python-sat 1.9.dev20__cp315-cp315-win_amd64.whl → 1.9.dev22__cp315-cp315-win_amd64.whl

pysat/__init__.py

@@ -22,7 +22,7 @@ del _delvewheel_patch_1_13_2
 
 # current version
 #==============================================================================
-VERSION = (1, 9, 'dev', 20)
+VERSION = (1, 9, 'dev', 22)
 
 
 # PEP440 Format

pysat/engines.py

@@ -141,7 +141,7 @@ class LinearConstraint:
             Constraint initialiser.
         """
 
-        if not weights or type(weights) == dict:
+        if not weights or isinstance(weights, dict):
             # the same literal may appear multiple times in the list
             # so we need to calculate it's actual weight
             cntr = Counter(lits)
@@ -378,7 +378,7 @@ class ParityConstraint:
         for lit in lits:
             if lit < 0:
                 lit = -lit
-                value ^= value
+                value ^= 1
             self.lits.append(lit)
 
         # right-hand side, current value, and variable counter
@@ -1038,6 +1038,9 @@ class BooleanEngine(Propagator):
 
         # forward simplification
         for i, csi in enumerate(self.xors):
+            if not csi.lits:  # eliminated as redundant (0 = 0)
+                continue
+
             v = csi.lits[0]  # pivot variable
 
             # going over all the other constraints and eliminating the pivot
@@ -1091,6 +1094,13 @@ class BooleanEngine(Propagator):
             Update the propagator's state given a new assignment.
         """
 
+        if fixed:
+            self.fixed[abs(lit)] = True
+
+        # the solver may notify us again when an assigned literal gets fixed
+        if self.level[abs(lit)] is not None:
+            return
+
         self.level[abs(lit)] = self.decision_level
 
         if self.qhead is None:
@@ -1100,9 +1110,6 @@ class BooleanEngine(Propagator):
 
         self.trail.append(lit)
 
-        if fixed:
-            self.fixed[abs(lit)] = True
-
     def on_new_level(self):
         """
             Keep track of decision level updates.
@@ -1116,6 +1123,8 @@ class BooleanEngine(Propagator):
             Cancel all the decisions up to a certain level.
         """
 
+        cursor = self.qhead
+
         # undoing the assignments
         while len(self.trlim) > to:
             while len(self.trail) > self.trlim[-1]:
@@ -1142,8 +1151,8 @@ class BooleanEngine(Propagator):
         # updating decision level
         self.decision_level = to
 
-        # updating queue head
-        self.qhead = None
+        # updating queue head (some assignments have not been processed)
+        self.qhead = min(cursor if cursor is not None else 0, len(self.trail))
 
     def check_model(self, model):
         """
@@ -1204,8 +1213,9 @@ class BooleanEngine(Propagator):
                 lit = self.trail[self.qhead]
 
                 # if we have just propagated an opposite value,
-                # we stop and expect conflict analysis to be performed
+                # this is a conflict that needs proper treatment
                 if self.origin[-lit] is not None:
+                    result.append(-lit)
                     break
 
                 self.value[abs(lit)] = lit  # actually setting the value
@@ -1277,7 +1287,7 @@ class BooleanEngine(Propagator):
 
             if nid is not None:
                 # this one has a negative counterpart
-                if pid < len(self.wlst[lit]):
+                if pid < len(self.wlst[lit]) and isinstance(self.wlst[lit][pid], ParityConstraint):
                     # and it's affected
                     self.wlst[lit][pid].wopp[-lit] = pid
 
@@ -1288,7 +1298,7 @@ class BooleanEngine(Propagator):
             self.wlst[-lit][nid] = self.wlst[-lit][-1]
             self.wlst[-lit].pop()
 
-            if nid < len(self.wlst[-lit]):
+            if nid < len(self.wlst[-lit]) and isinstance(self.wlst[-lit][nid], ParityConstraint):
                 self.wlst[-lit][nid].wopp[lit] = nid
 
     def provide_reason(self, lit):

pysat/examples/lbx.py

@@ -247,6 +247,10 @@ class LBX(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param soft: whether or not the clause is soft
 

pysat/examples/mcsls.py

@@ -248,6 +248,10 @@ class MCSls(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param soft: whether or not the clause is soft
 

pysat/examples/rc2.py

@@ -362,6 +362,9 @@ class RC2(object):
         self.sels_set = set(self.sels)
         self.sall = self.sels[:]
 
+        # original weights (as opposed to those after splitting)
+        self.owgt = dict(self.wght)
+
         # we may end up having zero-weighed soft clauses
         self.garbage = set([l for l in self.sels if self.wght[l] == 0])
         if self.garbage:
@@ -403,6 +406,10 @@ class RC2(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param weight: weight of the clause (if any)
 
@@ -475,6 +482,7 @@ class RC2(object):
                     # selector is not new; increment its weight
                     self.wght[selv] += weight
 
+                self.owgt[selv] = self.owgt.get(selv, 0) + weight
                 self.sall.append(selv)
                 self.sels_set.add(selv)
 
@@ -560,15 +568,15 @@ class RC2(object):
                 # so let's transform the None model returned to []
                 self.model = []
 
+            # if formula processing was used, we should restore the model
+            # for the original formula (before selectors are filtered out)
+            if self.processor:
+                self.model = self.processor.restore(self.model)
+
             self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
             self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
             self.model = sorted(self.model, key=lambda l: abs(l))
 
-            # if formula processing was used, we should
-            # restore the model for the original formula
-            if self.processor:
-                self.model = self.processor.restore(self.model)
-
             return self.model
 
     def enumerate(self, block=0, expect_interrupt=False):
@@ -583,7 +591,8 @@ class RC2(object):
             (MSSes) or minimal correction subsets (MCSes). To block MSSes, one
             should set the ``block`` parameter to ``1``. To block MCSes, set
             it to ``-1``. By the default (for blocking MaxSAT models),
-            ``block`` is set to ``0``.
+            ``block`` is set to ``0``. Note that if formula processing is
+            used (see parameter ``process``), only MCSes can be blocked.
 
             This MaxSAT enumeration call can be asynchronously interrupted, in
             which case the value of ``expect_interrupt`` must be set to
@@ -621,6 +630,9 @@ class RC2(object):
                 >>> rc2.delete()
         """
 
+        assert not self.processor or block == -1, \
+                'Only MCSes can be blocked if formula processing is used'
+
         done = False
         while not done:
             model = self.compute(expect_interrupt=expect_interrupt)
@@ -1471,6 +1483,9 @@ class RC2Stratified(RC2, object):
         # do clause hardening
         self.hard = nohard == False
 
+        # upper bound on the cost (trivial at first)
+        self.ubnd = sum(self.owgt.values())
+
         # backing up selectors
         self.bckp, self.bckp_set = self.sels, self.sels_set
         self.sels = []
@@ -1571,15 +1586,15 @@ class RC2Stratified(RC2, object):
             # so let's transform the None model returned to []
             self.model = []
 
+        # if formula processing was used, we should restore the model
+        # for the original formula (before selectors are filtered out)
+        if self.processor:
+            self.model = self.processor.restore(self.model)
+
         self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
         self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
         self.model = sorted(self.model, key=lambda l: abs(l))
 
-        # if formula processing was used, we should
-        # restore the model for the original formula
-        if self.processor:
-            self.model = self.processor.restore(self.model)
-
         return self.model
 
     def next_level(self):
@@ -1648,14 +1663,17 @@ class RC2Stratified(RC2, object):
             to optimization levels up to the newly computed level. It
             also reactivates previously deactivated clauses (see
             :func:`process_sels` and :func:`process_sums` for
-            details).
+            details). Clauses whose weight exceeds the gap between
+            the upper and lower bounds are hardened instead.
         """
 
         end = min(self.levl + 1, len(self.blop))
 
         for l in range(beg, end):
             for sel in self.wstr[self.blop[l]]:
-                if sel in self.bckp_set:
+                if self.hard and self.blop[l] > self.ubnd - self.cost:
+                    self.oracle.add_clause([sel])
+                elif sel in self.bckp_set:
                     self.sels.append(sel)
                 else:
                     self.sums.append(sel)
@@ -1670,7 +1688,8 @@ class RC2Stratified(RC2, object):
             This method does postprocessing of the current
             optimization level after it is solved. This includes
             *hardening* some of the soft clauses (depending on their
-            remaining weights) and also garbage collection.
+            remaining weights) and also garbage collection. The
+            level's model is used to tighten the upper bound.
         """
 
         # assumptions to remove
@@ -1679,9 +1698,15 @@ class RC2Stratified(RC2, object):
         # sum of weights of the remaining levels
         sumw = sum([w * len(self.wstr[w]) for w in self.blop[(self.levl + 1):]])
 
+        # upper bound given by the current model;
+        # selectors unknown to the oracle are deemed to be falsified
+        model = self.oracle.get_model()
+        cost = sum([w for s, w in six.iteritems(self.owgt) if abs(s) > len(model) or model[abs(s) - 1] != s])
+        self.ubnd = min(self.ubnd, cost)
+
         # trying to harden selectors and sums
         for s in self.sels + self.sums:
-            if self.wght[s] > sumw:
+            if self.wght[s] > min(sumw, self.ubnd - self.cost):
                 self.oracle.add_clause([s])
                 self.garbage.add(s)
 
@@ -1983,6 +2008,12 @@ if __name__ == '__main__':
         else:
             MXS = RC2
 
+        if process and to_enum != 1 and block != -1:
+            # no formula processing in case we enumerate multiple models or
+            # MSSes, as blocking them refers to variables it may eliminate
+            print('c formula processing is disabled for model enumeration')
+            process = 0
+
         # starting the solver
         with MXS(formula, solver=solver, adapt=adapt, exhaust=exhaust,
                 incr=incr, minz=minz, process=process, trim=trim,

pysat/process.py

@@ -23,7 +23,8 @@
     ==================
 
     This module provides access to the preprocessor functionality of `CaDiCaL
-    1.5.3 <https://github.com/arminbiere/cadical>`__. It can be used to
+    <https://github.com/arminbiere/cadical>`__, version 1.5.3 by default
+    (versions 1.9.5 and 3.0.0 can be selected instead). It can be used to
     process [1]_ (also see references therein) a given CNF formula and output
     a another formula, which is guaranteed to be *equisatisfiable* with the
     original formula. The processor can be invoked for a user-provided number
@@ -85,20 +86,30 @@
 #
 #==============================================================================
 from pysat.formula import CNF
-from pysat.solvers import Cadical153
+from pysat.solvers import Cadical153, Cadical195, Cadical300, NoSuchSolverError, SolverNames
 
 
 #
 #==============================================================================
 class Processor(object):
     """
-        This class provides interface to CaDiCaL's preprocessor. The only
-        input parameter is ``bootstrap_with``, which is expected to be a
-        :class:`.CNF` formula or a list (or iterable) of clauses.
+        This class provides interface to CaDiCaL's preprocessor. The input
+        parameters are ``bootstrap_with``, which is expected to be a
+        :class:`.CNF` formula or a list (or iterable) of clauses, and
+        ``engine``, which is the name of a CaDiCaL version to use, i.e. one of
+        the names of :class:`.Cadical153` (default), :class:`.Cadical195`, and
+        :class:`.Cadical300`. Note that preprocessing in CaDiCaL 1.9.5 should
+        not differ from that of CaDiCaL 1.5.3, as the two versions apply the
+        same techniques. In contrast, CaDiCaL 3.0.0 additionally applies
+        congruence closure, SAT sweeping, and binary clause backbone
+        computation.
 
         :param bootstrap_with: a list of clauses for processor initialization.
         :type bootstrap_with: :class:`.CNF` or iterable(iterable(int))
 
+        :param engine: name of the CaDiCaL version to use
+        :type engine: str
+
         Once created and used, a processor must be deleted with the
         :meth:`delete` method. Alternatively, if created using the ``with``
         statement, deletion is done automatically when the end of the ``with``
@@ -119,7 +130,7 @@ class Processor(object):
             >>> from pysat.process import Processor
             >>> from pysat.solvers import Solver
             >>>
-            >>> processor = Processor(bootstrap_with=[[-1, 2], [1, -2]])
+            >>> processor = Processor(bootstrap_with=[[-1, 2], [1, -2]], engine='cd195')
             >>> processor.append_formula([[-2, 3], [1]])
             >>> processor.add_clause([-3, 4])
             >>>
@@ -140,13 +151,23 @@ class Processor(object):
             >>> processor.delete()
     """
 
-    def __init__(self, bootstrap_with=None):
+    def __init__(self, bootstrap_with=None, engine='cd15'):
         """
             Basic constructor.
         """
 
+        self.cadical = None
+
         # immediately creating a CaDiCaL object
-        self.cadical = Cadical153()
+        engine_ = engine.lower()
+        if engine_ in SolverNames.cadical153:
+            self.cadical = Cadical153()
+        elif engine_ in SolverNames.cadical195:
+            self.cadical = Cadical195()
+        elif engine_ in SolverNames.cadical300:
+            self.cadical = Cadical300()
+        else:
+            raise(NoSuchSolverError(engine))
 
         # status of processor is True by default meaning
         # that the input formula *is not* unsatisfiable
@@ -219,14 +240,18 @@ class Processor(object):
         if self.cadical:
             self.cadical.append_formula(formula)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
-                decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+    def process(self, rounds=1, backbone=True, block=False, condition=False,
+                congruence=True, cover=False, decompose=True, elim=True,
+                probe=True, probehbr=True, subsume=True, sweep=True,
+                ternary=True, transred=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
             arguments. Note that the default values of all the arguments used
-            are set as in the default configuration of CaDiCaL 1.5.3.
+            are set as in the default configuration of CaDiCaL 1.5.3 and
+            3.0.0. Arguments ``backbone``, ``congruence``, and ``sweep`` are
+            used by CaDiCaL 3.0.0 only, as the older versions do not support
+            these techniques.
 
             As the result, the method returns a :class:`.CNF` object
             containing the processed formula. Additionally to the clauses, the
@@ -241,7 +266,11 @@ class Processor(object):
             and covered clause elimination is invoked only if bounded variable
             elimination is active. Subsumption elimination in turn may trigger
             vivification and transitive reduction if the corresponding flags
-            are set.
+            are set. Also, in CaDiCaL 3.0.0, flag ``probe`` controls only
+            failed literal probing while the other techniques applied along
+            with probing are controlled by their own flags. Flag ``elim``
+            there controls both bounded variable elimination and its fast
+            variant applied at the beginning of preprocessing.
 
             Finally, note that the ``freeze`` argument can be used to keep
             some of the variables of the original formula unchanged during
@@ -251,15 +280,21 @@ class Processor(object):
             :param rounds: number of preprocessing rounds
             :type rounds: int
 
+            :param backbone: compute backbones of the binary clauses (CaDiCaL 3.0.0 only)
+            :type backbone: bool
+
             :param block: apply blocked clause elimination
             :type block: bool
 
-            :param cover: apply covered clause elimination
-            :type cover: bool
-
             :param condition: detect conditional autarkies and apply globally-blocked clause elimination
             :type condition: bool
 
+            :param congruence: detect AND, XOR, and ITE gates and merge equivalent gate outputs (CaDiCaL 3.0.0 only)
+            :type congruence: bool
+
+            :param cover: apply covered clause elimination
+            :type cover: bool
+
             :param decompose: detect strongly connected components (SCCs) in the binary implication graph (BIG) and apply equivalent literal substitution (ELS)
             :type decompose: bool
 
@@ -275,6 +310,15 @@ class Processor(object):
             :param subsume: apply global forward clause subsumption
             :type subsume: bool
 
+            :param sweep: apply SAT sweeping to detect equivalent literals and backbones (CaDiCaL 3.0.0 only)
+            :type sweep: bool
+
+            :param ternary: apply hyper ternary resolution
+            :type ternary: bool
+
+            :param transred: apply transitive reduction of the binary implication graph (BIG)
+            :type transred: bool
+
             :param vivify: apply clause vivification
             :type vivify: bool
 
@@ -304,11 +348,24 @@ class Processor(object):
         """
 
         if self.cadical:
-            self.status, result = self.cadical.process(rounds, block, cover,
-                                                       condition, decompose,
-                                                       elim, probe, probehbr,
-                                                       subsume, vivify,
-                                                       freeze)
+            # techniques unavailable in the older versions of CaDiCaL
+            extra = {}
+            if isinstance(self.cadical, Cadical300):
+                extra = dict(backbone=backbone, congruence=congruence,
+                             sweep=sweep)
+
+            self.status, result = self.cadical.process(rounds=rounds,
+                                                       block=block,
+                                                       condition=condition,
+                                                       cover=cover,
+                                                       decompose=decompose,
+                                                       elim=elim, probe=probe,
+                                                       probehbr=probehbr,
+                                                       subsume=subsume,
+                                                       ternary=ternary,
+                                                       transred=transred,
+                                                       vivify=vivify,
+                                                       freeze=freeze, **extra)
 
             # making the status Boolean
             self.status = False if self.status == 20 else True

pysat/solvers.py

@@ -1359,6 +1359,64 @@ class Solver(object):
         if self.solver:
             return self.solver.propagate(assumptions, phase_saving)
 
+    def flip_bits(self, assumptions=[], preferences=None, budget=100000):
+        """
+            Run a "bit flipper" a.k.a. local search (based on CaDiCaL's
+            ProbSAT-like walker) aiming at a model of the formula that
+            minimizes its *cost* with respect to a set of weighted literal
+            preferences, i.e. the sum of the weights of the preferred literals
+            falsified by the model. The method returns a pair of a model and
+            its cost, or ``(None, None)`` if no model is found.
+
+            Preferences are given as a dictionary mapping literals to their
+            non-negative integer weights (both polarities of a variable can
+            be preferred). The preferences are kept between the calls unless
+            new ones are provided. The search is limited by a ``budget``
+            given in CaDiCaL's local search *ticks* (a measure of memory
+            accesses).
+
+            **Note** that all the clauses removed by preprocessing (see
+            :meth:`Cadical300.process`) are restored by the method.
+
+            **Note** that only :class:`Cadical300` supports this
+            functionality, without external propagators (and so without
+            native cardinality constraints).
+
+            .. warning::
+
+                This prototype implementation has been written by an LLM. So
+                use at your own risk!
+
+            :param assumptions: a list of assumption literals.
+            :param preferences: weighted preferred literals.
+            :param budget: limit on the number of ticks.
+
+            :type assumptions: iterable(int)
+            :type preferences: dict(int, int)
+            :type budget: int
+
+            :rtype: tuple(list(int), int) or tuple(None, None).
+
+            Usage example:
+
+            .. code-block:: python
+
+                >>> from pysat.solvers import Solver
+                >>>
+                >>> with Solver(name='cd30', bootstrap_with=[[1, 2], [-1, -2]]) as s:
+                ...     print(s.solve())
+                ...     print(s.flip_bits(preferences={1: 5, 2: 3}))
+                ...
+                True
+                ([1, -2], 3)
+        """
+
+        if self.solver:
+            if isinstance(self.solver, Cadical300):
+                return self.solver.flip_bits(assumptions, preferences, budget)
+            else:
+                raise NotImplementedError('Local search is supported only by CaDiCaL 3.0.0')
+
     def apply_jw(self):
         """
             Recompute and apply JW scores to the current formula.
@@ -2363,9 +2421,10 @@ class Cadical153(object):
         if self.cadical:
             pysolvers.cadical153_dbudget(self.cadical, budget)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
+    def process(self, rounds=1, block=False, condition=False, cover=False,
                 decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+                subsume=True, ternary=True, transred=True, vivify=True,
+                freeze=[]):
         """
             Apply the preprocessor for the internal formula. See the
             documentation for the ``process`` module for details.
@@ -2377,7 +2436,8 @@ class Cadical153(object):
                                                 int(condition),
                                                 int(decompose), int(elim),
                                                 int(probe), int(probehbr),
-                                                int(subsume), int(vivify),
+                                                int(subsume), int(ternary),
+                                                int(transred), int(vivify),
                                                 freeze,
                                                 int(MainThread.check()))
 
@@ -2797,9 +2857,10 @@ class Cadical195(object):
         if self.cadical:
             pysolvers.cadical195_dbudget(self.cadical, budget)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
+    def process(self, rounds=1, block=False, condition=False, cover=False,
                 decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+                subsume=True, ternary=True, transred=True, vivify=True,
+                freeze=[]):
         """
             Apply the preprocessor for the internal formula. See the
             documentation for the ``process`` module for details.
@@ -2811,7 +2872,8 @@ class Cadical195(object):
                                                 int(condition),
                                                 int(decompose), int(elim),
                                                 int(probe), int(probehbr),
-                                                int(subsume), int(vivify),
+                                                int(subsume), int(ternary),
+                                                int(transred), int(vivify),
                                                 freeze,
                                                 int(MainThread.check()))
 
@@ -3371,6 +3433,31 @@ class Cadical300(object):
 
             return self.status
 
+    def flip_bits(self, assumptions=[], preferences=None, budget=100000):
+        """
+            Run local search guided by weighted literal preferences.
+        """
+
+        if self.cadical:
+            self.sync_vars()
+
+            if self.use_timer:
+                start_time = process_time()
+
+            res = pysolvers.cadical300_flipbits(self.cadical, assumptions,
+                    preferences, budget, int(MainThread.check()))
+
+            if self.use_timer:
+                self.call_time = process_time() - start_time
+                self.accu_time += self.call_time
+
+            # the solver is in the inconclusive state now
+            self.status = None
+            self.prev_assumps = assumptions
+            self.sync_vpool()
+
+            return res
+
     def conf_budget(self, budget):
         """
             Set limit on the number of conflicts.
@@ -3387,9 +3474,10 @@ class Cadical300(object):
         if self.cadical:
             pysolvers.cadical300_dbudget(self.cadical, budget)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
-                decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+    def process(self, rounds=1, backbone=True, block=False, condition=False,
+                congruence=True, cover=False, decompose=True, elim=True,
+                probe=True, probehbr=True, subsume=True, sweep=True,
+                ternary=True, transred=True, vivify=True, freeze=[]):
         """
             Apply the preprocessor for the internal formula. See the
             documentation for the ``process`` module for details.
@@ -3399,12 +3487,14 @@ class Cadical300(object):
             self.sync_vars()
 
             result = pysolvers.cadical300_process(self.cadical, rounds,
-                                                  int(block), int(cover),
-                                                  int(condition),
+                                                  int(backbone), int(block),
+                                                  int(cover), int(condition),
+                                                  int(congruence),
                                                   int(decompose), int(elim),
                                                   int(probe), int(probehbr),
-                                                  int(subsume), int(vivify),
-                                                  freeze,
+                                                  int(subsume), int(sweep),
+                                                  int(ternary), int(transred),
+                                                  int(vivify), freeze,
                                                   int(MainThread.check()))
 
             self.sync_vpool()

{python_sat-1.9.dev20.data → python_sat-1.9.dev22.data}/scripts/lbx.py

@@ -247,6 +247,10 @@ class LBX(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param soft: whether or not the clause is soft
 

{python_sat-1.9.dev20.data → python_sat-1.9.dev22.data}/scripts/mcsls.py

@@ -248,6 +248,10 @@ class MCSls(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param soft: whether or not the clause is soft
 

{python_sat-1.9.dev20.data → python_sat-1.9.dev22.data}/scripts/rc2.py

@@ -362,6 +362,9 @@ class RC2(object):
         self.sels_set = set(self.sels)
         self.sall = self.sels[:]
 
+        # original weights (as opposed to those after splitting)
+        self.owgt = dict(self.wght)
+
         # we may end up having zero-weighed soft clauses
         self.garbage = set([l for l in self.sels if self.wght[l] == 0])
         if self.garbage:
@@ -403,6 +406,10 @@ class RC2(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param weight: weight of the clause (if any)
 
@@ -475,6 +482,7 @@ class RC2(object):
                     # selector is not new; increment its weight
                     self.wght[selv] += weight
 
+                self.owgt[selv] = self.owgt.get(selv, 0) + weight
                 self.sall.append(selv)
                 self.sels_set.add(selv)
 
@@ -560,15 +568,15 @@ class RC2(object):
                 # so let's transform the None model returned to []
                 self.model = []
 
+            # if formula processing was used, we should restore the model
+            # for the original formula (before selectors are filtered out)
+            if self.processor:
+                self.model = self.processor.restore(self.model)
+
             self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
             self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
             self.model = sorted(self.model, key=lambda l: abs(l))
 
-            # if formula processing was used, we should
-            # restore the model for the original formula
-            if self.processor:
-                self.model = self.processor.restore(self.model)
-
             return self.model
 
     def enumerate(self, block=0, expect_interrupt=False):
@@ -583,7 +591,8 @@ class RC2(object):
             (MSSes) or minimal correction subsets (MCSes). To block MSSes, one
             should set the ``block`` parameter to ``1``. To block MCSes, set
             it to ``-1``. By the default (for blocking MaxSAT models),
-            ``block`` is set to ``0``.
+            ``block`` is set to ``0``. Note that if formula processing is
+            used (see parameter ``process``), only MCSes can be blocked.
 
             This MaxSAT enumeration call can be asynchronously interrupted, in
             which case the value of ``expect_interrupt`` must be set to
@@ -621,6 +630,9 @@ class RC2(object):
                 >>> rc2.delete()
         """
 
+        assert not self.processor or block == -1, \
+                'Only MCSes can be blocked if formula processing is used'
+
         done = False
         while not done:
             model = self.compute(expect_interrupt=expect_interrupt)
@@ -1471,6 +1483,9 @@ class RC2Stratified(RC2, object):
         # do clause hardening
         self.hard = nohard == False
 
+        # upper bound on the cost (trivial at first)
+        self.ubnd = sum(self.owgt.values())
+
         # backing up selectors
         self.bckp, self.bckp_set = self.sels, self.sels_set
         self.sels = []
@@ -1571,15 +1586,15 @@ class RC2Stratified(RC2, object):
             # so let's transform the None model returned to []
             self.model = []
 
+        # if formula processing was used, we should restore the model
+        # for the original formula (before selectors are filtered out)
+        if self.processor:
+            self.model = self.processor.restore(self.model)
+
         self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
         self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
         self.model = sorted(self.model, key=lambda l: abs(l))
 
-        # if formula processing was used, we should
-        # restore the model for the original formula
-        if self.processor:
-            self.model = self.processor.restore(self.model)
-
         return self.model
 
     def next_level(self):
@@ -1648,14 +1663,17 @@ class RC2Stratified(RC2, object):
             to optimization levels up to the newly computed level. It
             also reactivates previously deactivated clauses (see
             :func:`process_sels` and :func:`process_sums` for
-            details).
+            details). Clauses whose weight exceeds the gap between
+            the upper and lower bounds are hardened instead.
         """
 
         end = min(self.levl + 1, len(self.blop))
 
         for l in range(beg, end):
             for sel in self.wstr[self.blop[l]]:
-                if sel in self.bckp_set:
+                if self.hard and self.blop[l] > self.ubnd - self.cost:
+                    self.oracle.add_clause([sel])
+                elif sel in self.bckp_set:
                     self.sels.append(sel)
                 else:
                     self.sums.append(sel)
@@ -1670,7 +1688,8 @@ class RC2Stratified(RC2, object):
             This method does postprocessing of the current
             optimization level after it is solved. This includes
             *hardening* some of the soft clauses (depending on their
-            remaining weights) and also garbage collection.
+            remaining weights) and also garbage collection. The
+            level's model is used to tighten the upper bound.
         """
 
         # assumptions to remove
@@ -1679,9 +1698,15 @@ class RC2Stratified(RC2, object):
         # sum of weights of the remaining levels
         sumw = sum([w * len(self.wstr[w]) for w in self.blop[(self.levl + 1):]])
 
+        # upper bound given by the current model;
+        # selectors unknown to the oracle are deemed to be falsified
+        model = self.oracle.get_model()
+        cost = sum([w for s, w in six.iteritems(self.owgt) if abs(s) > len(model) or model[abs(s) - 1] != s])
+        self.ubnd = min(self.ubnd, cost)
+
         # trying to harden selectors and sums
         for s in self.sels + self.sums:
-            if self.wght[s] > sumw:
+            if self.wght[s] > min(sumw, self.ubnd - self.cost):
                 self.oracle.add_clause([s])
                 self.garbage.add(s)
 
@@ -1983,6 +2008,12 @@ if __name__ == '__main__':
         else:
             MXS = RC2
 
+        if process and to_enum != 1 and block != -1:
+            # no formula processing in case we enumerate multiple models or
+            # MSSes, as blocking them refers to variables it may eliminate
+            print('c formula processing is disabled for model enumeration')
+            process = 0
+
         # starting the solver
         with MXS(formula, solver=solver, adapt=adapt, exhaust=exhaust,
                 incr=incr, minz=minz, process=process, trim=trim,

python_sat-1.9.dev22.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.13.2
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-aoldlhez\\cp315-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-aoldlhez\\cp315-win_amd64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-aoldlhez\\cp315-win_amd64\\built_wheel\\python_sat-1.9.dev22-cp315-cp315-win_amd64.whl']

{python_sat-1.9.dev20.dist-info → python_sat-1.9.dev22.dist-info}/METADATA

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

python_sat-1.9.dev22.dist-info/RECORD

@@ -0,0 +1,52 @@
+pycard.cp315-win_amd64.pyd,sha256=tef7CM3MyAIB0svbhn20WpE_xsIcCjBLDF0xNy4kdJE,77312
+pyformula.cp315-win_amd64.pyd,sha256=jVWzixCKAeF-ZNecwRm2YUqDsJXklovIb5euB_9EceQ,33792
+pysolvers.cp315-win_amd64.pyd,sha256=Pvzd9Dj4MBKmTGsk4DtSyxLJN4qrv1BGyag8JsguqMU,3663360
+pysat/card.py,sha256=JufbOKVdVrxABb3oKci3869eQytso58gLTqISac4H58,39252
+pysat/engines.py,sha256=G3hAOFuqc_GGf8ow5gKRLvNh48jiLInnQtIZSRwYuhs,48202
+pysat/formula.py,sha256=GCTvBA9TI7Q2klIaa6R1Suz2IwilNK4-31o8ADLXJaE,221485
+pysat/integer.py,sha256=McihZOmelBRKfw6Ng0A86_D_vLbXSvxla05tVWNyowk,99859
+pysat/pb.py,sha256=DjsHXwu5TG1FSbHg11DOV7kyZvtXHxknwHIL-z7udxQ,17974
+pysat/process.py,sha256=W0_Sm5rqas0SwZd5KgTuB35j2dA-WCg1Y4yqmIwLA9U,16255
+pysat/solvers.py,sha256=RTmMGLW6jeA0zOTzJWRpHTQEI1lLZAVHOg7w5BbysqI,332387
+pysat/_fileio.py,sha256=FxmRrrmCDay-2Guhdy0YhDlmVDAsCNaqfHzz18n_O5I,6924
+pysat/_utils.py,sha256=8mNX5XUKd9Bha99-jfvYgX2z2_CsE9z0DdEXCScSdCE,1398
+pysat/__init__.py,sha256=XG9iEubRItEdWdIvVpLAuEouzOynzprhtFWYtKRhS20,1018
+pysat/allies/approxmc.py,sha256=OV2nCeOKN69wXzGwHS9MH7exxYKW3wjMCwLD3GQ0Xqg,13971
+pysat/allies/unigen.py,sha256=d3uMDKiJzA7RLwfuZL4aniYbHPo28SqQd-h3jpmoOxU,17153
+pysat/allies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysat/examples/bbscan.py,sha256=iWUv5uvGuo5et1FaJfgNnnQ3ursgYA6dhUba0GXCk1k,22709
+pysat/examples/bica.py,sha256=yaV634q11Sox3ZJ5Un3JNVNbUzFYyisewZUjth8005k,28426
+pysat/examples/fm.py,sha256=Sir6X5lyYZ75T6MLGeU82YYCkHv_VfrZX4oK11BRvUE,18663
+pysat/examples/genhard.py,sha256=J6I3uVP5z0kipki6BWG7-LYpojcDTTXwXjeXBZ_m48A,19533
+pysat/examples/hitman.py,sha256=JTWHiPcOkuJdSUt9VTRw8rYpXfY_D4TOE1XgtdZvwMk,26763
+pysat/examples/lbx.py,sha256=F8NW2KI9Enxjxmq_cz9wHYM1gbOqp00ULk2i24_ljDM,24096
+pysat/examples/lsu.py,sha256=r1jKaon3QPTiPluBb3nzL9HW0HsoC5JfpMzfRUa_0GM,16700
+pysat/examples/mcsls.py,sha256=oaDtP2Z1cNa6LfsA8Jq4pUpz9wzLsnwE2q-4yWb1s2Q,22912
+pysat/examples/models.py,sha256=-KB2QPGjkXKo5Id_ro86xDzFsWMZXp9xbxQlwlNAJy0,5930
+pysat/examples/musx.py,sha256=vjBJ2tQcnuMLP5U0jwdEDOQxIpCQ-BPYRyL1s2KhSz4,11290
+pysat/examples/optux.py,sha256=YQSYYu6RHRWbp7EcJpHIgF3DadJhh2UQlpqL4xSpL0E,30521
+pysat/examples/primer.py,sha256=zSC3mx1I-t2yeo-Yn1bAK42rXi4VtFIgSJT-oiozUiU,23995
+pysat/examples/rc2.py,sha256=OkGxvQ8ufZME1GlDjmxB55hVHT5J526TWIncEBMWkn8,81083
+pysat/examples/usage.py,sha256=9IBfW4lBHoZVBEFURW73jhc12zSeFg8_-to9o3gc5nM,2246
+pysat/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_sat-1.9.dev22.data/platlib/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056
+python_sat-1.9.dev22.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
+python_sat-1.9.dev22.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
+python_sat-1.9.dev22.data/scripts/bica.py,sha256=659K6gdRBgYeNiLjQc_VnulXhbTHxnUljNYhXx-frwk,28413
+python_sat-1.9.dev22.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
+python_sat-1.9.dev22.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
+python_sat-1.9.dev22.data/scripts/lbx.py,sha256=1wAyfFjQQkhHte1OnSVhJviVmSEwWc0DaLro8fs6eik,24083
+python_sat-1.9.dev22.data/scripts/lsu.py,sha256=EpXQCu8ZdYoNgi70Uc1b8drOwp1fo82mhGbpjonjIzw,16687
+python_sat-1.9.dev22.data/scripts/mcsls.py,sha256=wetecyPhjfgu-jkjoZ4nrg3PiR2tCtLWLnQeiDCX5UU,22899
+python_sat-1.9.dev22.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
+python_sat-1.9.dev22.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
+python_sat-1.9.dev22.data/scripts/optux.py,sha256=9-4ynzXVYq7y67vy-emMbMx_gSlOBMDBX4VWkjSyHgE,30508
+python_sat-1.9.dev22.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
+python_sat-1.9.dev22.data/scripts/rc2.py,sha256=vIzgJEHSleKl45B_eENP31avWORuhaP5ogbLbf_N1HY,81070
+python_sat-1.9.dev22.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
+python_sat-1.9.dev22.dist-info/DELVEWHEEL,sha256=OVayoru_cuO5FCImHSOpRh8ZXCELyBN41oehf3dMm_8,413
+python_sat-1.9.dev22.dist-info/METADATA,sha256=_U0sZZ114kavqtqiooA_JEYZg9-B7ZfFHSsnoLzEWrE,1854
+python_sat-1.9.dev22.dist-info/RECORD,,
+python_sat-1.9.dev22.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
+python_sat-1.9.dev22.dist-info/WHEEL,sha256=0gLwYZa0C2fhgCxWR2c8HahwUiopqonVCV0wVwEg6fE,101
+python_sat-1.9.dev22.dist-info/licenses/LICENSE.txt,sha256=q-8zFb06i-6m_ueuQhkc1J4Ew2QByvODVIgm6fZYdTY,1130

python_sat-1.9.dev20.dist-info/DELVEWHEEL

@@ -1,2 +0,0 @@
-Version: 1.13.2
-Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-5__vq2mj\\cp315-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-5__vq2mj\\cp315-win_amd64\\repaired_wheel', '-v', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-5__vq2mj\\cp315-win_amd64\\built_wheel\\python_sat-1.9.dev20-cp315-cp315-win_amd64.whl']

python_sat-1.9.dev20.dist-info/RECORD

@@ -1,52 +0,0 @@
-pycard.cp315-win_amd64.pyd,sha256=aFw4f6LIc5XA4-oPHfv_YhNZ2rN3QcM7Za_RJ60qQsE,77312
-pyformula.cp315-win_amd64.pyd,sha256=SoQgGPWEw9693F94v4ingfy9yNxZhXHMOGxLntEXmpE,33792
-pysolvers.cp315-win_amd64.pyd,sha256=tJIhq5i20XIO3YF1hdYet3Of4DYHWpJO-2qem4Inxpo,3651072
-pysat/card.py,sha256=JufbOKVdVrxABb3oKci3869eQytso58gLTqISac4H58,39252
-pysat/engines.py,sha256=K4B9HrI6ni3qN9EW6siXhYZ6Gows5Z0ReQvl4Ks_-p0,47692
-pysat/formula.py,sha256=GCTvBA9TI7Q2klIaa6R1Suz2IwilNK4-31o8ADLXJaE,221485
-pysat/integer.py,sha256=McihZOmelBRKfw6Ng0A86_D_vLbXSvxla05tVWNyowk,99859
-pysat/pb.py,sha256=DjsHXwu5TG1FSbHg11DOV7kyZvtXHxknwHIL-z7udxQ,17974
-pysat/process.py,sha256=MoQm8gwsTWIP0yYYF_jZyF7sBnS6eXtCm1AgavvxZAY,13102
-pysat/solvers.py,sha256=ja022TLLVOVSUoeby79m35Avt5a2_3xq1XMXuXDf0Ns,328578
-pysat/_fileio.py,sha256=FxmRrrmCDay-2Guhdy0YhDlmVDAsCNaqfHzz18n_O5I,6924
-pysat/_utils.py,sha256=8mNX5XUKd9Bha99-jfvYgX2z2_CsE9z0DdEXCScSdCE,1398
-pysat/__init__.py,sha256=XYG2ytR4TQDilTPqSUrYPExDrxlTYm8atKfQxa52ddA,1018
-pysat/allies/approxmc.py,sha256=OV2nCeOKN69wXzGwHS9MH7exxYKW3wjMCwLD3GQ0Xqg,13971
-pysat/allies/unigen.py,sha256=d3uMDKiJzA7RLwfuZL4aniYbHPo28SqQd-h3jpmoOxU,17153
-pysat/allies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysat/examples/bbscan.py,sha256=iWUv5uvGuo5et1FaJfgNnnQ3ursgYA6dhUba0GXCk1k,22709
-pysat/examples/bica.py,sha256=yaV634q11Sox3ZJ5Un3JNVNbUzFYyisewZUjth8005k,28426
-pysat/examples/fm.py,sha256=Sir6X5lyYZ75T6MLGeU82YYCkHv_VfrZX4oK11BRvUE,18663
-pysat/examples/genhard.py,sha256=J6I3uVP5z0kipki6BWG7-LYpojcDTTXwXjeXBZ_m48A,19533
-pysat/examples/hitman.py,sha256=JTWHiPcOkuJdSUt9VTRw8rYpXfY_D4TOE1XgtdZvwMk,26763
-pysat/examples/lbx.py,sha256=pemAR7fQaxoFaHJRmz6FaL0ND6RgsxkIjWX8HBiCKrI,23887
-pysat/examples/lsu.py,sha256=r1jKaon3QPTiPluBb3nzL9HW0HsoC5JfpMzfRUa_0GM,16700
-pysat/examples/mcsls.py,sha256=GaGty5CU2D6v8W2pTP72tVYkYgQBpXTv9hM-XRXIMBU,22703
-pysat/examples/models.py,sha256=-KB2QPGjkXKo5Id_ro86xDzFsWMZXp9xbxQlwlNAJy0,5930
-pysat/examples/musx.py,sha256=vjBJ2tQcnuMLP5U0jwdEDOQxIpCQ-BPYRyL1s2KhSz4,11290
-pysat/examples/optux.py,sha256=YQSYYu6RHRWbp7EcJpHIgF3DadJhh2UQlpqL4xSpL0E,30521
-pysat/examples/primer.py,sha256=zSC3mx1I-t2yeo-Yn1bAK42rXi4VtFIgSJT-oiozUiU,23995
-pysat/examples/rc2.py,sha256=aOUq17SQCFQ4qr26RzO0M3LeUfoy9EaHJyg7-B_-rsA,79335
-pysat/examples/usage.py,sha256=9IBfW4lBHoZVBEFURW73jhc12zSeFg8_-to9o3gc5nM,2246
-pysat/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_sat-1.9.dev20.data/platlib/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056
-python_sat-1.9.dev20.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
-python_sat-1.9.dev20.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
-python_sat-1.9.dev20.data/scripts/bica.py,sha256=659K6gdRBgYeNiLjQc_VnulXhbTHxnUljNYhXx-frwk,28413
-python_sat-1.9.dev20.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
-python_sat-1.9.dev20.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
-python_sat-1.9.dev20.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
-python_sat-1.9.dev20.data/scripts/lsu.py,sha256=EpXQCu8ZdYoNgi70Uc1b8drOwp1fo82mhGbpjonjIzw,16687
-python_sat-1.9.dev20.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
-python_sat-1.9.dev20.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
-python_sat-1.9.dev20.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
-python_sat-1.9.dev20.data/scripts/optux.py,sha256=9-4ynzXVYq7y67vy-emMbMx_gSlOBMDBX4VWkjSyHgE,30508
-python_sat-1.9.dev20.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
-python_sat-1.9.dev20.data/scripts/rc2.py,sha256=YQ3UkYWVd2ge64u-SdqwVzZkHmj0tikYxXZS0O2pXy4,79322
-python_sat-1.9.dev20.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
-python_sat-1.9.dev20.dist-info/DELVEWHEEL,sha256=jztOobUxnDotEBBA_3W8R50us3SmVH4drwZWGIYeSwA,413
-python_sat-1.9.dev20.dist-info/METADATA,sha256=D0EUbf9MtSKJMOyIsA3DNbpzPKfx21RI8mPIplosjMs,1854
-python_sat-1.9.dev20.dist-info/RECORD,,
-python_sat-1.9.dev20.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
-python_sat-1.9.dev20.dist-info/WHEEL,sha256=0gLwYZa0C2fhgCxWR2c8HahwUiopqonVCV0wVwEg6fE,101
-python_sat-1.9.dev20.dist-info/licenses/LICENSE.txt,sha256=q-8zFb06i-6m_ueuQhkc1J4Ew2QByvODVIgm6fZYdTY,1130