python-sat 1.9.dev16__cp313-cp313-win_amd64.whl → 1.9.dev18__cp313-cp313-win_amd64.whl

pysat/__init__.py

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

pysat/card.py

@@ -195,46 +195,38 @@ class CardEnc(object):
     """
 
     @classmethod
-    def _update_vids(cls, cnf, inp, vpool):
+    def _update_vids(cls, cnf, top, vpool):
         """
-            Update variable ids in the given formula and id pool. The literals
-            serving as the input to the cardinality constraint are not
-            updated.
+            Update the id pool to account for the auxiliary variables of the
+            given formula, i.e. all variables larger than ``top``. If these
+            overlap with the ranges marked as occupied in the pool, they are
+            renumbered to free ids. Variables up to ``top``, e.g. the input
+            literals of the constraint, are not updated.
 
-            :param cnf: a list of literals in the sum.
-            :param inp: the list of input literals
-            :param vpool: the value of bound :math:`k`.
+            :param cnf: the encoding of the constraint
+            :param top: the largest variable id of the input
+            :param vpool: variable pool to update
 
             :type cnf: :class:`.formula.CNFPlus`
-            :type inp: list(int)
+            :type top: int
             :type vpool: :class:`.formula.IDPool`
         """
 
-        top, vmap = max(inp + [vpool.top]), {}  # current top and variable mapping
+        # the pool must not hand out the input ids, nor the rest of an
+        # occupied range that the input ids reach into
+        vpool.top = top
+        while vpool._occupied and vpool._occupied[0][0] <= vpool.top:
+            vpool.top = max(vpool.top, vpool._occupied[0][1])
+            vpool._occupied.pop(0)
 
-        # we are going to use this to check if literals are input
-        inp = set([abs(l) for l in inp])
-
-        # creating a new variable mapping, taking into
-        # account variables marked as "occupied"
-        while top < cnf.nv:
-            top += 1
-
-            # skipping the input literals
-            if top in inp:
-                vmap[top] = top
-                continue
-
-            vpool.top += 1
-
-            while vpool._occupied and vpool.top >= vpool._occupied[0][0]:
-                if vpool.top <= vpool._occupied[0][1] + 1:
-                    vpool.top = vpool._occupied[0][1] + 1
-
-                vpool._occupied.pop(0)
+        if vpool.top == top and not (vpool._occupied and vpool._occupied[0][0] <= cnf.nv):
+            # the auxiliary variables already have free ids
+            vpool.top = max(vpool.top, cnf.nv)
+            return
 
-            # mapping this literal to a free one
-            vmap[top] = vpool.top
+        # mapping each auxiliary variable to a free id,
+        # taking into account variables marked as "occupied"
+        vmap = {var: vpool._next() for var in range(top + 1, cnf.nv + 1)}
 
         # updating the clauses
         for cl in cnf.clauses:
@@ -296,12 +288,7 @@ class CardEnc(object):
 
             # updating vpool if necessary
             if vpool:
-                if vpool._occupied and vpool.top <= vpool._occupied[0][0] <= ret.nv:
-                    cls._update_vids(ret, lits, vpool)
-                else:
-                    # here, ret.nv id is assumed to be larger than the top id
-                    vpool.top = ret.nv - 1
-                    vpool._next()
+                cls._update_vids(ret, top_id, vpool)
 
         return ret
 
@@ -397,12 +384,7 @@ class CardEnc(object):
 
             # updating vpool if necessary
             if vpool:
-                if vpool._occupied and vpool.top <= vpool._occupied[0][0] <= ret.nv:
-                    cls._update_vids(ret, lits, vpool)
-                else:
-                    # here, ret.nv id is assumed to be larger than the top id
-                    vpool.top = ret.nv - 1
-                    vpool._next()
+                cls._update_vids(ret, top_id, vpool)
 
         return ret
 

pysat/integer.py

@@ -228,7 +228,9 @@ import numbers
 from pysat.card import CardEnc, EncType as CardEncType
 from pysat.engines import BooleanEngine
 from pysat.formula import CNF, Formula
-from pysat.pb import PBEnc, EncType as PBEncType
+from pysat.pb import PBEnc, EncType as PBEncType, NoSuchEncodingError, \
+        _pindakaas_db, _pindakaas_cnf
+import pindakaas  # after pysat.pb, which checks that it is installed
 
 
 # importable components
@@ -577,7 +579,8 @@ class Integer:
         """
 
         def is_satisfied(lit):
-            return model[abs(lit) - 1] == lit
+            # a literal beyond the model occurs in no clause, so it is free
+            return abs(lit) <= len(model) and model[abs(lit) - 1] == lit
 
         if self.encoding == 'direct':
             for value in self.domain:
@@ -752,6 +755,45 @@ class Integer:
 
         return wmap, shift
 
+    def _linear_term(self, kind, wmap):
+        """
+            Inverse of :meth:`linearize` for one kind of literal. Given a map
+            from domain values ``v`` to pairs ``(lit, weight)``, where ``lit``
+            is the literal of :math:`x \\geq v` (``kind == 'ge'``) or of
+            :math:`x = v` (``kind == 'eq'``), possibly negated, return
+            ``(coeff, const)`` such that the weighted sum of the literals
+            equals ``coeff * X + const``. Return ``None`` if the map does not
+            have this form.
+
+            :param kind: ``'ge'`` or ``'eq'``
+            :param wmap: literals and their weights by domain value
+            :type kind: str
+            :type wmap: dict
+
+            :rtype: tuple or None
+        """
+
+        if kind == 'ge':
+            # x = lb + sum_k [x >= k] and ub - x = sum_k -[x >= k]
+            signs = {lit > 0 for lit, _ in wmap.values()}
+            wvals = {wght for _, wght in wmap.values()}
+            if len(wmap) != self.ub - self.lb or len(signs) != 1 or len(wvals) != 1:
+                return None
+
+            wght = wvals.pop()
+            return (wght, -wght * self.lb) if signs.pop() else (-wght, wght * self.ub)
+
+        # direct literals, the weights must be affine in the values
+        if any(lit < 0 for lit, _ in wmap.values()):
+            return None
+
+        wvals = [wmap[v][1] if v in wmap else 0 for v in self.domain]
+        coeff = wvals[1] - wvals[0] if len(wvals) > 1 else 0
+        if any(w != wvals[0] + coeff * i for i, w in enumerate(wvals)):
+            return None
+
+        return coeff, wvals[0] - coeff * self.lb
+
     def _add_channeling(self):
         """
             Clauses linking direct and order encodings.
@@ -2142,26 +2184,45 @@ class IntegerEngine(BooleanEngine):
         self._add_clause([s1, s2], selv=selv)
         return selv
 
-    def clausify(self, cardenc=CardEncType.seqcounter, pbenc=PBEncType.best):
+    def clausify(self, cardenc=CardEncType.seqcounter, pbenc=PBEncType.best,
+                 intenc=PBEncType.best):
         """
-            Clausify all constraints and return a CNF encoding. All linear
-            constraints are converted using the user-specified cardinality and
-            pseudo-Boolean encoding. The former are utilized for unweighted
-            constraints, while the latter are utilized for weighted
-            constraints.
+            Clausify all constraints and return a CNF encoding.
+
+            Linear constraints over :class:`Integer` variables are encoded by
+            Pindakaas as *integer* linear constraints, using the encoding
+            ``intenc``. The literals of each :class:`Integer` are passed to
+            Pindakaas as an integer variable, which lets it use integer
+            encodings, e.g. the mixed radix encoding.
+
+            The remaining linear constraints, and all of them if ``intenc``
+            is ``None``, are converted using the user-specified cardinality
+            and pseudo-Boolean encoding. The former are utilized for
+            unweighted constraints, while the latter are utilized for
+            weighted constraints.
 
-            Note that parameters ``cardenc`` and ``pbenc`` default to
-            :attr:`.card.EncType.seqcounter` and
-            :class:`pysat.pb.EncType.best`, respectively.
+            Note that parameters ``cardenc``, ``pbenc`` and ``intenc``
+            default to :attr:`.card.EncType.seqcounter`,
+            :class:`pysat.pb.EncType.best` and
+            :class:`pysat.pb.EncType.best`, respectively. The *native*
+            encodings produce no clauses and raise :class:`ValueError`.
 
             :param cardenc: cardinality encoding for unweighted constraints
             :param pbenc: PB encoding for weighted constraints
+            :param intenc: encoding for integer linear constraints, or ``None``
             :type cardenc: int
             :type pbenc: int
+            :type intenc: int or None
 
             :rtype: :class:`pysat.formula.CNF`
         """
 
+        # native constraints are not clauses, and would be lost
+        if cardenc == CardEncType.native or PBEncType.native in (pbenc, intenc):
+            raise ValueError('Native encodings cannot be clausified')
+        if intenc is not None and intenc not in PBEncType._to_encoder:
+            raise NoSuchEncodingError(intenc)
+
         # we are going to store the resulting formula here
         res = CNF()
 
@@ -2184,8 +2245,19 @@ class IntegerEngine(BooleanEngine):
         # (e.g. reified disjunctions) already cached in the engine
         res.extend(self.clauses)
 
+        # separating integer linear constraints from Boolean ones
+        lcons, iconss = self._lcons, []
+        if intenc is not None:
+            lcons = []
+            for cs in self._lcons:
+                icons = self._integer_terms(cs, vpool)
+                if icons:
+                    iconss.append(icons)
+                else:
+                    lcons.append(cs)
+
         # the main part is to encode all linear constraints
-        for cs in self._lcons:
+        for cs in lcons:
             lits, bound = cs[1][0], cs[1][1]
             weights = {} if len(cs[1]) == 2 else cs[1][2]
 
@@ -2200,13 +2272,11 @@ class IntegerEngine(BooleanEngine):
 
             # we have a common weight wght => cardinality constraint
             if wght is not None:
-                new_bound = bound // wght
-                if isinstance(new_bound, Decimal):
-                    new_bound = int(new_bound)
-                elif isinstance(new_bound, float):
-                    new_bound = int(math.floor(new_bound))
+                if isinstance(bound, Decimal):
+                    # Decimal's // rounds towards zero, not down
+                    new_bound = math.floor(bound / wght)
                 else:
-                    new_bound = int(new_bound)
+                    new_bound = int(math.floor(bound // wght))
 
                 if new_bound < 0:
                     # the bound is negative => constraint is unsatisfiable
@@ -2235,20 +2305,112 @@ class IntegerEngine(BooleanEngine):
             wlist = [int(w) if not isinstance(w, Decimal) else int(w)
                             for w in wlist]
 
+            if bound_int < 0:
+                # the weights are non-negative => unsatisfiable
+                res.append([])
+                continue
+
             enc = PBEnc.atmost(lits=lits, weights=wlist, bound=bound_int,
                                vpool=vpool, encoding=pbenc)
             res.extend(enc.clauses)
 
+        # integer linear constraints go last, as they share one encoding
+        if iconss:
+            res.extend(self._clausify_integer(iconss, vpool, intenc))
+
         return res
 
+    def _integer_terms(self, cs, vpool):
+        """
+            Recover the integer structure of a linear constraint. The
+            literals of each :class:`Integer` recognized by
+            :meth:`Integer._linear_term` become a single integer term.
+            Return a triple ``(terms, rest, bound)``, where ``terms`` is a
+            list of ``(var, kind, coeff)``, ``rest`` is a list of the
+            remaining weighted literals, and the constraint is ``terms +
+            rest <= bound``. Return ``None`` if there are no integer terms or
+            if the numbers are not integers.
+        """
+
+        _, _, bound, lits, weights = self._linear_key(cs)
+
+        if not self._intlike(bound) or not all(self._intlike(weights[l]) for l in lits):
+            return None
+
+        # grouping the literals by their integer variable and kind
+        groups, rest = defaultdict(dict), []
+        for l in lits:
+            obj, wght = vpool.obj(abs(l)), int(weights[l])
+            if isinstance(obj, tuple) and len(obj) == 3 and isinstance(obj[0], Integer):
+                group = groups[obj[0], obj[1]]
+                if obj[2] not in group:
+                    group[obj[2]] = (l, wght)
+                    continue
+
+            # a Boolean literal, or the negation of one already in its group
+            rest.append((l, wght))
+
+        terms, bound = [], int(bound)
+        for (var, kind), wmap in groups.items():
+            term = var._linear_term(kind, wmap)
+            if term is None:
+                rest.extend(wmap.values())
+            else:
+                coeff, const = term
+                if coeff:
+                    terms.append((var, kind, coeff))
+                bound -= const
+
+        return (terms, rest, bound) if terms else None
+
+    def _clausify_integer(self, iconss, vpool, intenc):
+        """
+            Encode integer linear constraints, as returned by
+            :meth:`_integer_terms`, with Pindakaas. Return the list of
+            clauses.
+        """
+
+        encoder, options = PBEncType._to_encoder[intenc]
+        Lit = pindakaas.Lit.from_raw
+
+        # new variables must also avoid literals that are not in the pool
+        top_id = max([vpool.top] + [abs(l) for _, rest, _ in iconss for l, _ in rest])
+        db = _pindakaas_db(top_id)
+        ivars = {}  # integer variables, created lazily
+
+        def ivar(var, kind):
+            if (var, kind) not in ivars:
+                if kind == 'ge':
+                    lits = [var.ge(k) for k in range(var.lb + 1, var.ub + 1)]
+                    make = db.int_var_from_order_literals
+                else:
+                    lits = [var.equals(v) for v in var.domain]
+                    make = db.int_var_from_direct_literals
+                ivars[var, kind] = make(var.domain, [Lit(l) for l in lits])
+            return ivars[var, kind]
+
+        try:
+            for terms, rest, bound in iconss:
+                lhs = 0
+                for var, kind, coeff in terms:
+                    lhs += coeff * ivar(var, kind)
+                for l, w in rest:
+                    lhs += w * Lit(l)
+
+                db.add_encoding(lhs <= bound, encoder, **options)
+        except pindakaas.Unsatisfiable:
+            return [[]]
+
+        return _pindakaas_cnf(db, top_id, vpool=vpool).clauses
+
     @staticmethod
     def _intlike(value):
         """
             Checking if the value can be converted to integer.
         """
 
-        # yes, nothing to do
-        if isinstance(value, numbers.Integral):
+        # yes, nothing to do (plain ints first, as the ABC check is slow)
+        if type(value) is int or isinstance(value, numbers.Integral):
             return True
 
         # yes, it's a convertable decimal

pysat/pb.py

@@ -25,28 +25,23 @@
 
     .. note::
 
-        Functionality of this module is available only if the `PyPBLib`
+        Functionality of this module is available only if the `Pindakaas`
         package is installed, e.g. from PyPI:
 
         .. code-block::
 
-            $ pip install pypblib
+            $ pip install python-sat[pb]
 
-    This module provides access to the basic functionality of the `PyPBLib
-    library <https://pypi.org/project/pypblib/>`__ developed by the `Logic
-    Optimization Group <http://ulog.udl.cat/>`__ of the University of Lleida.
-    PyPBLib provides a user with an extensive Python API to the well-known
-    `PBLib library <http://tools.computational-logic.org/content/pblib.php>`__
-    [1]_. Note the PyPBLib has a number of `additional features
-    <http://hardlog.udl.cat/static/doc/pypblib/html/index.html>`__ that cannot
-    be accessed through PySAT *at this point*. (One concrete example is a
-    range of cardinality encodings, which clash with the internal
-    :mod:`pysat.card` module.) If a user needs some functionality of PyPBLib
-    missing in this module, he/she may apply PyPBLib as a standalone library,
-    when working with PySAT.
+    This module provides access to the pseudo-Boolean encodings of the
+    `Pindakaas library <https://pypi.org/project/pindakaas/>`__ [1]_, a Rust
+    library for encoding pseudo-Boolean and integer constraints into CNF.
+    Pindakaas has a number of additional features (e.g. integer variables
+    and further encodings) that are not accessible through this module. If
+    a user needs any of them, Pindakaas can be used as a standalone library
+    alongside PySAT.
 
-    .. [1] Tobias Philipp, Peter Steinke. *PBLib - A Library for Encoding
-        Pseudo-Boolean Constraints into CNF*. SAT 2015. pp. 9-16
+    .. [1] Hendrik Bierlee, Jip J. Dekker. *Pindakaas*. Software.
+        https://doi.org/10.5281/zenodo.10851855
 
     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
@@ -56,7 +51,9 @@
     applications. Thus, several *encodings* of pseudo-Boolean constraints into
     CNF formulas are known [2]_. The list of pseudo-Boolean encodings
     supported by this module include BDD [3]_ [4]_, sequential weight counters
-    [5]_, sorting networks [3]_, adder networks [3]_, and binary merge [6]_.
+    [5]_, sorting networks [3]_, adder networks [3]_, binary merge [6]_, the
+    watchdog encoding [7]_, the generalized totalizer [8]_, and the mixed
+    radix encoding [9]_.
     Access to all cardinality encodings can be made through the main class of
     this module, which is :class:`.PBEnc`.
 
@@ -79,6 +76,17 @@
         Translation of Pseudo-Boolean Constraints into CNF Such That
         Generalized Arc Consistency Is Maintained*. KI. 2014. pp. 123-134
 
+    .. [7] Olivier Bailleux, Yacine Boufkhad, Olivier Roussel. *New
+        Encodings of Pseudo-Boolean Constraints into CNF*. SAT 2009.
+        pp. 181-194
+
+    .. [8] Saurabh Joshi, Ruben Martins, Vasco Manquinho. *Generalized Totalizer
+        Encoding for Pseudo-Boolean Constraints*. CP 2015. pp. 200-209
+
+    .. [9] Anpeng Zha, Miyuki Koshimura, Hiroshi Fujita. *N-level Modulo-based
+        CNF Encodings of Pseudo-Boolean Constraints for MaxSAT*. Constraints
+        24(2). 2019. pp. 133-161
+
     ==============
     Module details
     ==============
@@ -86,15 +94,16 @@
 
 #
 #==============================================================================
-import math
+import operator
+from pysat.card import CardEnc
 from pysat.formula import CNFPlus
 
-# checking whether or not pypblib is available and working as expected
-pblib_present = True
+# checking whether or not pindakaas is available
+pindakaas_present = True
 try:
-    from pypblib import pblib
+    import pindakaas
 except ImportError:
-    pblib_present = False
+    pindakaas_present = False
 
 
 #
@@ -124,6 +133,9 @@ class EncType(object):
             adder      = 4
             binmerge   = 5
             native     = 6
+            watchdog   = 7
+            totalizer  = 8
+            mixedradix = 9
 
         The desired encoding can be selected either directly by its integer
         identifier, e.g. ``2``, or by its alphabetical name, e.g.
@@ -132,12 +144,16 @@ class EncType(object):
         All the encodings are produced and returned as a list of clauses in
         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).
+        Note that the encoding type can be set to ``best``, in which case
+        Pindakaas uses its default encoder for the shape of the constraint
+        (e.g. the totalizer for PB and cardinality constraints). Any other
+        encoding is applied to *every* shape of constraint, including
+        cardinality and AtMostOne constraints. Finally, ``binmerge`` is the
+        ``watchdog`` encoding of Pindakaas, counting with sorting networks
+        rather than totalizers.
     """
 
-    assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
+    assert pindakaas_present, 'Package \'pindakaas\' is unavailable. Install it with \'pip install python-sat[pb]\'.'
 
     best       = 0
     bdd        = 1
@@ -146,23 +162,61 @@ class EncType(object):
     adder      = 4
     binmerge   = 5
     native     = 6
-
-    # mapping from internal encoding identifiers to the ones of PyPBLib
-    _to_pbenc = {
-            best:       pblib.PB_BEST,
-            bdd:        pblib.PB_BDD,
-            seqcounter: pblib.PB_SWC,
-            sortnetwrk: pblib.PB_SORTINGNETWORKS,
-            adder:      pblib.PB_ADDER,
-            binmerge:   pblib.PB_BINARY_MERGE
+    watchdog   = 7
+    totalizer  = 8
+    mixedradix = 9
+
+    # mapping from internal encoding identifiers to Pindakaas encoders and
+    # their options
+    _to_encoder = {
+            best:       (None, {}),
+            bdd:        (pindakaas.Encoder.DECISION_DIAGRAM, {}),
+            seqcounter: (pindakaas.Encoder.SEQUENTIAL_COUNTER, {}),
+            sortnetwrk: (pindakaas.Encoder.SORTING_NETWORK, {}),
+            adder:      (pindakaas.Encoder.ADDER, {}),
+            binmerge:   (pindakaas.Encoder.WATCHDOG, {'sorting_networks': True}),
+            watchdog:   (pindakaas.Encoder.WATCHDOG, {}),
+            totalizer:  (pindakaas.Encoder.TOTALIZER, {}),
+            mixedradix: (pindakaas.Encoder.MIXED_RADIX, {})
         }
 
-    # mapping from internal comparator identifiers to the ones of PyPBLib
-    _to_pbcmp = {
-            '<': pblib.LEQ,
-            '>': pblib.GEQ,
-            '=': pblib.BOTH
-        }
+    # mapping from internal comparator identifiers to operators
+    _to_cmp = {'<': operator.le, '>': operator.ge, '=': operator.eq}
+
+
+#
+#==============================================================================
+def _pindakaas_db(top_id):
+    """
+        Create an empty ``pindakaas.CNF``, in which all new (auxiliary)
+        variables are larger than ``top_id``.
+    """
+
+    db = pindakaas.CNF()
+    db.new_vars(top_id)
+
+    return db
+
+
+#
+#==============================================================================
+def _pindakaas_cnf(db, top_id, vpool=None):
+    """
+        Convert the clauses of a ``pindakaas.CNF`` created by
+        :func:`_pindakaas_db` into a :class:`pysat.formula.CNFPlus`. If
+        ``vpool`` is given, it is updated to account for the auxiliary
+        variables, i.e. those larger than ``top_id``.
+    """
+
+    ret = CNFPlus()
+    ret.clauses = db._clauses_as_int()
+    ret.nv = len(db.variables())
+
+    # updating vpool if necessary
+    if vpool:
+        CardEnc._update_vids(ret, top_id, vpool)
+
+    return ret
 
 
 #
@@ -187,66 +241,17 @@ class PBEnc(object):
             >>> from pysat.pb import *
             >>> cnf = PBEnc.atmost(lits=[1, 2, 3], weights=[1, 2, 3], bound=3)
             >>> print(cnf.clauses)
-            [[4], [-1, -5], [-2, -5], [5, -3, -6], [6]]
+            [[-5, 4], [-6, 5], [-2, 5], [-1, 4], [-1, -2, 6], [-4, -3]]
             >>> cnf = PBEnc.equals(lits=[1, 2, 3], weights=[1, 2, 3], bound=3, encoding=EncType.bdd)
             >>> print(cnf.clauses)
-            [[4], [-5, -2], [-5, 2, -1], [-5, -1], [-6, 1], [-7, -2, 6], [-7, 2], [-7, 6], [-8, -3, 5], [-8, 3, 7], [-8, 5, 7], [8]]
+            [[-1, 5], [1, -5], [-2, 4], [-5, 4], [2, -4], [5, -4], [-4, -3], [4, 3]]
     """
 
-    @classmethod
-    def _update_vids(cls, cnf, inp, vpool):
-        """
-            Update variable ids in the given formula and id pool. The literals
-            serving as the input to the cardinality constraint are not
-            updated.
-
-            :param cnf: a list of literals in the sum.
-            :param inp: the list of input literals
-            :param vpool: the value of bound :math:`k`.
-
-            :type cnf: :class:`.formula.CNFPlus`
-            :type inp: list(int)
-            :type vpool: :class:`.formula.IDPool`
-        """
-
-        top, vmap = max(inp + [vpool.top]), {}  # current top and variable mapping
-
-        # we are going to use this to check if literals are input
-        inp = set([abs(l) for l in inp])
-
-        # creating a new variable mapping, taking into
-        # account variables marked as "occupied"
-        while top < cnf.nv:
-            top += 1
-
-            # skipping the input literals
-            if top in inp:
-                vmap[top] = top
-                continue
-
-            vpool.top += 1
-
-            while vpool._occupied and vpool.top >= vpool._occupied[0][0]:
-                if vpool.top <= vpool._occupied[0][1] + 1:
-                    vpool.top = vpool._occupied[0][1] + 1
-
-                vpool._occupied.pop(0)
-
-            # mapping this literal to a free one
-            vmap[top] = vpool.top
-
-        # updating the clauses
-        for cl in cnf.clauses:
-            cl[:] = map(lambda l: int(math.copysign(vmap[abs(l)], l)) if abs(l) in vmap else l, cl)
-
-        # updating the number of variables
-        cnf.nv = vpool.top
-
     @classmethod
     def _encode(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
             encoding=EncType.best, comparator='<', conditionals=None):
         """
-            This is the method that wraps the encoder of PyPBLib. Although the
+            This is the method that wraps the encoders of Pindakaas. Although the
             method can be invoked directly, a user is expected to call one of
             the following methods instead: :meth:`atmost`, :meth:`atleast`, or
             :meth:`equals`.
@@ -275,7 +280,7 @@ class PBEnc(object):
             :rtype: :class:`pysat.formula.CNFPlus`
         """
 
-        if encoding < 0 or encoding > 6:
+        if encoding < 0 or encoding > 9:
             raise(NoSuchEncodingError(encoding))
 
         # checking if the bound is meaningless for any encoding
@@ -295,15 +300,14 @@ class PBEnc(object):
         # preparing weighted literals
         if weights:
             assert len(lits) == len(weights), 'Same number of literals and weights is expected.'
-            wlits = [(l, w) for l, w in zip(lits, weights)]
+            lits, weights = list(lits), list(weights)
         else:
             if all(map(lambda lw: (type(lw) in (list, tuple)) and len(lw) == 2, lits)):
                 # literals are already weighted
-                lits, weight = zip(*lits)  # unweighted literals for getting top_id
+                lits, weights = map(list, zip(*lits))
             elif all(map(lambda l: type(l) is int, lits)):
                 # no weights are provided => all weights are units
-                wlits = [(l, 1) for l in lits]
-                weights = [1 for l in lits]
+                lits, weights = list(lits), [1 for l in lits]
             else:
                 assert 0, 'Incorrect literals given.'
 
@@ -330,40 +334,27 @@ class PBEnc(object):
 
             return ret
 
-        assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
-
-        # 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)
+        Lit = pindakaas.Lit.from_raw
 
-        # add optional conditionals
-        if len(conditionals) > 0:
-            constr.add_conditionals(conditionals)
+        # the weighted sum (in place, as `+` copies the sum)
+        lhs = 0
+        for l, w in zip(lits, weights):
+            lhs += w * Lit(l)
 
-        # encoder configuration
-        config = pblib.PBConfig()
-        config.set_PB_Encoder(EncType._to_pbenc[encoding])
+        constr = EncType._to_cmp[comparator](lhs, bound)
+        encoder, options = EncType._to_encoder[encoding]
 
-        # encoding
-        result = pblib.VectorClauseDatabase(config)
-        pb2cnf = pblib.Pb2cnf(config)
-        pb2cnf.encode(constr, result, varmgr)
-
-        # extracting clauses
-        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:
-            if vpool._occupied and vpool.top <= vpool._occupied[0][0] <= ret.nv:
-                cls._update_vids(ret, vpool, lits)
-            else:
-                vpool.top = ret.nv - 1
-                vpool._next()
+        db = _pindakaas_db(top_id)
+        try:
+            db.add_encoding(constr, encoder,
+                            conditions=[Lit(l) for l in conditionals], **options)
+        except pindakaas.Unsatisfiable:
+            # the constraint cannot hold, so neither can all conditionals
+            ret = _pindakaas_cnf(db, top_id, vpool=vpool)
+            ret.clauses = [[-l for l in conditionals]]
+            return ret
 
-        return ret
+        return _pindakaas_cnf(db, top_id, vpool=vpool)
 
     @classmethod
     def leq(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
@@ -373,14 +364,14 @@ class PBEnc(object):
             (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`.
+            :class:`.formula.CNFPlus`.
 
             The input list of literals can contain either integers or pairs
             ``(l, w)``, where ``l`` is an integer literal and ``w`` is an
             integer weight. The latter can be done only if no ``weights`` are
             specified separately. The type of encoding to use can be specified
             using the ``encoding`` parameter. By default, it is set to
-            ``EncType.best``, i.e. it is up to the PBLib encoder to choose the
+            ``EncType.best``, i.e. it is up to Pindakaas to choose the
             encoding type.
 
             The final optional argument is ``conditionals``, where a list of
@@ -415,7 +406,7 @@ class PBEnc(object):
     def atmost(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
             encoding=EncType.best, conditionals=None):
         """
-            A synonim for :meth:`PBEnc.leq`.
+            A synonym for :meth:`PBEnc.leq`.
         """
 
         return cls.leq(lits, weights=weights, bound=bound, top_id=top_id,

pysat/solvers.py

@@ -710,7 +710,26 @@ class Solver(object):
             else:
                 raise NotImplementedError('Extension-variable mining is unsupported by this solver')
 
-    def xpairs(self):
+    def shift_xscope(self, old, new):
+        """
+            Move the scope of extension-variable mining from the variables
+            of the literals in ``old`` to those of the literals in ``new``,
+            e.g. from one call's assumptions to the next one's. Only the
+            difference is passed on, so a scope that stays put costs nothing.
+
+            :param old: literals whose variables are in scope now
+            :param new: literals whose variables should be in scope instead
+            :type old: iterable(int)
+            :type new: iterable(int)
+        """
+
+        if self.solver:
+            if type(self.solver) in (Ergo,):
+                self.solver.shift_xscope(old, new)
+            else:
+                raise NotImplementedError('Extension-variable mining is unsupported by this solver')
+
+    def xpairs(self, lits=None):
         """
             Return the literal pairs the extension-variable miner is currently
             tracking, as a list of ``(la, lb, z, count)`` tuples. A pair that
@@ -720,17 +739,64 @@ class Solver(object):
             0`` and a ``count`` saying how reliably it has recurred so far.
             Promoted pairs come first.
 
+            If parameter ``lits`` is given, only the pairs over those literals
+            are reported, which is normally what a caller wants: the literals
+            it is about to encode. The literals must be distinct.
+
             The result is valid until the next call to :meth:`solve`,
             :meth:`solve_limited` or :meth:`propagate`, like a model or an
             unsatisfiable core. Adopting a ``z`` beyond that point requires
             :meth:`xpin`.
 
+            :param lits: literals to ask about, or ``None`` for every pair
+            :type lits: iterable(int)
+
             :rtype: list(tuple(int, int, int, float))
         """
 
         if self.solver:
             if type(self.solver) in (Ergo,):
-                return self.solver.xpairs()
+                return self.solver.xpairs(lits)
+            else:
+                raise NotImplementedError('Extension-variable mining is unsupported by this solver')
+
+    def xname(self, pairs):
+        """
+            Tell the solver about the names of the literal pairs given
+            externally. The solver adds the definition clauses, stops its
+            miner from introducing other names for the same pairs, and
+            rewrites its learnt clauses accordingly. Pair names adopted this
+            way are never retired.
+
+            .. note::
+
+                A pair that already has a name, and a ``z`` that already
+                names another pair, are both ignored.
+
+            :param pairs: the pairs to name
+            :type pairs: iterable(tuple(int, int, int))
+        """
+
+        if self.solver:
+            if type(self.solver) in (Ergo,):
+                self.solver.xname(pairs)
+            else:
+                raise NotImplementedError('Extension-variable mining is unsupported by this solver')
+
+    def xblock(self, pairs):
+        """
+            Tell the solver that the given literal pairs are encoded
+            externally, so its miner must never consider them again. Unlike
+            :meth:`xname`, nothing is defined, recorded or rewritten: the
+            caller's own names for the pairs stay ordinary variables.
+
+            :param pairs: the pairs to keep the miner off
+            :type pairs: iterable(tuple(int, int))
+        """
+
+        if self.solver:
+            if type(self.solver) in (Ergo,):
+                self.solver.xblock(pairs)
             else:
                 raise NotImplementedError('Extension-variable mining is unsupported by this solver')
 
@@ -1293,7 +1359,18 @@ class Solver(object):
         if self.solver:
             return self.solver.propagate(assumptions, phase_saving)
 
-    def set_phases(self, literals=[]):
+    def apply_jw(self):
+        """
+            Recompute and apply JW scores to the current formula.
+        """
+
+        if self.solver:
+            if not isinstance(self.solver, Ergo):
+                raise NotImplementedError('Applying JW scores is unsupported by this solver')
+
+            self.solver.apply_jw()
+
+    def set_phases(self, literals=[], hard=False):
         """
             The method takes a list of literals as an argument and sets
             *phases* (or MiniSat-like *polarities*) of the corresponding
@@ -1312,7 +1389,12 @@ class Solver(object):
             Also **note** that :class:`Cadical103`, :class:`Cadical153`, and
             :class:`Cadical195` do not support this functionality.
 
-            :param literals: a list of literals.
+            Experimental default parameter ``hard=True`` is not currently
+            supported and is ignored.
+
+            :param hard: persistent branching preferences
+            :type hard: bool
+            :param literals: a list of literals
             :type literals: iterable(int)
 
             Usage example:
@@ -1334,6 +1416,11 @@ class Solver(object):
         """
 
         if self.solver:
+            if hard:
+                if not isinstance(self.solver, Ergo):
+                    raise NotImplementedError('Setting persistent phases is unsupported by this solver')
+                return self.solver.set_phases(literals, hard=True)
+
             return self.solver.set_phases(literals)
 
     def get_status(self):
@@ -3708,12 +3795,21 @@ class Ergo(object):
                         # creating the engine
                         self.activate_atmost()
 
-                for clause in bootstrap_with:
-                    if not clause or isinstance(clause[0], int):  # it is a clause
-                        self.add_clause(clause)
-                    else:
-                        self.add_atmost(clause[0], clause[1],
-                                        weights=clause[2] if len(clause) == 3 else [])
+                if not self.supports_atmost() and getattr(self.add_clause, '__func__', None) is Ergo.add_clause:
+                    for clause in bootstrap_with:
+                        try:
+                            self.add_clause(clause)
+                        except TypeError:
+                            if not clause or isinstance(clause[0], int):
+                                raise
+                            self.add_atmost(clause[0], clause[1], weights=clause[2] if len(clause) == 3 else [])
+                else:
+                    for clause in bootstrap_with:
+                        if not clause or isinstance(clause[0], int):  # it is a clause
+                            self.add_clause(clause)
+                        else:
+                            self.add_atmost(clause[0], clause[1],
+                                            weights=clause[2] if len(clause) == 3 else [])
 
             if warm_start:
                 self.start_mode(warm=True)
@@ -3915,13 +4011,22 @@ class Ergo(object):
 
             return bool(st), props if props != None else []
 
-    def set_phases(self, literals=[]):
+    def apply_jw(self):
         """
-            Sets polarities of a given list of variables.
+            Apply the selected JW mode now; repeat after adding clauses if needed.
         """
 
         if self.ergo:
-            pysolvers.ergo_setphases(self.ergo, literals)
+            pysolvers.ergo_apply_jw(self.ergo)
+
+    def set_phases(self, literals=[], hard=False):
+        """
+            Set branching polarities; ``hard=True`` overrides phase saving.
+            ``hard=False`` releases persistent preferences for these variables.
+        """
+
+        if self.ergo:
+            pysolvers.ergo_setphases(self.ergo, literals, bool(hard))
 
     def set_activities(self, activities={}):
         """
@@ -3974,6 +4079,13 @@ class Ergo(object):
             applied first, so any other parameter given in the same call
             overrides the emulated preset.
 
+            .. note::
+
+                A JW mode, if requested, is applied (after all parameters) to
+                the formula loaded at this call. Use ``apply_jw()`` directly
+                to recompute after adding clauses. Mode 'none' performs no
+                scoring and preserves existing phases.
+
             The list of available options:
 
                 * ``emulate``: emulate another solver's tuning -- one of
@@ -4033,6 +4145,18 @@ class Ergo(object):
                 * ``ext-escalate``: how quickly ``ext-threshold`` grows
                   with the number of variables already introduced (float)
 
+                * ``ext-rewrite``: whether a promoted or named pair may
+                  be substituted into the clause database (default
+                  ``True``); switching it off also stops mining from
+                  promoting, since a variable nothing references retires
+                  the moment it is created
+
+                * ``ext-equiv``: whether an extension variable gets the
+                  ``la | lb -> z`` half of its definition (default
+                  ``True``); without it ``z`` is only the upper bound a
+                  totalizer would have encoded itself, which a rewrite
+                  cannot use, so it forces ``ext-rewrite`` off
+
             :param parameters: parameter names mapped to their values
             :type parameters: dict
         """
@@ -4046,6 +4170,10 @@ class Ergo(object):
                 if name != 'emulate':
                     pysolvers.ergo_set(self.ergo, name, value)
 
+            # setting JW mode if not 'none'
+            if parameters.get('jw-mode', 'none') != 'none':
+                self.apply_jw()
+
     def set_xscope(self, add=[], remove=[]):
         """
             Adjust the scope of extension-variable mining: a pair of
@@ -4070,7 +4198,21 @@ class Ergo(object):
         if self.ergo:
             pysolvers.ergo_setxscope(self.ergo, add, remove)
 
-    def xpairs(self):
+    def shift_xscope(self, old, new):
+        """
+            Move the mining scope from the variables of ``old`` to those of
+            ``new``; only the difference reaches Ergo.
+
+            :param old: literals whose variables are in scope now
+            :param new: literals whose variables should be in scope instead
+            :type old: iterable(int)
+            :type new: iterable(int)
+        """
+
+        if self.ergo:
+            pysolvers.ergo_shiftxscope(self.ergo, old, new)
+
+    def xpairs(self, lits=None):
         """
             Return the literal pairs the extension-variable miner is currently
             tracking, as a list of ``(la, lb, z, count)`` tuples. A pair that
@@ -4080,16 +4222,57 @@ class Ergo(object):
             0`` and a ``count`` saying how reliably it has recurred so far.
             Promoted pairs come first.
 
+            If ``lits`` is given, only the pairs over those literals are
+            reported, which is normally what a caller wants: the literals it
+            is about to encode. Asking narrowly is also much cheaper than
+            taking the whole database home and sifting it there. The
+            literals must be distinct.
+
             The result is valid until the next call to :meth:`solve`,
             :meth:`solve_limited` or :meth:`propagate`, like a model or an
             unsatisfiable core. Adopting a ``z`` beyond that point requires
             :meth:`xpin`.
 
+            :param lits: literals to ask about, or ``None`` for every pair
+            :type lits: iterable(int)
+
             :rtype: list(tuple(int, int, int, float))
         """
 
         if self.ergo:
-            return pysolvers.ergo_xpairs(self.ergo)
+            return pysolvers.ergo_xpairs(self.ergo, lits)
+
+    def xname(self, pairs):
+        """
+            Adopt variables of the caller's own as names for literal pairs,
+            i.e. register ``z <-> la | lb`` for a pair the caller has encoded
+            itself. Ergo adds ``z``'s definition clauses, records the pair so
+            its miner never mints a second name for it, and rewrites its
+            learnt clauses onto ``z``. An adopted name is pinned on arrival
+            and never retires.
+
+            A pair that already has a name, and a ``z`` that already names
+            another pair, are both ignored.
+
+            :param pairs: the pairs to name
+            :type pairs: iterable(tuple(int, int, int))
+        """
+
+        if self.ergo:
+            pysolvers.ergo_xname(self.ergo, [l for p in pairs for l in p])
+
+    def xblock(self, pairs):
+        """
+            Keep the miner off literal pairs the caller encodes itself, for
+            good. Nothing is defined, recorded or rewritten, and the
+            caller's own variable for a pair is none of Ergo's business.
+
+            :param pairs: the pairs to keep the miner off
+            :type pairs: iterable(tuple(int, int))
+        """
+
+        if self.ergo:
+            pysolvers.ergo_xblock(self.ergo, [l for p in pairs for l in p[:2]])
 
     def xpin(self, variables):
         """
@@ -4272,16 +4455,30 @@ class Ergo(object):
                 if not self.supports_atmost():
                     raise NotImplementedError('Native atmost constraints are currently disabled')
 
-            for clause in formula:
-                if not clause or isinstance(clause[0], int):  # it is a clause
-                    res = self.add_clause(clause, no_return)
-                else:
-                    res = self.add_atmost(clause[0], clause[1],
-                                          weights=clause[2] if len(clause) == 3 else [],
-                                          no_return=no_return)
+            if not self.supports_atmost() and getattr(self.add_clause, '__func__', None) is Ergo.add_clause:
+                for clause in formula:
+                    try:
+                        res = self.add_clause(clause, no_return)
+                    except TypeError:
+                        if not clause or isinstance(clause[0], int):
+                            raise
+                        res = self.add_atmost(clause[0], clause[1],
+                                              weights=clause[2] if len(clause) == 3 else [],
+                                              no_return=no_return)
 
-                if not no_return and res == False:
-                    return res
+                    if not no_return and res == False:
+                        return res
+            else:
+                for clause in formula:
+                    if not clause or isinstance(clause[0], int):  # it is a clause
+                        res = self.add_clause(clause, no_return)
+                    else:
+                        res = self.add_atmost(clause[0], clause[1],
+                                              weights=clause[2] if len(clause) == 3 else [],
+                                              no_return=no_return)
+
+                    if not no_return and res == False:
+                        return res
 
             if not no_return:
                 return res

{python_sat-1.9.dev16.dist-info → python_sat-1.9.dev18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev16
+Version: 1.9.dev18
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado
@@ -15,8 +15,10 @@ Provides-Extra: approxmc
 Requires-Dist: pyapproxmc>=4.1.8; extra == "approxmc"
 Provides-Extra: cryptosat
 Requires-Dist: pycryptosat>=5.11.18; extra == "cryptosat"
+Provides-Extra: pb
+Requires-Dist: pindakaas>=0.6.1; extra == "pb"
 Provides-Extra: pblib
-Requires-Dist: pypblib>=0.0.3; extra == "pblib"
+Requires-Dist: pindakaas>=0.6.1; extra == "pblib"
 Provides-Extra: unigen
 Requires-Dist: pyunigen>=4.1.20; extra == "unigen"
 Dynamic: author

{python_sat-1.9.dev16.dist-info → python_sat-1.9.dev18.dist-info}/RECORD

@@ -1,16 +1,16 @@
-pycard.cp313-win_amd64.pyd,sha256=-21c04ZDTCkbLY-PrhzRBwcrr8JMYth7F67HhQgEXrg,71680
-pyformula.cp313-win_amd64.pyd,sha256=1YTbw9DofgYjA7leKm8AtmMZ0qp2eRFZMMKzEUoyHpY,31232
-pysolvers.cp313-win_amd64.pyd,sha256=J8Hx4wiiQfSJS4Jz_LYlXs4vlu2LrYJuDo1uNtuapZM,3341824
-pysat/__init__.py,sha256=4JqjNiGlyx3erAPAvKC8uCaQB-3IozEaQNRn_ANOeYU,681
+pycard.cp313-win_amd64.pyd,sha256=PZ50XA6fybcRvw5SPc9j0nJDSNVqB2juDezaMoUVkEM,71680
+pyformula.cp313-win_amd64.pyd,sha256=zveu2NsNepVzqxV08-yfzqzkwgNge1bq5-rNFBKrb5E,31232
+pysolvers.cp313-win_amd64.pyd,sha256=MIEeH7EN00zm9PaBz4kNWgKvMeR71bpooummkosh_PM,3341824
+pysat/__init__.py,sha256=GVL8Ti2mVtexajShuobNXoYUQxcG9MV244bA72LC44M,681
 pysat/_fileio.py,sha256=pXRGGAaP7U8r3bpn5ShseCSHROXqi7ygaYe6T6QORto,6700
 pysat/_utils.py,sha256=4cv40p70FKvjCTKq8GqzS_jlxF74cp_lojTZSim_qJE,1340
-pysat/card.py,sha256=rav3_t_mCzbLw8SAdXcOh-PNbFtaATVSAJzpbygqiQ4,30066
+pysat/card.py,sha256=j39uYFhgol08nxReT1g7tMEfEdtMmEkQzI_JJ219Uac,29639
 pysat/engines.py,sha256=yAYA_PzIGr_uRF85M7kL2bipjpLbY7jdfFKTdY-yW8I,46364
 pysat/formula.py,sha256=qtADpavl5m-pHRDnZ7PDEiosT7TbaCwqY_xpv_--Nlw,215586
-pysat/integer.py,sha256=um6FXUzmBHUFlWXNKs0xLh9Jss3jiEin2Er_U41KtkA,90203
-pysat/pb.py,sha256=DMy8UfbbpfJo5cTZul9W1o_mlr-B0lCIEseZjrQYd8A,17816
+pysat/integer.py,sha256=_1qPuYuUT8jT0PfbQhHS1ujQBxNyoYRbrEvnD2aIuEQ,97091
+pysat/pb.py,sha256=cVpCFc0gAARaQa9VU0Vx-P5wAWoLlXcMKpuhgtRqez4,17520
 pysat/process.py,sha256=8lNbpEKipFZjbQ9DCJPfdL8eZHx-ltNuu7h4geWWdJY,12739
-pysat/solvers.py,sha256=uE8HkMcLWvL4WrgtDhRBrqh0wq5kg9kNpAKGoBOX4GU,310003
+pysat/solvers.py,sha256=Mt9QPzxXosIfSJmPJ1kWN10M6oCKu1BRoHHGqkNFE4I,318480
 pysat/allies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pysat/allies/approxmc.py,sha256=LtUss6PiqmgvFwLTe4KUHmhavdzlotRii2UUOSb9gTU,13586
 pysat/allies/unigen.py,sha256=qOGc_WwcIi-AgFSJDBhhY2n6Q6UeYVMpMPuem4-Vf6c,16718
@@ -29,22 +29,22 @@ pysat/examples/optux.py,sha256=cZMwxzOxuTzo6TDUvZVVuF3V1tOAlAdZpW6cm6qW1HM,29771
 pysat/examples/primer.py,sha256=0OeV9R6mWyIr2BKIitkrfgY3q2XE-sV1ZLSiybGRFXw,23375
 pysat/examples/rc2.py,sha256=dZMslLc2P7PYdH82lekWSaE6dTz8MyDVzj56nwOkYuw,77292
 pysat/examples/usage.py,sha256=x9luw6pyKAAndlxAeUWFhS4aLSVmD2t_j_5uA9YddHg,2183
-python_sat-1.9.dev16.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
-python_sat-1.9.dev16.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
-python_sat-1.9.dev16.data/scripts/bica.py,sha256=659K6gdRBgYeNiLjQc_VnulXhbTHxnUljNYhXx-frwk,28413
-python_sat-1.9.dev16.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
-python_sat-1.9.dev16.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
-python_sat-1.9.dev16.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
-python_sat-1.9.dev16.data/scripts/lsu.py,sha256=EpXQCu8ZdYoNgi70Uc1b8drOwp1fo82mhGbpjonjIzw,16687
-python_sat-1.9.dev16.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
-python_sat-1.9.dev16.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
-python_sat-1.9.dev16.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
-python_sat-1.9.dev16.data/scripts/optux.py,sha256=9-4ynzXVYq7y67vy-emMbMx_gSlOBMDBX4VWkjSyHgE,30508
-python_sat-1.9.dev16.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
-python_sat-1.9.dev16.data/scripts/rc2.py,sha256=YQ3UkYWVd2ge64u-SdqwVzZkHmj0tikYxXZS0O2pXy4,79322
-python_sat-1.9.dev16.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
-python_sat-1.9.dev16.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
-python_sat-1.9.dev16.dist-info/METADATA,sha256=PMvSMSHwEAfxi9k9cTiE0RLkz2zvgR8DYBYYAjBTGoE,1784
-python_sat-1.9.dev16.dist-info/WHEEL,sha256=0LUNoHxLvcpw9db_x0XozE5jW73-_GOAO7fDDJ4Xt4Q,101
-python_sat-1.9.dev16.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
-python_sat-1.9.dev16.dist-info/RECORD,,
+python_sat-1.9.dev18.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
+python_sat-1.9.dev18.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
+python_sat-1.9.dev18.data/scripts/bica.py,sha256=659K6gdRBgYeNiLjQc_VnulXhbTHxnUljNYhXx-frwk,28413
+python_sat-1.9.dev18.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
+python_sat-1.9.dev18.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
+python_sat-1.9.dev18.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
+python_sat-1.9.dev18.data/scripts/lsu.py,sha256=EpXQCu8ZdYoNgi70Uc1b8drOwp1fo82mhGbpjonjIzw,16687
+python_sat-1.9.dev18.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
+python_sat-1.9.dev18.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
+python_sat-1.9.dev18.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
+python_sat-1.9.dev18.data/scripts/optux.py,sha256=9-4ynzXVYq7y67vy-emMbMx_gSlOBMDBX4VWkjSyHgE,30508
+python_sat-1.9.dev18.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
+python_sat-1.9.dev18.data/scripts/rc2.py,sha256=YQ3UkYWVd2ge64u-SdqwVzZkHmj0tikYxXZS0O2pXy4,79322
+python_sat-1.9.dev18.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
+python_sat-1.9.dev18.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
+python_sat-1.9.dev18.dist-info/METADATA,sha256=y415j-u4ZKAjyEiYy8qhEhrBP6T2A5RYZE8HyhGngEc,1854
+python_sat-1.9.dev18.dist-info/WHEEL,sha256=fOyJWI5N6P4iPL9_doBC3lf0L4Z-hcIkjNV5ilMSlqY,101
+python_sat-1.9.dev18.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
+python_sat-1.9.dev18.dist-info/RECORD,,

{python_sat-1.9.dev16.dist-info → python_sat-1.9.dev18.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: false
 Tag: cp313-cp313-win_amd64