python-sat 1.8.dev23__tar.gz → 1.8.dev25__tar.gz

{python_sat-1.8.dev23/python_sat.egg-info → python_sat-1.8.dev25}/PKG-INFO

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

@@ -73,7 +73,7 @@
         >>> cnf = CNF(from_file='formula.wcnf.xz')
         >>>
         >>> # creating BBScan and running it
-        >>> with BBScan(cnf, solver='g3', lift=False, rotate=True) as bbscan:
+        >>> with BBScan(cnf, solver='g3', rotate=True) as bbscan:
         ...     bbone = bbscan.compute(algorithm='core')
         ...
         ...     # outputting the results
@@ -81,10 +81,10 @@
         ...         print(bbone)
         [1, -3]
 
-    Each of the available algorithms can be augmented with two simple
-    heuristics aiming at reducing satisfying assignments and, thus, filtering
-    out unnecessary literals: literal lifting and filtering rotatable
-    literals. Both are described in the aforementioned paper.
+    Each of the available algorithms can be augmented with a simple heuristic
+    aiming at reducing satisfying assignments and, thus, filtering out
+    unnecessary literals: namely, filtering rotatable literals. The heuristic
+    is described in the aforementioned paper.
 
     Note that most of the methods of the class :class:`BBScan` are made
     private. Therefore, the tool provides a minimalistic interface via which a
@@ -113,44 +113,42 @@ class BBScan:
     """
         A solver for computing all backbone literals of a given Boolean
         formula. It implements 6 algorithms for backbone computation described
-        in [1]_ augmented with two simple heuristics that can be speed up the
-        process.
+        in [1]_ augmented with a heuristic that can be speed up the process.
 
         Note that the input formula can be a :class:`.CNF` object but also any
         object of class :class:`.Formula`, thus the tool can used for
         computing backbone literals of non-clausal formulas.
 
         A user can select one of the SAT solvers available at hand
-        (``'glucose3'`` is used by default). The optional two heuristics can
-        be also specified as Boolean input arguments ``lift``, and ``rotate``
-        (turned off by default).
+        (``'glucose3'`` is used by default). The optional heuristic can be
+        also specified as a Boolean input arguments ``rotate`` (turned off by
+        default).
 
         The list of initialiser's arguments is as follows:
 
         :param formula: input formula whose backbone is sought
         :param solver: SAT oracle name
-        :param lift: apply literal lifting heuristic
         :param rotate: apply rotatable literal filtering
         :param verbose: verbosity level
 
         :type formula: :class:`.Formula` or :class:`.CNF`
         :type solver: str
-        :type lift: bool
         :type rotate: bool
         :type verbose: int
     """
 
-    def __init__(self, formula, solver='g3', lift=False, rotate=False, verbose=0):
+    def __init__(self, formula, solver='g3', rotate=False, verbose=0):
         """
             Constructor.
         """
 
         self.formula = formula
+        self.focuscl = list(range(len(formula.clauses))) if rotate else []
         self.verbose = verbose
         self.oracle  = None
 
         # implicant reduction heuristics
-        self.lift, self.rotate = lift, rotate
+        self.rotate = rotate
 
         # basic stats
         self.calls, self.filtered = 0, 0
@@ -230,12 +228,26 @@ class BBScan:
         """
 
         self.calls += 1
+        trivial = []
 
         if self.oracle.solve():
-            self.model = self.oracle.get_model()
+            self.model = set(self.oracle.get_model())
             if focus_on is not None:
-                model = set(self.model)
-                self.model = [l for l in focus_on if l in model]
+                self.model &= set(focus_on)
+
+                # if filtering rotatable literals is requested then
+                # we should be clever about the clauses to traverse
+                if self.rotate:
+                    self.focuscl = []
+                    for i, cl in enumerate(self.formula):
+                        for l in cl:
+                            if l in self.model:
+                                if len(cl) == 1:
+                                    trivial.append(l)
+                                    self.model.remove(l)
+                                else:
+                                    self.focuscl.append(i)
+                                break
         else:
             raise ValueError('Unsatisfiable formula')
 
@@ -258,50 +270,36 @@ class BBScan:
         else:
             assert 0, f'Unknown algorithm: {algorithm}'
 
-        return sorted(result, key=lambda l: abs(l))
-
-    def _get_implicant(self, model):
-        """
-            Simple literal lifting used to reduce a given model.
-        """
-
-        res, model = set(), set(model)
-
-        # traversing the clauses and collecting all literals
-        # that satisfy at least one clause of the formula
-        for cl in self.formula:
-            res |= set([l for l in cl if l in model])
-
-        return list(res)
+        return sorted(trivial + result, key=lambda l: abs(l))
 
     def _filter_rotatable(self, model):
         """
             Filter out rotatable literals.
         """
 
-        units, model = set([]), set(model)
+        def get_unit(cl):
+            # this is supposed to be a faster alternative to the
+            # complete clause traversal with a conditional inside
+            unit = None
+            for l in cl:
+                if l in model:
+                    if unit:
+                        return
+                    else:
+                        unit = l
+            return unit
+
+        # result of this procedure
+        units = set([])
 
         # determining unit literals
-        for cl in self.formula:
-            satisfied = [l for l in cl if l in model]
-            if len(satisfied) == 1:
-                units.add(satisfied[0])
+        for i in self.focuscl:
+            unit = get_unit(self.formula.clauses[i])
+            if unit:
+                units.add(unit)
 
         self.filtered += len(model) - len(units)
-        return list(units)
-
-    def _process_model(self, model):
-        """
-            Heuristically reduce a model.
-        """
-
-        if self.lift:
-            model = self._get_implicant(model)
-
-        if self.rotate:
-            model = self._filter_rotatable(model)
-
-        return model
+        return units
 
     def _compute_enum(self, focus_on=None):
         """
@@ -312,7 +310,7 @@ class BBScan:
             print('c using enumeration-based algorithm')
 
         # initial backbone estimate contains all literals
-        bbone = set(self.model) if focus_on is None else set(focus_on)
+        bbone = self.model if focus_on is None else focus_on
 
         while bbone:
             # counting the number of calls
@@ -322,15 +320,14 @@ class BBScan:
             if not self.oracle.solve():
                 break
 
-            coex = set(self.oracle.get_model())
-            self.model = [l for l in bbone if l in coex]
-            self.model = self._process_model(self.model)
-
             # updating backbone estimate - intersection
-            bbone &= set(self.model)
+            bbone &= set(self.oracle.get_model())
+
+            if self.rotate:
+                bbone = self._filter_rotatable(bbone)
 
             # blocking the previously found implicant
-            self.oracle.add_clause([-l for l in self.model])
+            self.oracle.add_clause([-l for l in bbone])
 
         return list(bbone)
 
@@ -342,6 +339,8 @@ class BBScan:
         if self.verbose:
             print('c using iterative algorithm')
 
+        # initial estimate
+        # using sets for model and assumps to save filtering time
         bbone, model = [], self.model if focus_on is None else focus_on
 
         while model:
@@ -357,9 +356,10 @@ class BBScan:
             else:
                 # it isn't and we've got a counterexample
                 # => using it to filter out more literals
-                coex = set(self.oracle.get_model())
-                model = [l for l in model if l in coex]
-                model = self._process_model(model)
+                model &= set(self.oracle.get_model())
+
+                if self.rotate:
+                    model = self._filter_rotatable(model)
 
         return bbone
 
@@ -372,7 +372,7 @@ class BBScan:
             print('c using complement of backbone estimate algorithm')
 
         # initial estimate
-        bbone = set(self.model) if focus_on is None else set(focus_on)
+        bbone = self.model if focus_on is None else focus_on
 
         # iterating until we find the backbone or determine there is none
         while bbone:
@@ -385,23 +385,23 @@ class BBScan:
             if self.oracle.solve() == False:
                 break
             else:
-                coex = set(self.oracle.get_model())
-                model = [l for l in bbone if l in coex]
-                model = self._process_model(model)
-                bbone &= set(model)
+                bbone &= set(self.oracle.get_model())
+
+                if self.rotate:
+                    bbone = self._filter_rotatable(bbone)
 
         return list(bbone)
 
     def _compute_chunking(self, chunk_size=100, focus_on=None):
         """
-            Algorithm 5: Chunking algorithm.
+            Chunking algorithm.
         """
 
         if self.verbose:
             print('c using chunking algorithm, with chunk size:', chunk_size)
 
         # initial estimate
-        bbone, model = [], self.model if focus_on is None else focus_on
+        bbone, model = [], list(self.model if focus_on is None else focus_on)
 
         # we are going to use clause selectors
         vpool = IDPool(start_from=self.formula.nv + 1)
@@ -427,7 +427,9 @@ class BBScan:
             else:
                 coex = set(self.oracle.get_model())
                 model = [l for l in model if l in coex]
-                model = self._process_model(model)
+
+                if self.rotate:
+                    model = list(self._filter_rotatable(set(model)))
 
         return bbone
 
@@ -440,21 +442,24 @@ class BBScan:
             print('c using core-based algorithm')
 
         # initial estimate
+        # using sets for model and assumps to save filtering time
         bbone, model = [], self.model if focus_on is None else focus_on
 
         # iterating until we find the backbone or determine there is none
         while model:
             # flipping all the literals
-            assumps = [-l for l in model]
+            assumps = {-l for l in model}
 
             # getting unsatisfiable cores with them
             while True:
                 self.calls += 1
 
                 if self.oracle.solve(assumptions=assumps):
-                    coex = set(self.oracle.get_model())
-                    model = [l for l in model if l in coex]
-                    model = self._process_model(model)
+                    model &= set(self.oracle.get_model())
+
+                    if self.rotate:
+                        model  = self._filter_rotatable(model)
+
                     break
 
                 else:
@@ -464,18 +469,12 @@ class BBScan:
                         self.oracle.add_clause([-core[0]])
 
                         # remove from the working model
-                        indx = model.index(-core[0])  # may be slow
-                        if indx < len(model) - 1:
-                            model[indx] = model.pop()
-                        else:
-                            model.pop()
+                        model.remove(-core[0])
 
                     # filtering out unnecessary flipped literals
-                    core = set(core)
-                    assumps = [l for l in assumps if l not in core]
+                    assumps -= set(core)
 
                     if not assumps:
-                        # resorting to the iterative traversal algorithm
                         self.model = model
                         return bbone + self._compute_iter()
 
@@ -490,7 +489,7 @@ class BBScan:
             print('c using core-based chunking, with chunk size:', chunk_size)
 
         # initial estimate
-        bbone, model = [], self.model if focus_on is None else focus_on
+        bbone, model = [], list(self.model if focus_on is None else focus_on)
 
         # we are going to use clause selectors
         vpool = IDPool(start_from=self.formula.nv + 1)
@@ -501,7 +500,7 @@ class BBScan:
             size = min(chunk_size, len(model))
 
             # flipping all the literals
-            assumps, skipped = [-model.pop() for i in range(size)], []
+            assumps, skipped = {-model.pop() for i in range(size)}, set()
 
             # getting unsatisfiable cores with them
             while True:
@@ -510,7 +509,9 @@ class BBScan:
                 if self.oracle.solve(assumptions=assumps):
                     coex = set(self.oracle.get_model())
                     model = [l for l in model if l in coex]
-                    model = self._process_model(model)
+
+                    if self.rotate:
+                        model = list(self._filter_rotatable(set(model)))
 
                     if skipped:
                         bbone += self._compute_iter(focus_on=skipped)
@@ -526,11 +527,10 @@ class BBScan:
                         self.oracle.add_clause([-core[0]])
                     else:
                         # all removed literals are going to be tested later
-                        skipped += [-l for l in core]
+                        skipped |= {-l for l in core}
 
                     # filtering out unnecessary flipped literals
-                    core = set(core)
-                    assumps = [l for l in assumps if l not in core]
+                    assumps -= set(core)
 
                     if not assumps:
                         # resorting to the iterative traversal algorithm
@@ -561,11 +561,10 @@ def parse_options():
 
     try:
         opts, args = getopt.getopt(sys.argv[1:],
-                                   'a:c:hlrs:v',
+                                   'a:c:hrs:v',
                                    ['algo=',
                                     'chunk=',
                                     'help',
-                                    'lift',
                                     'rotate',
                                     'solver=',
                                     'verbose'])
@@ -576,7 +575,6 @@ def parse_options():
 
     algo = 'iter'
     chunk = 100
-    lift = False
     rotate = False
     solver = 'g3'
     verbose = 0
@@ -594,8 +592,6 @@ def parse_options():
         elif opt in ('-h', '--help'):
             usage()
             sys.exit(0)
-        elif opt in ('-l', '--lift'):
-            lift = True
         elif opt in ('-r', '--rotate'):
             rotate = True
         elif opt in ('-s', '--solver'):
@@ -605,7 +601,7 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return algo, chunk, lift, rotate, solver, verbose, args
+    return algo, chunk, rotate, solver, verbose, args
 
 
 #
@@ -622,7 +618,6 @@ def usage():
     print('        -c, --chunk=<int,float>    Chunk size for chunking algorithms')
     print('                                   Available values: [1 .. INT_MAX] or (0 .. 1] (default: 100)')
     print('        -h, --help                 Show this message')
-    print('        -l, --lift                 Apply literal lifting for heuristic model reduction')
     print('        -r, --rotate               Heuristically filter out rotatable literals')
     print('        -s, --solver=<string>      SAT solver to use')
     print('                                   Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default: g3)')
@@ -632,7 +627,7 @@ def usage():
 #
 #==============================================================================
 if __name__ == '__main__':
-    algo, chunk, lift, rotate, solver, verbose, files = parse_options()
+    algo, chunk, rotate, solver, verbose, files = parse_options()
 
     if files:
         # read CNF from file
@@ -645,8 +640,7 @@ if __name__ == '__main__':
                                                             len(formula.clauses)))
 
         # computing the backbone
-        with BBScan(formula, solver=solver, lift=lift, rotate=rotate,
-                    verbose=verbose) as bbscan:
+        with BBScan(formula, solver=solver, rotate=rotate, verbose=verbose) as bbscan:
             try:
                 bbone = bbscan.compute(algorithm=algo, chunk_size=chunk)
 

{python_sat-1.8.dev23 → python_sat-1.8.dev25}/pysat/__init__.py

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

{python_sat-1.8.dev23 → python_sat-1.8.dev25}/pysat/_fileio.py

@@ -189,7 +189,7 @@ class FileObject(object):
             self.ctype = 'bzip2'
         elif ext in ('.xz', '.lzma'):
             self.ctype = 'lzma'
-        elif ext == 'zst':
+        elif ext == '.zst':
             self.ctype = 'zstd'
         else:
             self.ctype = None

{python_sat-1.8.dev23 → python_sat-1.8.dev25}/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.dev23 → python_sat-1.8.dev25}/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.dev23 → python_sat-1.8.dev25/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.8.dev23
+Version: 1.8.dev25
 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.dev23 → python_sat-1.8.dev25}/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.dev25/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.dev25/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