python-sat 0.1.8.dev10__cp310-cp310-win_amd64.whl → 1.8.dev26__cp310-cp310-win_amd64.whl

pysat/pb.py

@@ -49,9 +49,9 @@
         Pseudo-Boolean Constraints into CNF*. SAT 2015. pp. 9-16
 
     A *pseudo-Boolean constraint* is a constraint of the form:
-    :math:`\left(\sum_{i=1}^n{a_i\cdot x_i}\\right)\circ k`, where
-    :math:`a_i\in\mathbb{N}`, :math:`x_i\in\{y_i,\\neg{y_i}\}`,
-    :math:`y_i\in\mathbb{B}`, and :math:`\circ\in\{\leq,=,\geq\}`.
+    :math:`\\left(\\sum_{i=1}^n{a_i\\cdot x_i}\\right)\\circ k`, where
+    :math:`a_i\\in\\mathbb{N}`, :math:`x_i\\in\\{y_i,\\neg{y_i}\\}`,
+    :math:`y_i\\in\\mathbb{B}`, and :math:`\\circ\\in\\{\\leq,=,\\geq\\}`.
     Pseudo-Boolean constraints arise in a number of important practical
     applications. Thus, several *encodings* of pseudo-Boolean constraints into
     CNF formulas are known [2]_. The list of pseudo-Boolean encodings
@@ -87,7 +87,7 @@
 #
 #==============================================================================
 import math
-from pysat.formula import CNF
+from pysat.formula import CNFPlus
 
 # checking whether or not pypblib is available and working as expected
 pblib_present = True
@@ -123,25 +123,29 @@ class EncType(object):
             sortnetwrk = 3
             adder      = 4
             binmerge   = 5
+            native     = 6
 
         The desired encoding can be selected either directly by its integer
         identifier, e.g. ``2``, or by its alphabetical name, e.g.
         ``EncType.seqcounter``.
 
         All the encodings are produced and returned as a list of clauses in
-        the :class:`pysat.formula.CNF` format.
+        the :class:`pysat.formula.CNFPlus` format.
 
         Note that the encoding type can be set to ``best``, in which case the
         encoder selects one of the other encodings from the list (in most
         cases, this invokes the ``bdd`` encoder).
     """
 
+    assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
+
     best       = 0
     bdd        = 1
     seqcounter = 2
     sortnetwrk = 3
     adder      = 4
     binmerge   = 5
+    native     = 6
 
     # mapping from internal encoding identifiers to the ones of PyPBLib
     _to_pbenc = {
@@ -171,7 +175,7 @@ class PBEnc(object):
         either a list of weighted literals or a list of unweighted literals
         followed by a list of weights, (2) an integer bound and an encoding
         type, each of these methods returns an object of class
-        :class:`pysat.formula.CNF` representing the resulting CNF formula.
+        :class:`pysat.formula.CNFPlus` representing the resulting CNF formula.
 
         Since the class is abstract, there is no need to create an object of
         it. Instead, the methods should be called directly as class methods,
@@ -240,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
@@ -268,31 +272,38 @@ class PBEnc(object):
             :type encoding: integer
             :type comparator: str
 
-            :rtype: :class:`pysat.formula.CNF`
+            :rtype: :class:`pysat.formula.CNFPlus`
         """
 
-        assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
-
-        if encoding < 0 or encoding > 5:
+        if encoding < 0 or encoding > 6:
             raise(NoSuchEncodingError(encoding))
 
-        assert lits, 'No literals are provided.'
+        # checking if the bound is meaningless for any encoding
+        if bound < 0:
+            raise ValueError('Wrong bound: {0}'.format(bound))
 
         assert not top_id or not vpool, \
                 'Use either a top id or a pool of variables but not both.'
 
+        # we are going to return this formula
+        ret = CNFPlus()
+
+        # if the list of literals is empty, return empty formula
+        if not lits:
+            return ret
+
         # preparing weighted literals
         if weights:
             assert len(lits) == len(weights), 'Same number of literals and weights is expected.'
-            wlits = [pblib.WeightedLit(l, w) for l, w in zip(lits, weights)]
+            wlits = [(l, w) for l, w in zip(lits, weights)]
         else:
             if all(map(lambda lw: (type(lw) in (list, tuple)) and len(lw) == 2, lits)):
                 # literals are already weighted
-                wlits = [pblib.WeightedLit(*wl) for wl in lits]
-                lits = zip(*lits)[0]  # unweighted literals for getting top_id
+                lits, weight = zip(*lits)  # unweighted literals for getting top_id
             elif all(map(lambda l: type(l) is int, lits)):
                 # no weights are provided => all weights are units
-                wlits = [pblib.WeightedLit(l, 1) for l in lits]
+                wlits = [(l, 1) for l in lits]
+                weights = [1 for l in lits]
             else:
                 assert 0, 'Incorrect literals given.'
 
@@ -300,13 +311,37 @@ class PBEnc(object):
         if vpool:
             top_id = vpool.top
 
-        if not top_id:
-            top_id = max(map(lambda x: abs(x), lits))
+        # choosing the maximum id among the current top and the list of literals
+        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:
+            ret.nv = top_id
+
+            if comparator == '<':
+                ret.atmosts = [(lits, bound, weights)]
+            elif comparator == '>':
+                ret.atmosts = [(list(map(lambda l: -l, lits)), sum(weights) - bound, weights)]
+            elif comparator:  # comparator == '='
+                ret.atmosts = [(lits, bound, weights),
+                        (list(map(lambda l: -l, lits)), sum(weights) - bound, weights)]
+
+            return ret
+
+        assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
 
         # pseudo-Boolean constraint and variable manager
-        constr = pblib.PBConstraint(wlits, EncType._to_pbcmp[comparator], bound)
+        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])
@@ -317,8 +352,8 @@ class PBEnc(object):
         pb2cnf.encode(constr, result, varmgr)
 
         # extracting clauses
-        ret = CNF(from_clauses=result.get_clauses())
-        ret.nv = max(ret.nv, top_id)  # needed if no auxiliary variable is used
+        ret.clauses = result.get_clauses()
+        ret.nv = max(ret.nv, top_id, varmgr.get_biggest_returned_auxvar())  # needed if no auxiliary variable is used
 
         # updating vpool if necessary
         if vpool:
@@ -332,12 +367,13 @@ 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
-            :math:`\sum_{i=1}^{n}{a_i\cdot x_i}\leq k`. The resulting set of
-            clauses is returned as an object of class :class:`.formula.CNF`.
+            :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}\\leq k`. The resulting set
+            of clauses is returned as an object of class
+            :class:`.formula.CNF`.
 
             The input list of literals can contain either integers or pairs
             ``(l, w)``, where ``l`` is an integer literal and ``w`` is an
@@ -347,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)
@@ -360,56 +402,62 @@ 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.CNF`
+            :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
-            :math:`\sum_{i=1}^{n}{a_i\cdot x_i}\geq k`. The method shares the
-            arguments and the return type with method :meth:`PBEnc.leq`.
+            :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}\\geq k`. The method shares
+            the arguments and the return type with method :meth:`PBEnc.leq`.
             Please, see it for details.
         """
 
         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}=
+            EqualsK constraint, i.e. of :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}=
             k`. The method shares the arguments and the return type with
             method :meth:`PBEnc.leq`. Please, see it for details.
         """
 
         return cls._encode(lits, weights=weights, bound=bound, top_id=top_id,
-                vpool=vpool, encoding=encoding, comparator='=')
+                           vpool=vpool, encoding=encoding, comparator='=',
+                           conditionals=conditionals)

pysat/process.py

@@ -43,6 +43,11 @@
     .. [1] Armin Biere, Matti Järvisalo, Benjamin Kiesl. *Preprocessing in SAT
         Solving*. In *Handbook of Satisfiability - Second Edition*. pp. 391-435
 
+    Importantly, the module provides a user with a possibility to freeze some
+    of the formula's variables so that they aren't eliminated, which may be
+    useful when unsatisfiability preserving processing is required - usable in
+    MCS and MUS enumeration as well as MaxSAT solving.
+
     Note that the numerous parameters used in CaDiCaL for tweaking the
     preprocessor's behavior are currently unavailable here. (Default values
     are used.)
@@ -216,7 +221,7 @@ class Processor(object):
 
     def process(self, rounds=1, block=False, cover=False, condition=False,
                 decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True):
+                subsume=True, vivify=True, freeze=[]):
         """
             Runs CaDiCaL's preprocessor for the internal formula for a given
             number of rounds and using the techniques specified in the
@@ -238,6 +243,11 @@ class Processor(object):
             vivification and transitive reduction if the corresponding flags
             are set.
 
+            Finally, note that the ``freeze`` argument can be used to keep
+            some of the variables of the original formula unchanged during
+            preprocessing. If convenient, the list may contain literals too
+            (negative integers).
+
             :param rounds: number of preprocessing rounds
             :type rounds: int
 
@@ -268,6 +278,9 @@ class Processor(object):
             :param vivify: apply clause vivification
             :type vivify: bool
 
+            :param freeze: a list of variables / literals to be kept during preprocessing
+            :type freeze: list(int) or any iterable(int)
+
             :return: processed formula
             :rtype: :class:`.CNF`
 
@@ -294,7 +307,8 @@ class Processor(object):
             self.status, result = self.cadical.process(rounds, block, cover,
                                                        condition, decompose,
                                                        elim, probe, probehbr,
-                                                       subsume, vivify)
+                                                       subsume, vivify,
+                                                       freeze)
 
             # making the status Boolean
             self.status = False if self.status == 20 else True