python-sat 1.9.dev3__cp313-cp313-win_amd64.whl → 1.9.dev12__cp313-cp313-win_amd64.whl

pysat/__init__.py

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

pysat/engines.py

@@ -564,8 +564,11 @@ class Propagator(object):
                 def provide_reason(self, lit: int) -> List[int]:
                     pass      # explain why a given literal was propagated
 
+                def has_clause(self) -> bool:
+                    return False  # optional: report whether an external clause exists
+
                 def add_clause(self) -> List[int]:
-                    return [] # add an(y) external clause to the solver
+                    return [] # if has_clause() is used, may also be the empty clause
     """
 
     def __init__(self):
@@ -687,10 +690,9 @@ class Propagator(object):
 
     def add_clause(self) -> List[int]:
         """
-            The method is called by the solver to add an external clause if
-            there is any. The clause can be arbitrary but if it is
-            root-satisfied or tautological, the solver will ignore it without
-            learning it.
+            The method is called by the solver to obtain an external clause.
+            The clause can be arbitrary but if it is root-satisfied or
+            tautological, the solver will ignore it without learning it.
 
             Root-falsified literals are eagerly removed from the clause.
             Falsified clauses trigger conflict analysis, propagating clauses
@@ -700,6 +702,19 @@ class Propagator(object):
             An empty clause (or root falsified clause, see above) makes the
             formula unsatisfiable and stops the search immediately.
 
+            .. note::
+
+                The exact meaning of returning ``[]`` depends on whether the
+                propagator defines method ``has_clause()``.
+
+                - If ``has_clause()`` is defined, the solver first queries it.
+                  Whenever it returns ``True``, the follow-up call of
+                  :meth:`add_clause` is expected to return the clause itself,
+                  and ``[]`` denotes the actual empty clause.
+                - Otherwise, if ``has_clause()`` is undefined, returning
+                  ``[]`` from :meth:`add_clause` is interpreted as saying that
+                  there is no clause to add.
+
             :rtype: iterable(int)
         """
 
@@ -1283,14 +1298,25 @@ class BooleanEngine(Propagator):
 
         return [lit] + self.origin[lit].justify(lit)
 
+    def has_clause(self):
+        """
+            Check whether the engine currently has an external clause to add.
+            When queried separately by the solver, this lets
+            :meth:`add_clause` return ``[]`` as an actual empty clause.
+        """
+
+        return self.falsified is not None
+
     def add_clause(self):
         """
-            Extract a new clause to add to the solver if one exists; return an
-            empty clause ``[]`` otherwise.
+            Extract the external clause previously announced by
+            :meth:`has_clause`.
         """
 
-        if self.falsified is None:
-            return []
+        # # old behaviour checking if we have a clause to add;
+        # # commenting this out because we have has_clause() now
+        # if self.falsified is None:
+        #     return []
 
         to_add = self.falsified.explain_failure()
 

pysat/examples/rc2.py

@@ -131,9 +131,9 @@
 #
 #==============================================================================
 from __future__ import print_function
+import bisect
 import collections
 import getopt
-import itertools
 from math import copysign
 import os
 from pysat.formula import CNFPlus, WCNFPlus, IDPool
@@ -408,6 +408,9 @@ class RC2(object):
             :type clause: iterable(int)
             :type weight: int
 
+            :return: selector literal for a soft clause and ``None`` for a hard one
+            :rtype: int or None
+
             .. code-block:: python
 
                 >>> from pysat.examples.rc2 import RC2
@@ -448,6 +451,8 @@ class RC2(object):
                         '{0} does not support native cardinality constraints. Make sure you use the right type of formula.'.format(self.solver)
 
                 self.oracle.add_atmost(cl, clause[1], weights=clause[2] if len(clause) == 3 else [])
+
+            return None
         else:
             # soft clauses should be augmented with a selector
             selv = cl[0]  # for a unit clause, no selector is needed
@@ -471,6 +476,8 @@ class RC2(object):
             self.sall.append(selv)
             self.sels_set.add(selv)
 
+            return selv
+
     def delete(self):
         """
             Explicit destructor of the internal SAT oracle and all the
@@ -732,9 +739,12 @@ class RC2(object):
             self.minw = min(map(lambda l: self.wght[l], self.core))
 
             # dividing the core into two parts
-            iter1, iter2 = itertools.tee(self.core)
-            self.core_sels = list(l for l in iter1 if l in self.sels_set)
-            self.core_sums = list(l for l in iter2 if l not in self.sels_set)
+            self.core_sels, self.core_sums = [], []
+            for l in self.core:
+                if l in self.sels_set:
+                    self.core_sels.append(l)
+                else:
+                    self.core_sums.append(l)
 
     def process_core(self):
         """
@@ -810,8 +820,8 @@ class RC2(object):
             handled by calling :func:`process_am1`.
         """
 
-        # literal connections
-        conns = collections.defaultdict(lambda: set([]))
+        # literal connections and selectors conflicting on their own
+        conns = collections.defaultdict(list)
         confl = []
 
         # prepare connections
@@ -819,26 +829,29 @@ class RC2(object):
             st, props = self.oracle.propagate(assumptions=[l1], phase_saving=2)
             if st:
                 for l2 in props:
-                    if -l2 in self.sels_set:
-                        conns[l1].add(-l2)
-                        conns[-l2].add(l1)
+                    l2 = -l2
+                    if l2 in self.sels_set:
+                        conns[l1].append(l2)
+                        conns[l2].append(l1)
             else:
                 # propagating this literal results in a conflict
                 confl.append(l1)
 
-        if confl:  # filtering out unnecessary connections
-            ccopy = {}
-            confl = set(confl)
+        # sort (in-place) and deduplicate adjacency lists
+        for l in list(conns):
+            neigh = conns[l]
+            if neigh:
+                neigh.sort()
 
-            for l in conns:
-                if l not in confl:
-                    cc = conns[l].difference(confl)
-                    if cc:
-                        ccopy[l] = cc
+                j = 1
+                for i in range(1, len(neigh)):
+                    if neigh[i] != neigh[j - 1]:
+                        neigh[j] = neigh[i]
+                        j += 1
 
-            conns = ccopy
-            confl = list(confl)
+                del neigh[j:]
 
+        if confl:
             # processing unit size cores
             for l in confl:
                 self.core, self.minw = [l], self.wght[l]
@@ -849,24 +862,47 @@ class RC2(object):
                 print('c unit cores found: {0}; cost: {1}'.format(len(confl),
                     self.cost))
 
+        # the following graph manipulation requires
+        # fast membership checks for confl; making it a set
+        confl = set(confl)
+
+        # current degrees in the remaining graph;
+        # literals disconnected after removing conflicts are ignored
+        degree, lits = {}, set()
+        for l in conns:
+            if l not in confl:
+                d = sum(1 for l2 in conns[l] if l2 not in confl)
+                if d:
+                    degree[l] = d
+                    lits.add(l)
+
+        # detect AM1s on the original formula with conflicting selectors
+        # filtered out, similarly to the previous implementation
         nof_am1 = 0
         len_am1 = []
-        lits = set(conns.keys())
+
         while lits:
-            am1 = [min(lits, key=lambda l: len(conns[l]))]
+            am1 = [min(lits, key=lambda l: degree[l])]
 
-            for l in sorted(conns[am1[0]], key=lambda l: len(conns[l])):
+            for l in sorted(conns[am1[0]], key=lambda l: degree.get(l, 0)):
                 if l in lits:
                     for l_added in am1[1:]:
-                        if l_added not in conns[l]:
+                        # adjacency lists are sorted, so we use
+                        # binary search for clique membership tests
+                        i = bisect.bisect_left(conns[l], l_added)
+                        if i == len(conns[l]) or conns[l][i] != l_added:
                             break
                     else:
                         am1.append(l)
 
-            # updating remaining lits and connections
-            lits.difference_update(set(am1))
-            for l in conns:
-                conns[l] = conns[l].difference(set(am1))
+            # updating remaining literals and their degrees
+            am1_set = set(am1)
+            lits.difference_update(am1_set)
+
+            for l in am1:
+                for l2 in conns.get(l, []):
+                    if l2 in lits:
+                        degree[l2] -= 1
 
             if len(am1) > 1:
                 # treat the new atmost1 relation

pysat/formula.py

@@ -810,6 +810,13 @@ class Formula(object):
             :type type: :class:`FormulaType`
         """
 
+        # Formula.__new__ may return an existing structurally identical
+        # formula; by default, Python still invokes __init__ in that case,
+        # which is harmful; if an identical object exists, we should
+        # immediately return
+        if hasattr(self, 'type'):
+            return
+
         assert 'type' in kwargs, 'No \'type\' of the formula is provided'
         self.type = kwargs['type']
 
@@ -883,11 +890,11 @@ class Formula(object):
     @staticmethod
     def _get_key(*args, **kwargs):
         """
-            The method is used to extract and return a list of attributes to
-            serve as a key associated with the formula requested by a user.
-            The flattened result will contain string, i.e. ``repr()``,
-            representation of all the attributes. The method is meant to be
-            internal and not to be used by formula users.
+            The method is used to extract and return an immutable structural
+            key associated with the formula requested by a user. The key is
+            composed of tuples, frozensets, and scalar values rather than
+            string representations. The method is meant to be internal and
+            not to be used by formula users.
         """
 
         def _hashable(entity):
@@ -918,7 +925,6 @@ class Formula(object):
                     if isinstance(value, Iterable) and value:
                         items.extend(_flatten(value, prefix=new_key, sep=sep))
                     else:
-
                         items.append((new_key, value))
 
             # finally, it is a simple non-empty object
@@ -945,58 +951,136 @@ class Formula(object):
             elif item[0] != 'merge':
                 subfs.append(item)
             else:
-                extra = [('merge', repr(item[1]))]
+                extra = [('merge', item[1])]
+
+        def _object_key(obj):
+            """
+                Get a hashable key for an atom object.
+            """
+
+            if type(obj) in (bool, int, float, str, bytes, type(None)):
+                return ('val', type(obj), obj)
+            if type(obj) in (tuple, list):
+                return ('seq', tuple(_object_key(item) for item in obj))
+            if type(obj) in (set, frozenset):
+                return ('set', frozenset(_object_key(item) for item in obj))
+            if isinstance(obj, dict):
+                return ('map', frozenset((_object_key(key), _object_key(val)) for key, val in obj.items()))
+            try:
+                hash(obj)
+            except TypeError:
+                return ('identity', type(obj), id(obj))
+            return ('obj', type(obj), obj)
+
+        def _formula_key_uncached(form):
+            """
+                Get a structural key without a formula's merge flag.
+            """
+
+            if not isinstance(form, Formula):
+                return ('identity', type(form), id(form))
+
+            if form.type == FormulaType.CNF:
+                # CNF and CNFPlus are mutable containers and deliberately
+                # bypass Formula's unique-object constructor; using their
+                # object identity as it looks like the cheapest option
+                return ('cnf-object', type(form), id(form))
+
+            if form.type == FormulaType.ATOM:
+                return (FormulaType.ATOM, _object_key(form.object))
+            if form.type == FormulaType.NEG:
+                return (FormulaType.NEG, _formula_key(form.subformula))
+            if form.type == FormulaType.IMPL:
+                return (FormulaType.IMPL, _formula_key(form.left),
+                        _formula_key(form.right))
+            if form.type == FormulaType.ITE:
+                return (FormulaType.ITE, _formula_key(form.cond),
+                        _formula_key(form.cons1),
+                        _formula_key(form.cons2))
+
+            counts = collections.Counter(_formula_key(subform) for subform in form.subformulas)
+            return (form.type, frozenset(counts.items()))
+
+        def _formula_key(form):
+            """
+                Get a cached structural key for an immutable formula.
+            """
+
+            if isinstance(form, Formula):
+                key = getattr(form, '_key_cache', None)
+                if key is None:
+                    key = _formula_key_uncached(form)
+                    form._key_cache = key
+
+                return key
+
+            return _formula_key_uncached(form)
+
+        def _merged_operands(operands, formula_type):
+            """Flatten same-type operands for a merged connective."""
+            result = []
+            for operand in operands:
+                if isinstance(operand, Formula) and operand.type == formula_type:
+                    result.extend(_merged_operands(operand.subformulas,
+                                                   formula_type))
+                else:
+                    result.append(_formula_key(operand))
+            return result
 
-        # the ugly part:
-        # reconstructing the key pairs, depending on the type of Formula
-        if ftype[1] == FormulaType.ATOM:
+        # Reconstruct a structural key depending on the Formula type.
+        formula_type = ftype[1]
+        if formula_type == FormulaType.ATOM:
             assert len(subfs) == 1, 'A single object is required for an Atom formula'
-            subfs[0] = ('object', repr(subfs[0][1]))
-        elif ftype[1] == FormulaType.NEG:
+            return (formula_type, _object_key(subfs[0][1]))
+
+        if formula_type == FormulaType.NEG:
             assert len(subfs) == 1, 'A single subformula is required for a Neg formula'
-            subfs[0] = ('subformula', id(subfs[0][1]))
-        elif ftype[1] == FormulaType.IMPL:
+            return (formula_type, _formula_key(subfs[0][1]))
+
+        if formula_type == FormulaType.IMPL:
             assert len(subfs) == 2, 'Two subformulas are required for an Implies formula'
             if subfs[0][0] == '' and subfs[1][0] == '':
-                subfs[0] = ('left', id(subfs[0][1]))
-                subfs[1] = ('right', id(subfs[1][1]))
+                operands = [('left', subfs[0][1]), ('right', subfs[1][1])]
             elif subfs[1][0] == 'left':
-                subfs[0] = ('right', id(subfs[0][1]))
+                operands = [('right', subfs[0][1]), subfs[1]]
             elif subfs[1][0] == 'right':
-                subfs[0] = ('left', id(subfs[0][1]))
-        elif ftype[1] == FormulaType.ITE:
+                operands = [('left', subfs[0][1]), subfs[1]]
+            else:
+                operands = subfs
+            role_order = {'left': 0, 'right': 1}
+            return (formula_type, tuple( (label, _formula_key(value)) for \
+                    label, value in sorted(operands,
+                                           key=lambda pair: role_order[pair[0]])))
+
+        if formula_type == FormulaType.ITE:
             assert len(subfs) == 3, 'Three subformulas are required for an ITE formula'
-            if subfs[0][0] == '' and subfs[1][0] == '' and subfs[2][0] == '':
-                subfs[0] = ('cond', id(subfs[0][1]))
-                subfs[1] = ('cons1', id(subfs[1][1]))
-                subfs[2] = ('cons2',  id(subfs[2][1]))
+            if all(item[0] == '' for item in subfs):
+                subfs = [('cond', subfs[0][1]), ('cons1', subfs[1][1]), ('cons2', subfs[2][1])]
             elif subfs[0][0] == subfs[1][0] == '':
-                if subfs[2][0] == 'cond':
-                    subfs[0] = ('cons1', id(subfs[0][1]))
-                    subfs[1] = ('cons2', id(subfs[1][1]))
-                elif subfs[2][0] == 'cons1':
-                    subfs[0] = ('cond',  id(subfs[0][1]))
-                    subfs[1] = ('cons2', id(subfs[1][1]))
-                elif subfs[2][0] == 'cons2':
-                    subfs[0] = ('cond',  id(subfs[0][1]))
-                    subfs[1] = ('cons1', id(subfs[1][1]))
-            elif subfs[0] == '':
-                if 'cond' not in (subfs[1][0], subfs[2][0]):
-                    subfs[0] = ('cond', id(subfs[0][0]))
-                elif 'cons1' not in (subfs[1][0], subfs[2][0]):
-                    subfs[0] = ('cons1', id(subfs[0][0]))
-                elif 'cons2' not in (subfs[1][0], subfs[2][0]):
-                    subfs[0] = ('cons2', id(subfs[0][0]))
+                role = subfs[2][0]
+                missing = [r for r in ('cond', 'cons1', 'cons2') if r != role]
+                subfs = [(missing[0], subfs[0][1]), (missing[1], subfs[1][1]), subfs[2]]
+            elif subfs[0][0] == '':
+                roles = {item[0] for item in subfs[1:]}
+                missing = next(r for r in ('cond', 'cons1', 'cons2') if r not in roles)
+                subfs[0] = (missing, subfs[0][1])
+
+            role_order = {'cond': 0, 'cons1': 1, 'cons2': 2}
+            return (formula_type, tuple((label, _formula_key(value)) for \
+                    label, value in sorted(subfs,
+                                           key=lambda pair: role_order[pair[0]])))
+
+        # these are commutative connectives; representing operands as a
+        # multiset so that argument order is irrelevant while duplicate
+        # operands remain significant; a merged connective also flattens nested operands.
+        assert len(subfs) >= 1, 'At least one subformula is required for an And/Equals/Or/XOr formula'
+        merge = dict(extra).get('merge', False)
+        operands = [value for _, value in subfs]
+        if merge:
+            operands = _merged_operands(operands, formula_type)
         else:
-            # these are commutative connectives; we need to sort the arguments
-            assert len(subfs) >= 1, 'At least one subformula is required for an And/Equals/Or/XOr formula'
-            subfs = sorted(map(lambda p: (p[0], repr(id(p[1]))), subfs))
-
-            if not extra:
-                extra = [('merge', repr(False))]
-
-        # the key is a string combining all the parts
-        return ' '.join([f'{repr(p[0])}:{repr(p[1])}' for p in [ftype] + subfs + extra])
+            operands = [_formula_key(operand) for operand in operands]
+        return (formula_type, frozenset(collections.Counter(operands).items()), merge)
 
     def __hash__(self):
         """
@@ -1708,50 +1792,83 @@ class And(Formula):
 
     def _clausify(self, name_required=True):
         """
-            Conjuction clausification.
+            Conjunction clausification.
 
             If ``name_required`` is ``False``, the method recursively encodes
-            the subformulas and populates self's clauses with unit clauses,
-            each containing the auxiliary "name" of the corresponding
-            subformula, thus representing their conjunction.
-
-            If ``name_required`` is set to ``True``, the method encodes the
-            conjunction using the standard logic: :math:`x \\equiv
-            \\bigwedge{y_i}`, if :math:`x` is the new auxiliary variable
-            encoding ``self`` and :math:`y_i` is the auxiliary variable
-            representing :math:`i`'s subformula.
+            the subformulas expanding self's list of clauses and also
+            populates self's clauses with unit clauses, each containing the
+            auxiliary "name" of the corresponding subformula, thus
+            representing their conjunction. However, :class:`CNF` formulas
+            are expanded without introducing an intermediate Boolean name -
+            instead, they contribute their clausal representations to the
+            list of self's clauses unchanged.
+
+            If ``name_required`` is set to ``True``, the method introduces one
+            name for the complete conjunction and encodes the equivalence
+            between that name and the collected clauses.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         save_clauses = bool(self.clauses)
 
         if not self.clauses:
-            # first, recursively encoding subformulas
+            # recursively collect a clausal representation; CNF objects are
+            # already clausal, so they do not need a Boolean name at this
+            # level
             for sub in self.subformulas:
-                sub._clausify(name_required=True)
-
-                # adding unit clauses
-                self.clauses.append([sub.name])
+                if type(sub) is CNF:
+                    sub._clausify(name_required=False)
+                    self.clauses.extend(cl.copy() for cl in sub.clauses)
+                else:
+                    sub._clausify(name_required=True)
+                    self.clauses.append([sub.name])
 
-        # introducing a new name for this formula if required
+        # introducing a name is needed only when this conjunction is itself
+        # used by another connective; encode each non-unit clause with its own
+        # selector, then encode the conjunction of those selectors with the
+        # single name for this `And` formula
         if name_required and not self.name:
-            if save_clauses:
-                self.encoded = [clause.copy() for clause in self.clauses]
-            else:
-                self.encoded = self.clauses
-                self.clauses = []
+            self.encoded, enclits = [], []
 
-            self.name = Formula._vpool[Formula._context].id(self)
+            for cl in self.clauses:
+                auxv = cl[0]
+                if len(cl) > 1:
+                    auxv = Formula._vpool[Formula._context].id()
+
+                    # direct implication
+                    for l in cl:
+                        self.encoded.append([-l, auxv])
+
+                    # opposite implication
+                    self.encoded.append(cl + [-auxv])
 
-            cl = [self.name]  # final clause (converse implication)
-            for i in range(len(self.encoded)):
-                cl.append(-self.encoded[i][0])      # updating final clause
-                self.encoded[i].append(-self.name)  # updating direct implication
+                # literals representing the clauses
+                enclits.append(auxv)
 
-            # adding final clause
-            self.encoded.append(cl)
+            # encoding the conjunction
+            if len(enclits) > 1:
+                self.name = Formula._vpool[Formula._context].id(self)
+
+                for lit in enclits:
+                    self.encoded.append([lit, -self.name])
+                self.encoded.append([self.name] + [-lit for lit in enclits])
+            elif len(enclits) == 1:  # single clause - nothing left to encode
+                self.name = enclits[0]  # existing variable
+
+                # connecting it to the `And` object as its name
+                Formula._vpool[Formula._context].obj2id[self] = self.name
+                if self.name not in Formula._vpool[Formula._context].id2obj:
+                    Formula._vpool[Formula._context].id2obj[self.name] = self
+            else:
+                self.name = PYSAT_TRUE.name
+
+            # preserve clauses that existed before this call;
+            # they are still needed if the same formula is later iterated as
+            # an outermost formula
+            if not save_clauses:
+                self.clauses = []
 
     def _atoms(self, dest):
         """
@@ -1947,18 +2064,18 @@ class Or(Formula):
             Disjunction clausification.
 
             If ``name_required`` is ``False``, the method recursively encodes
-            the subformulas and populates self's clauses with unit clauses,
-            each containing the auxiliary "name" of the corresponding
-            subformula, thus representing their conjunction.
+            the subformulas and populates self's clauses with a unit clause
+            containing the auxiliary "name" of each corresponding subformula,
+            thus representing their disjunction.
 
             If ``name_required`` is set to ``True``, the method encodes the
-            conjunction using the standard logic: :math:`x \\equiv
+            disjunction using the standard logic: :math:`x \\equiv
             \\bigvee{y_i}`, if :math:`x` is the new auxiliary variable
             encoding ``self`` and :math:`y_i` is the auxiliary variable
             representing :math:`i`'s subformula.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         save_clauses = bool(self.clauses)
@@ -2136,7 +2253,7 @@ class Neg(Formula):
             is equal to the negation of subformula's name.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         if not self.clauses:
@@ -2307,7 +2424,7 @@ class Implies(Formula):
 
             If ``name_required`` is ``False``, the method recursively encodes
             the left and right subformulas giving them names, say, :math:`x`
-            and :math:`y` respectively and the populates self's clauses with a
+            and :math:`y` respectively, and populates self's clauses with a
             single binary clause :math:`(\\neg{x}\\lor y)`.
 
             If ``name_required`` is set to ``True``, the method removes this
@@ -2315,7 +2432,7 @@ class Implies(Formula):
             Tseitin-encoding it, i.e. :math:`n \\equiv (\\neg{x}\\lor y)`.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         save_clauses = bool(self.clauses)
@@ -2407,7 +2524,7 @@ class Equals(Formula):
             >>> from pysat.formula import *
             >>> a1 = Equals(Equals(Atom('x'), Atom('y')), Atom('z'))
             >>> a2 = Equals(Equals(Atom('x'), Atom('y')), Atom('z'), merge=True)
-            >>> a3 = Atom('x') == Atom('y') == Atom('z')
+            >>> a3 = Atom('x') @ Atom('y') @ Atom('z')
             >>>
             >>> print(a1)
             (x @ y) @ z
@@ -2571,7 +2688,7 @@ class Equals(Formula):
             relating it with the names of subformulas.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         save_clauses = bool(self.clauses)
@@ -2652,13 +2769,12 @@ class XOr(Formula):
 
         If an additional Boolean keyword argument ``merge`` is provided set to
         ``True``, the toolkit will try to flatten the current :class:`XOr`
-        formula merging its *equivalence* sub-operands into the list of
-        operands. For example, if ``XOr(XOr(x, y), z, merge=True)`` is called,
-        a new Formula object will be created with two operands: ``XOr(x, y)``
-        and ``z``, followed by merging ``x`` and ``y`` into the list of
-        root-level ``XOr``. This will result in a formula ``XOr(x, y, z)``.
-        Merging sub-operands is disabled by default if bitwise operations are
-        used to create ``XOr`` formulas.
+        formula merging its *exclusive-disjunction* sub-operands into the
+        list of operands. For example, if ``XOr(XOr(x, y), z, merge=True)`` is
+        called, a new Formula object will be created with two operands:
+        ``XOr(x, y)`` and ``z``, followed by merging ``x`` and ``y`` into the
+        list of root-level ``XOr``. This will result in a formula
+        ``XOr(x, y, z)``. Bitwise ``^`` operations also enable merging.
 
         Example:
 
@@ -2679,8 +2795,8 @@ class XOr(Formula):
             >>> id(a1) == id(a2)
             False
             >>>
-            >>> id(a1) == id(a3)
-            True  # formulas a1 and a3 refer to the same object
+            >>> id(a2) == id(a3)
+            True  # formulas a2 and a3 refer to the same object
 
         .. note::
 
@@ -2766,7 +2882,7 @@ class XOr(Formula):
                 >>> a = x ^ y ^ z
                 >>>
                 >>> print(a.simplified(assumptions=[y]))
-                ~x ^ z
+                ~(x ^ z)
                 >>> print(a.simplified(assumptions=[~y]))
                 x ^ z
         """
@@ -2817,7 +2933,7 @@ class XOr(Formula):
             variable for each pair of operands.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         save_clauses = bool(self.clauses)
@@ -2943,7 +3059,7 @@ class ITE(Formula):
             >>> ite = ITE(x, y, z)
             >>>
             >>> print(ite)
-            >>> (x >> y) & (~x >> z)
+            (x >> y) & (~x >> z)
     """
 
     def __new__(cls, *args, **kwargs):
@@ -3071,17 +3187,17 @@ class ITE(Formula):
 
             If ``name_required`` is ``False``, the method recursively encodes
             the ``cond``, ``cons1``, and ``cons2`` subformulas giving them
-            names, say, :math:`x`, :math:`y`, and :math:`z`, respectivela, and
-            the populates self's clauses with two binary clauses
-            :math:`(\\neg{x}\\lor y)` and :math:`(x \\lor y)`.
+            names, say, :math:`x`, :math:`y`, and :math:`z`, respectively, and
+            populates self's clauses with two binary clauses
+            :math:`(\\neg{x}\\lor y)` and :math:`(x \\lor z)`.
 
             If ``name_required`` is set to ``True``, the method removes these
             clauses and instead gives a name to the ITE by Tseitin-encoding
             it, i.e. encoding :math:`n \\equiv \\left[(\\neg{x}\\lor
-            y)\\land(x\\lor y)\\right]`.
+            y)\\land(x\\lor z)\\right]`.
 
             :param name_required: whether or not a Tseitin variable is needed
-            :param name_required: bool
+            :type name_required: bool
         """
 
         save_clauses = bool(self.clauses)
@@ -3136,7 +3252,7 @@ class ITE(Formula):
         """
             Informal representation of the ``ITE`` formula. Returns a string
             representation of the subformulas as two implications connected
-            with the conjuction symbol ``' & '``
+            with the conjunction symbol ``' & '``
         """
 
         cons1 = '{0} >> {1}'.format(f'{str(self.cond)}' if self.cond.type in (FormulaType.ATOM, FormulaType.NEG) else f'({str(self.cond)})',
@@ -3898,7 +4014,7 @@ class CNF(Formula, object):
                 for lit in enclits:
                     clauses.append([-self.name, lit])
                 clauses.append([self.name] + [-lit for lit in enclits])
-            else:  # single clause - nothing left to encode
+            elif len(enclits) == 1:  # single clause - nothing left to encode
                 self.name = enclits[0]  # existing variable
 
                 # connecting it to the CNF object as its name
@@ -3907,6 +4023,8 @@ class CNF(Formula, object):
 
                 # just in case, marking all ids below self.name as occupied
                 Formula._vpool[Formula._context].occupy(1, self.name)
+            else:
+                self.name = PYSAT_TRUE.name
 
             self.encoded = clauses
             self.auxvars = auxvars
@@ -4129,6 +4247,7 @@ class WCNF(object):
         # normalize it, i.e. transform into a set of clauses
         # with a positive weight
         if negs:
+            self.nv = max(self.nv, max(map(lambda cl: max(map(abs, cl[0])), negs)))
             self.normalize_negatives(negs)
 
         # if topw was unspecified and assigned to +infinity,
@@ -5380,6 +5499,7 @@ class WCNFPlus(WCNF, object):
         # normalize it, i.e. transform into a set of clauses
         # with a positive weight
         if negs:
+            self.nv = max(self.nv, max(map(lambda cl: max(map(abs, cl[0])), negs)))
             self.normalize_negatives(negs)
 
         # if topw was unspecified and assigned to +infinity,

pysat/solvers.py

@@ -184,9 +184,9 @@
     settings. For that reason, :class:`Cadical300`'s BVA is disabled by
     default whenever it is created without a synchronized
     :class:`.pysat.formula.IDPool`. Users who want BVA can either enable it
-    manually with :meth:`.configure` or attach a shared pool with
-    :meth:`.attach_vpool` and keep it synchronized explicitly with
-    :meth:`.sync_vpool`.
+    manually with :meth:`.Solver.configure` or attach a shared pool with
+    :meth:`.Solver.attach_vpool` and keep it synchronized explicitly with
+    :meth:`.Solver.sync_vpool`.
 
     ==============
     Module details

{python_sat-1.9.dev3.data → python_sat-1.9.dev12.data}/scripts/rc2.py

@@ -131,9 +131,9 @@
 #
 #==============================================================================
 from __future__ import print_function
+import bisect
 import collections
 import getopt
-import itertools
 from math import copysign
 import os
 from pysat.formula import CNFPlus, WCNFPlus, IDPool
@@ -408,6 +408,9 @@ class RC2(object):
             :type clause: iterable(int)
             :type weight: int
 
+            :return: selector literal for a soft clause and ``None`` for a hard one
+            :rtype: int or None
+
             .. code-block:: python
 
                 >>> from pysat.examples.rc2 import RC2
@@ -448,6 +451,8 @@ class RC2(object):
                         '{0} does not support native cardinality constraints. Make sure you use the right type of formula.'.format(self.solver)
 
                 self.oracle.add_atmost(cl, clause[1], weights=clause[2] if len(clause) == 3 else [])
+
+            return None
         else:
             # soft clauses should be augmented with a selector
             selv = cl[0]  # for a unit clause, no selector is needed
@@ -471,6 +476,8 @@ class RC2(object):
             self.sall.append(selv)
             self.sels_set.add(selv)
 
+            return selv
+
     def delete(self):
         """
             Explicit destructor of the internal SAT oracle and all the
@@ -732,9 +739,12 @@ class RC2(object):
             self.minw = min(map(lambda l: self.wght[l], self.core))
 
             # dividing the core into two parts
-            iter1, iter2 = itertools.tee(self.core)
-            self.core_sels = list(l for l in iter1 if l in self.sels_set)
-            self.core_sums = list(l for l in iter2 if l not in self.sels_set)
+            self.core_sels, self.core_sums = [], []
+            for l in self.core:
+                if l in self.sels_set:
+                    self.core_sels.append(l)
+                else:
+                    self.core_sums.append(l)
 
     def process_core(self):
         """
@@ -810,8 +820,8 @@ class RC2(object):
             handled by calling :func:`process_am1`.
         """
 
-        # literal connections
-        conns = collections.defaultdict(lambda: set([]))
+        # literal connections and selectors conflicting on their own
+        conns = collections.defaultdict(list)
         confl = []
 
         # prepare connections
@@ -819,26 +829,29 @@ class RC2(object):
             st, props = self.oracle.propagate(assumptions=[l1], phase_saving=2)
             if st:
                 for l2 in props:
-                    if -l2 in self.sels_set:
-                        conns[l1].add(-l2)
-                        conns[-l2].add(l1)
+                    l2 = -l2
+                    if l2 in self.sels_set:
+                        conns[l1].append(l2)
+                        conns[l2].append(l1)
             else:
                 # propagating this literal results in a conflict
                 confl.append(l1)
 
-        if confl:  # filtering out unnecessary connections
-            ccopy = {}
-            confl = set(confl)
+        # sort (in-place) and deduplicate adjacency lists
+        for l in list(conns):
+            neigh = conns[l]
+            if neigh:
+                neigh.sort()
 
-            for l in conns:
-                if l not in confl:
-                    cc = conns[l].difference(confl)
-                    if cc:
-                        ccopy[l] = cc
+                j = 1
+                for i in range(1, len(neigh)):
+                    if neigh[i] != neigh[j - 1]:
+                        neigh[j] = neigh[i]
+                        j += 1
 
-            conns = ccopy
-            confl = list(confl)
+                del neigh[j:]
 
+        if confl:
             # processing unit size cores
             for l in confl:
                 self.core, self.minw = [l], self.wght[l]
@@ -849,24 +862,47 @@ class RC2(object):
                 print('c unit cores found: {0}; cost: {1}'.format(len(confl),
                     self.cost))
 
+        # the following graph manipulation requires
+        # fast membership checks for confl; making it a set
+        confl = set(confl)
+
+        # current degrees in the remaining graph;
+        # literals disconnected after removing conflicts are ignored
+        degree, lits = {}, set()
+        for l in conns:
+            if l not in confl:
+                d = sum(1 for l2 in conns[l] if l2 not in confl)
+                if d:
+                    degree[l] = d
+                    lits.add(l)
+
+        # detect AM1s on the original formula with conflicting selectors
+        # filtered out, similarly to the previous implementation
         nof_am1 = 0
         len_am1 = []
-        lits = set(conns.keys())
+
         while lits:
-            am1 = [min(lits, key=lambda l: len(conns[l]))]
+            am1 = [min(lits, key=lambda l: degree[l])]
 
-            for l in sorted(conns[am1[0]], key=lambda l: len(conns[l])):
+            for l in sorted(conns[am1[0]], key=lambda l: degree.get(l, 0)):
                 if l in lits:
                     for l_added in am1[1:]:
-                        if l_added not in conns[l]:
+                        # adjacency lists are sorted, so we use
+                        # binary search for clique membership tests
+                        i = bisect.bisect_left(conns[l], l_added)
+                        if i == len(conns[l]) or conns[l][i] != l_added:
                             break
                     else:
                         am1.append(l)
 
-            # updating remaining lits and connections
-            lits.difference_update(set(am1))
-            for l in conns:
-                conns[l] = conns[l].difference(set(am1))
+            # updating remaining literals and their degrees
+            am1_set = set(am1)
+            lits.difference_update(am1_set)
+
+            for l in am1:
+                for l2 in conns.get(l, []):
+                    if l2 in lits:
+                        degree[l2] -= 1
 
             if len(am1) > 1:
                 # treat the new atmost1 relation

{python_sat-1.9.dev3.dist-info → python_sat-1.9.dev12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev3
+Version: 1.9.dev12
 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.dev12.dist-info/RECORD

@@ -0,0 +1,50 @@
+pycard.cp313-win_amd64.pyd,sha256=D53SVLi3JhMdEfqTkJO1bgTsDVhh_lfdJoB8-XKEIHA,71680
+pyformula.cp313-win_amd64.pyd,sha256=J7eXIRP8RrOdwbynbwkc4oEnMQIP0HsnBDFN3BzaAfI,31232
+pysolvers.cp313-win_amd64.pyd,sha256=sjflLpYHydwda4Y6amRmn0WI66Ui8ZdWe4S_ECq4OYE,3340288
+pysat/__init__.py,sha256=NUV138GbmWkxc-cwJx_fsLTx9ps9VuNoI2fx0C9Pf5Q,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/engines.py,sha256=yAYA_PzIGr_uRF85M7kL2bipjpLbY7jdfFKTdY-yW8I,46364
+pysat/formula.py,sha256=zmAceFu7gpvopLWfpXSZVH9jaQY_5FOGt03lrse3X1Y,215477
+pysat/integer.py,sha256=um6FXUzmBHUFlWXNKs0xLh9Jss3jiEin2Er_U41KtkA,90203
+pysat/pb.py,sha256=DMy8UfbbpfJo5cTZul9W1o_mlr-B0lCIEseZjrQYd8A,17816
+pysat/process.py,sha256=8lNbpEKipFZjbQ9DCJPfdL8eZHx-ltNuu7h4geWWdJY,12739
+pysat/solvers.py,sha256=JTZU2O-rrmUKDRNq0vLm0wtXIGsftwhGxxQZdGiij34,277199
+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
+pysat/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysat/examples/bbscan.py,sha256=E4Y5j3Llr0-jIn-RDZIk-f02Sbujg4wX7uysoiFRnLg,22046
+pysat/examples/bica.py,sha256=OGcGQGQnMepCCurwRbygokFgoDkI7eBhjmsYvr3FM1M,27098
+pysat/examples/fm.py,sha256=e_s6wNBstEeoMw9zYyyDRgkE-Hqa902Iy_CxCS961CE,18136
+pysat/examples/genhard.py,sha256=DFXtSVQ4qn78y0-ZMr2D6gBCLizZSzgkvcbDsjqjnKI,19017
+pysat/examples/hitman.py,sha256=vHJEeSfoMQlDD3D3Poofaryv-k_dMH37XoqVXJUUuUg,26360
+pysat/examples/lbx.py,sha256=InMjqY-9UvWKznIXOEwfBsM4spfkduDld6gUkr1jCqo,23249
+pysat/examples/lsu.py,sha256=qyN2TvXG61EtMy-IrX5EYmLPM_iNOhtOkGTY5nHO_zo,16198
+pysat/examples/mcsls.py,sha256=bP47P56OOP_uy0MuFA7TGxMdkAis7gX4E9AEEI0tSec,22093
+pysat/examples/models.py,sha256=cdIR8iOrYu2ibqfcb_kEKXQMCfmFiz7cvZ3y1dur3Qw,5741
+pysat/examples/musx.py,sha256=hswVGkjm95lhOyrtl1e4ouDyNSy-hWvQ05084Xnck9I,10946
+pysat/examples/optux.py,sha256=8eYHO_uhL_4ugb-hRv2s6cnOwTurfqkpbdnK9T4iDtw,27697
+pysat/examples/primer.py,sha256=0OeV9R6mWyIr2BKIitkrfgY3q2XE-sV1ZLSiybGRFXw,23375
+pysat/examples/rc2.py,sha256=7-FuygxAbgNYb9QmKsNhkK5EG5OW8mpHOpoA8GnDs28,76998
+pysat/examples/usage.py,sha256=x9luw6pyKAAndlxAeUWFhS4aLSVmD2t_j_5uA9YddHg,2183
+python_sat-1.9.dev12.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
+python_sat-1.9.dev12.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
+python_sat-1.9.dev12.data/scripts/bica.py,sha256=q6fQGsFp1EaaYRZGBsDFOIJPVScr5k42XFskBzW69mA,27776
+python_sat-1.9.dev12.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
+python_sat-1.9.dev12.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
+python_sat-1.9.dev12.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
+python_sat-1.9.dev12.data/scripts/lsu.py,sha256=cAATg2x0Cu1LC8KszMctHqywjq7pygkb9vWNBrbUEZs,16681
+python_sat-1.9.dev12.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
+python_sat-1.9.dev12.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
+python_sat-1.9.dev12.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
+python_sat-1.9.dev12.data/scripts/optux.py,sha256=t20YBZH4_axTkRMapq-DL-fq-9tBybPWo0pkhIyGhDw,28394
+python_sat-1.9.dev12.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
+python_sat-1.9.dev12.data/scripts/rc2.py,sha256=vvB7GlzssovGtnyk-COK-1bxmPh4zpj8Y7GqQa9dC9U,79020
+python_sat-1.9.dev12.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
+python_sat-1.9.dev12.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
+python_sat-1.9.dev12.dist-info/METADATA,sha256=sJK6NIR39c2zlQYICi7dM1ZNAHAc91t0iQTGNIBJCUI,1784
+python_sat-1.9.dev12.dist-info/WHEEL,sha256=0LUNoHxLvcpw9db_x0XozE5jW73-_GOAO7fDDJ4Xt4Q,101
+python_sat-1.9.dev12.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
+python_sat-1.9.dev12.dist-info/RECORD,,

{python_sat-1.9.dev3.dist-info → python_sat-1.9.dev12.dist-info}/WHEEL

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

python_sat-1.9.dev3.dist-info/RECORD

@@ -1,50 +0,0 @@
-pycard.cp313-win_amd64.pyd,sha256=imahNXZGs_FQFbCmOasfz7D2m4dZ8rCXTaP-oGeM_Wk,71680
-pyformula.cp313-win_amd64.pyd,sha256=T6n_TZi4gxd80YRi9nv0wcRL0v23633jdwjvthNmw7M,30208
-pysolvers.cp313-win_amd64.pyd,sha256=xf58mzY8XyIsBQcbqI8yRz7L-W0FniikTXCqfCFXmDU,3332608
-pysat/__init__.py,sha256=G7mBSiK_F_B3A_VWDDB1c8RXtNIGmgHsZ5-JV8Md9Ko,680
-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/engines.py,sha256=PzcZJ4zFXDHfcSSHF7iPadtrwSVEt4t9B_cO5epwTZk,45182
-pysat/formula.py,sha256=3VdJYS6jZDRWSwn_KfofTmwD_x401O-3rQyfzgORL6o,210084
-pysat/integer.py,sha256=um6FXUzmBHUFlWXNKs0xLh9Jss3jiEin2Er_U41KtkA,90203
-pysat/pb.py,sha256=DMy8UfbbpfJo5cTZul9W1o_mlr-B0lCIEseZjrQYd8A,17816
-pysat/process.py,sha256=8lNbpEKipFZjbQ9DCJPfdL8eZHx-ltNuu7h4geWWdJY,12739
-pysat/solvers.py,sha256=puvS7W8TjBz5cIb65XgXv3KaSNjvJS8aju_AepJGyKA,277178
-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
-pysat/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysat/examples/bbscan.py,sha256=E4Y5j3Llr0-jIn-RDZIk-f02Sbujg4wX7uysoiFRnLg,22046
-pysat/examples/bica.py,sha256=OGcGQGQnMepCCurwRbygokFgoDkI7eBhjmsYvr3FM1M,27098
-pysat/examples/fm.py,sha256=e_s6wNBstEeoMw9zYyyDRgkE-Hqa902Iy_CxCS961CE,18136
-pysat/examples/genhard.py,sha256=DFXtSVQ4qn78y0-ZMr2D6gBCLizZSzgkvcbDsjqjnKI,19017
-pysat/examples/hitman.py,sha256=vHJEeSfoMQlDD3D3Poofaryv-k_dMH37XoqVXJUUuUg,26360
-pysat/examples/lbx.py,sha256=InMjqY-9UvWKznIXOEwfBsM4spfkduDld6gUkr1jCqo,23249
-pysat/examples/lsu.py,sha256=qyN2TvXG61EtMy-IrX5EYmLPM_iNOhtOkGTY5nHO_zo,16198
-pysat/examples/mcsls.py,sha256=bP47P56OOP_uy0MuFA7TGxMdkAis7gX4E9AEEI0tSec,22093
-pysat/examples/models.py,sha256=cdIR8iOrYu2ibqfcb_kEKXQMCfmFiz7cvZ3y1dur3Qw,5741
-pysat/examples/musx.py,sha256=hswVGkjm95lhOyrtl1e4ouDyNSy-hWvQ05084Xnck9I,10946
-pysat/examples/optux.py,sha256=8eYHO_uhL_4ugb-hRv2s6cnOwTurfqkpbdnK9T4iDtw,27697
-pysat/examples/primer.py,sha256=0OeV9R6mWyIr2BKIitkrfgY3q2XE-sV1ZLSiybGRFXw,23375
-pysat/examples/rc2.py,sha256=QjN-LbLWNnDwSyZKn10_INniPpIK8dv_0BGPZzbXxa8,75763
-pysat/examples/usage.py,sha256=x9luw6pyKAAndlxAeUWFhS4aLSVmD2t_j_5uA9YddHg,2183
-python_sat-1.9.dev3.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
-python_sat-1.9.dev3.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
-python_sat-1.9.dev3.data/scripts/bica.py,sha256=q6fQGsFp1EaaYRZGBsDFOIJPVScr5k42XFskBzW69mA,27776
-python_sat-1.9.dev3.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
-python_sat-1.9.dev3.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
-python_sat-1.9.dev3.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
-python_sat-1.9.dev3.data/scripts/lsu.py,sha256=cAATg2x0Cu1LC8KszMctHqywjq7pygkb9vWNBrbUEZs,16681
-python_sat-1.9.dev3.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
-python_sat-1.9.dev3.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
-python_sat-1.9.dev3.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
-python_sat-1.9.dev3.data/scripts/optux.py,sha256=t20YBZH4_axTkRMapq-DL-fq-9tBybPWo0pkhIyGhDw,28394
-python_sat-1.9.dev3.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
-python_sat-1.9.dev3.data/scripts/rc2.py,sha256=yFieB6_5sYLLfIRo6Al9DXt3V5Y-qIUYH5E89xoaLN4,77749
-python_sat-1.9.dev3.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
-python_sat-1.9.dev3.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
-python_sat-1.9.dev3.dist-info/METADATA,sha256=7JnxB6MFLeaqZ3M8n_ZUJGRtlFnrgEm25bwE9XJ__VE,1783
-python_sat-1.9.dev3.dist-info/WHEEL,sha256=x5Wpw_tLx5PQKiWdxpqvs0e7Sg-SO0mTWdEADYDGPGA,101
-python_sat-1.9.dev3.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
-python_sat-1.9.dev3.dist-info/RECORD,,