python-sat 1.9.dev6__cp313-cp313-win_amd64.whl → 1.9.dev8__cp313-cp313-win_amd64.whl

pysat/__init__.py

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

pysat/examples/rc2.py

@@ -134,7 +134,6 @@ 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
@@ -740,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):
         """

pysat/formula.py

@@ -883,11 +883,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 +918,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 +944,121 @@ 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(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 _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 +1770,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, nested :class:`And` and
+            :class:`CNF` formulas are expanded without introducing
+            intermediate Boolean names - 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; nested `And` and
+            # `CNF` objects are conjunctions already, 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) in (And, CNF):
+                    sub._clausify(name_required=False)
+                    self.clauses.extend(clause.copy() for clause 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])
+
+                # literals representing the clauses
+                enclits.append(auxv)
+
+            # encoding the conjunction
+            if len(enclits) > 1:
+                self.name = Formula._vpool[Formula._context].id(self)
 
-            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
+                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
 
-            # adding final clause
-            self.encoded.append(cl)
+                # 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 +2042,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 +2231,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 +2402,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 +2410,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 +2502,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 +2666,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 +2747,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 +2773,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 +2860,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 +2911,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 +3037,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 +3165,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 +3230,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 +3992,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 +4001,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 +4225,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 +5477,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,

{python_sat-1.9.dev6.data → python_sat-1.9.dev8.data}/scripts/rc2.py

@@ -134,7 +134,6 @@ 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
@@ -740,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):
         """

{python_sat-1.9.dev6.dist-info → python_sat-1.9.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev6
+Version: 1.9.dev8
 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.dev6.dist-info → python_sat-1.9.dev8.dist-info}/RECORD

@@ -1,12 +1,12 @@
-pycard.cp313-win_amd64.pyd,sha256=_YeCSdLzg77f5jzn0O8_yW8edYghRbQeWRwpgGsdIy0,71680
-pyformula.cp313-win_amd64.pyd,sha256=MSBPHrc1zv9M7z5F-B4HWOT4yDrIWloGhvn8pJF2PEM,30208
-pysolvers.cp313-win_amd64.pyd,sha256=V_v8vFftnxTtQEUuBEHdDHc95Ico5BmwZsxhbh2C2iw,3340288
-pysat/__init__.py,sha256=3xVN-13D2BJd2W6nYySBDnNAaIspI_4CrJBoATo0EMQ,680
+pycard.cp313-win_amd64.pyd,sha256=_voIGCx_18yyEut1hwFyQQOXXx0cpK7SUk9XUk1FeJg,71680
+pyformula.cp313-win_amd64.pyd,sha256=IM84nhDX6glnVN5r00up53DLBbEcnvYiu0_obtp1IhU,31232
+pysolvers.cp313-win_amd64.pyd,sha256=euQwMYwmZ2b0O2vmc0kt9TaoL5FtGz14WOQmtA858d0,3340288
+pysat/__init__.py,sha256=QTCb8kNOCtmIuJySA5yDeowVukzE_yj5qxdVTBdzgaM,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=yAYA_PzIGr_uRF85M7kL2bipjpLbY7jdfFKTdY-yW8I,46364
-pysat/formula.py,sha256=3VdJYS6jZDRWSwn_KfofTmwD_x401O-3rQyfzgORL6o,210084
+pysat/formula.py,sha256=qCT-1__FtpTNemKFnixKOEi7Pwt3EIUnY_3TgQUcDWw,214793
 pysat/integer.py,sha256=um6FXUzmBHUFlWXNKs0xLh9Jss3jiEin2Er_U41KtkA,90203
 pysat/pb.py,sha256=DMy8UfbbpfJo5cTZul9W1o_mlr-B0lCIEseZjrQYd8A,17816
 pysat/process.py,sha256=8lNbpEKipFZjbQ9DCJPfdL8eZHx-ltNuu7h4geWWdJY,12739
@@ -27,24 +27,24 @@ 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=i1sH8ukXng56Vx-KnA2GiOvC_aCa_vFRVGoTMJoZjW4,76984
+pysat/examples/rc2.py,sha256=7-FuygxAbgNYb9QmKsNhkK5EG5OW8mpHOpoA8GnDs28,76998
 pysat/examples/usage.py,sha256=x9luw6pyKAAndlxAeUWFhS4aLSVmD2t_j_5uA9YddHg,2183
-python_sat-1.9.dev6.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
-python_sat-1.9.dev6.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
-python_sat-1.9.dev6.data/scripts/bica.py,sha256=q6fQGsFp1EaaYRZGBsDFOIJPVScr5k42XFskBzW69mA,27776
-python_sat-1.9.dev6.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
-python_sat-1.9.dev6.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
-python_sat-1.9.dev6.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
-python_sat-1.9.dev6.data/scripts/lsu.py,sha256=cAATg2x0Cu1LC8KszMctHqywjq7pygkb9vWNBrbUEZs,16681
-python_sat-1.9.dev6.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
-python_sat-1.9.dev6.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
-python_sat-1.9.dev6.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
-python_sat-1.9.dev6.data/scripts/optux.py,sha256=t20YBZH4_axTkRMapq-DL-fq-9tBybPWo0pkhIyGhDw,28394
-python_sat-1.9.dev6.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
-python_sat-1.9.dev6.data/scripts/rc2.py,sha256=yJL34GQclQakHH_Ksgt431Xwi7lmTZtiRI0VClHlirU,79004
-python_sat-1.9.dev6.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
-python_sat-1.9.dev6.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
-python_sat-1.9.dev6.dist-info/METADATA,sha256=konIlhC8zDuRr1L6yUDS5rlPNvM2j-doYxWwAH-lCzQ,1783
-python_sat-1.9.dev6.dist-info/WHEEL,sha256=AP_wkikJcUkDPUGvTNydv7g0R7BhW1u_fVHNKW7TJyI,101
-python_sat-1.9.dev6.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
-python_sat-1.9.dev6.dist-info/RECORD,,
+python_sat-1.9.dev8.data/scripts/approxmc.py,sha256=h6aMnSpIaYXkTMq-tCSzNWwKb0AG-vTH4vuLWGn5Q4s,13958
+python_sat-1.9.dev8.data/scripts/bbscan.py,sha256=xGxklG6Gc_UBaM8QvEJDOtQhEamxAncfsd65E-0JcAc,22696
+python_sat-1.9.dev8.data/scripts/bica.py,sha256=q6fQGsFp1EaaYRZGBsDFOIJPVScr5k42XFskBzW69mA,27776
+python_sat-1.9.dev8.data/scripts/fm.py,sha256=ek1QDsuxiq1zm1PBLbrSXXEE89RP9_DYwVNnyB3eO4s,18650
+python_sat-1.9.dev8.data/scripts/genhard.py,sha256=YswufT272W4xTJrSBlOC2ucJx4RK4ntfRv73rASrx30,19520
+python_sat-1.9.dev8.data/scripts/lbx.py,sha256=rCQ6zH_DXoVjBrzhZHSDJMfP92-hz2JVwh6e4m44AUc,23874
+python_sat-1.9.dev8.data/scripts/lsu.py,sha256=cAATg2x0Cu1LC8KszMctHqywjq7pygkb9vWNBrbUEZs,16681
+python_sat-1.9.dev8.data/scripts/mcsls.py,sha256=cTJQMIO-4iho412wG0JhvhqXWy81U0RQV8wwOgkri3Q,22690
+python_sat-1.9.dev8.data/scripts/models.py,sha256=UmMmklExzyXAIhh-0i038nQb7hTK6CbdV1M6m2GxxSI,5917
+python_sat-1.9.dev8.data/scripts/musx.py,sha256=LwK10YuQ8pIf1TJwp0HKp54O0hdk8zBy3TIfGsF1yW0,11277
+python_sat-1.9.dev8.data/scripts/optux.py,sha256=t20YBZH4_axTkRMapq-DL-fq-9tBybPWo0pkhIyGhDw,28394
+python_sat-1.9.dev8.data/scripts/primer.py,sha256=iE9Vy0XyeySIY-7-L_VMwRahsIVCEmm9k04OhLwDvuw,23982
+python_sat-1.9.dev8.data/scripts/rc2.py,sha256=vvB7GlzssovGtnyk-COK-1bxmPh4zpj8Y7GqQa9dC9U,79020
+python_sat-1.9.dev8.data/scripts/unigen.py,sha256=e-HC2UxWA8MTN90VslkHX1ZlTPjdhI4etzkn6G8YAX4,17140
+python_sat-1.9.dev8.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
+python_sat-1.9.dev8.dist-info/METADATA,sha256=G0u3A0QEHYeubjJ5xFClVKTkS7cNKvB_3FtDjjXfaTw,1783
+python_sat-1.9.dev8.dist-info/WHEEL,sha256=AP_wkikJcUkDPUGvTNydv7g0R7BhW1u_fVHNKW7TJyI,101
+python_sat-1.9.dev8.dist-info/top_level.txt,sha256=0SLg3yVqNpeiqOwFcAo3OxXhqAnflCmb5Fjl6gsl-Do,33
+python_sat-1.9.dev8.dist-info/RECORD,,