python-sat 1.8.dev22__cp314-cp314t-macosx_10_13_x86_64.whl → 1.8.dev24__cp314-cp314t-macosx_10_13_x86_64.whl

pysat/__init__.py

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

pysat/_fileio.py

@@ -189,7 +189,7 @@ class FileObject(object):
             self.ctype = 'bzip2'
         elif ext in ('.xz', '.lzma'):
             self.ctype = 'lzma'
-        elif ext == 'zst':
+        elif ext == '.zst':
             self.ctype = 'zstd'
         else:
             self.ctype = None

pysat/examples/bbscan.py

@@ -73,7 +73,7 @@
         >>> cnf = CNF(from_file='formula.wcnf.xz')
         >>>
         >>> # creating BBScan and running it
-        >>> with BBScan(cnf, solver='g3', lift=False, rotate=True) as bbscan:
+        >>> with BBScan(cnf, solver='g3', rotate=True) as bbscan:
         ...     bbone = bbscan.compute(algorithm='core')
         ...
         ...     # outputting the results
@@ -81,10 +81,10 @@
         ...         print(bbone)
         [1, -3]
 
-    Each of the available algorithms can be augmented with two simple
-    heuristics aiming at reducing satisfying assignments and, thus, filtering
-    out unnecessary literals: literal lifting and filtering rotatable
-    literals. Both are described in the aforementioned paper.
+    Each of the available algorithms can be augmented with a simple heuristic
+    aiming at reducing satisfying assignments and, thus, filtering out
+    unnecessary literals: namely, filtering rotatable literals. The heuristic
+    is described in the aforementioned paper.
 
     Note that most of the methods of the class :class:`BBScan` are made
     private. Therefore, the tool provides a minimalistic interface via which a
@@ -113,44 +113,42 @@ class BBScan:
     """
         A solver for computing all backbone literals of a given Boolean
         formula. It implements 6 algorithms for backbone computation described
-        in [1]_ augmented with two simple heuristics that can be speed up the
-        process.
+        in [1]_ augmented with a heuristic that can be speed up the process.
 
         Note that the input formula can be a :class:`.CNF` object but also any
         object of class :class:`.Formula`, thus the tool can used for
         computing backbone literals of non-clausal formulas.
 
         A user can select one of the SAT solvers available at hand
-        (``'glucose3'`` is used by default). The optional two heuristics can
-        be also specified as Boolean input arguments ``lift``, and ``rotate``
-        (turned off by default).
+        (``'glucose3'`` is used by default). The optional heuristic can be
+        also specified as a Boolean input arguments ``rotate`` (turned off by
+        default).
 
         The list of initialiser's arguments is as follows:
 
         :param formula: input formula whose backbone is sought
         :param solver: SAT oracle name
-        :param lift: apply literal lifting heuristic
         :param rotate: apply rotatable literal filtering
         :param verbose: verbosity level
 
         :type formula: :class:`.Formula` or :class:`.CNF`
         :type solver: str
-        :type lift: bool
         :type rotate: bool
         :type verbose: int
     """
 
-    def __init__(self, formula, solver='g3', lift=False, rotate=False, verbose=0):
+    def __init__(self, formula, solver='g3', rotate=False, verbose=0):
         """
             Constructor.
         """
 
         self.formula = formula
+        self.focuscl = list(range(len(formula.clauses))) if rotate else []
         self.verbose = verbose
         self.oracle  = None
 
         # implicant reduction heuristics
-        self.lift, self.rotate = lift, rotate
+        self.rotate = rotate
 
         # basic stats
         self.calls, self.filtered = 0, 0
@@ -204,13 +202,16 @@ class BBScan:
 
             If the chunking algorithm is selected (either ``'chunk'`` or
             ``'corechunk'``), the user may specify the size of the chunk,
-            which is set to 100 by default.
+            which is set to 100 by default. Note that the chunk_size can be a
+            floating-point number in the interval (0, 1], which will set the
+            actual chunk_size relative to the total number of literals of
+            interest.
 
             Finally, one may opt for computing backbone literals out of a
-            particular subset of literals / variables, which may run faster
-            than computing the entire formula's backbone. To focus on a
-            particular set of variables / literals, the user should use the
-            parameter ``focus_on``, which is set to ``None`` by default.
+            particular subset of literals, which may run faster than computing
+            the entire formula's backbone. To focus on a particular set of
+            literals, the user should use the parameter ``focus_on``, which is
+            set to ``None`` by default.
 
             .. note::
 
@@ -222,20 +223,38 @@ class BBScan:
             :param focus_on: a list of literals to focus on
 
             :type algorithm: str
-            :type chunk_size: int
+            :type chunk_size: int or float
             :type focus_on: iterable(int)
         """
 
         self.calls += 1
+        trivial = []
 
         if self.oracle.solve():
-            self.model = self.oracle.get_model()
+            self.model = set(self.oracle.get_model())
             if focus_on is not None:
-                model = set(self.model)
-                self.model = [l for l in focus_on if l in model]
+                self.model &= set(focus_on)
+
+                # if filtering rotatable literals is requested then
+                # we should be clever about the clauses to traverse
+                if self.rotate:
+                    self.focuscl = []
+                    for i, cl in enumerate(self.formula):
+                        for l in cl:
+                            if l in self.model:
+                                if len(cl) == 1:
+                                    trivial.append(l)
+                                    self.model.remove(l)
+                                else:
+                                    self.focuscl.append(i)
+                                break
         else:
             raise ValueError('Unsatisfiable formula')
 
+        if isinstance(chunk_size, float):
+            assert 0 < chunk_size <= 1, f'Wrong chunk proportion {chunk_size}'
+            chunk_size = int(min(self.formula.nv, len(self.model)) * chunk_size)
+
         if algorithm == 'enum':
             result = self._compute_enum()
         elif algorithm == 'iter':
@@ -251,50 +270,36 @@ class BBScan:
         else:
             assert 0, f'Unknown algorithm: {algorithm}'
 
-        return sorted(result, key=lambda l: abs(l))
-
-    def _get_implicant(self, model):
-        """
-            Simple literal lifting used to reduce a given model.
-        """
-
-        res, model = set(), set(model)
-
-        # traversing the clauses and collecting all literals
-        # that satisfy at least one clause of the formula
-        for cl in self.formula:
-            res |= set([l for l in cl if l in model])
-
-        return list(res)
+        return sorted(trivial + result, key=lambda l: abs(l))
 
     def _filter_rotatable(self, model):
         """
             Filter out rotatable literals.
         """
 
-        units, model = set([]), set(model)
+        def get_unit(cl):
+            # this is supposed to be a faster alternative to the
+            # complete clause traversal with a conditional inside
+            unit = None
+            for l in cl:
+                if l in model:
+                    if unit:
+                        return
+                    else:
+                        unit = l
+            return unit
+
+        # result of this procedure
+        units = set([])
 
         # determining unit literals
-        for cl in self.formula:
-            satisfied = [l for l in cl if l in model]
-            if len(satisfied) == 1:
-                units.add(satisfied[0])
+        for i in self.focuscl:
+            unit = get_unit(self.formula.clauses[i])
+            if unit:
+                units.add(unit)
 
         self.filtered += len(model) - len(units)
-        return list(units)
-
-    def _process_model(self, model):
-        """
-            Heuristically reduce a model.
-        """
-
-        if self.lift:
-            model = self._get_implicant(model)
-
-        if self.rotate:
-            model = self._filter_rotatable(model)
-
-        return model
+        return units
 
     def _compute_enum(self, focus_on=None):
         """
@@ -305,7 +310,7 @@ class BBScan:
             print('c using enumeration-based algorithm')
 
         # initial backbone estimate contains all literals
-        bbone = set(self.model) if focus_on is None else set(focus_on)
+        bbone = self.model if focus_on is None else focus_on
 
         while bbone:
             # counting the number of calls
@@ -315,17 +320,14 @@ class BBScan:
             if not self.oracle.solve():
                 break
 
-            self.model = self.oracle.get_model()
-            # if self.lift:
-            #     self.model = self._get_implicant(self.model)
-
-            self.model = self._process_model(self.model)
-
             # updating backbone estimate - intersection
-            bbone &= set(self.model)
+            bbone &= set(self.oracle.get_model())
+
+            if self.rotate:
+                bbone = self._filter_rotatable(bbone)
 
             # blocking the previously found implicant
-            self.oracle.add_clause([-l for l in self.model])
+            self.oracle.add_clause([-l for l in bbone])
 
         return list(bbone)
 
@@ -337,6 +339,8 @@ class BBScan:
         if self.verbose:
             print('c using iterative algorithm')
 
+        # initial estimate
+        # using sets for model and assumps to save filtering time
         bbone, model = [], self.model if focus_on is None else focus_on
 
         while model:
@@ -352,9 +356,10 @@ class BBScan:
             else:
                 # it isn't and we've got a counterexample
                 # => using it to filter out more literals
-                coex = set(self.oracle.get_model())
-                model = [l for l in model if l in coex]
-                model = self._process_model(model)
+                model &= set(self.oracle.get_model())
+
+                if self.rotate:
+                    model = self._filter_rotatable(model)
 
         return bbone
 
@@ -367,7 +372,7 @@ class BBScan:
             print('c using complement of backbone estimate algorithm')
 
         # initial estimate
-        bbone = set(self.model) if focus_on is None else set(focus_on)
+        bbone = self.model if focus_on is None else focus_on
 
         # iterating until we find the backbone or determine there is none
         while bbone:
@@ -380,22 +385,23 @@ class BBScan:
             if self.oracle.solve() == False:
                 break
             else:
-                model = self._process_model(self.oracle.get_model())
-                model = self._process_model(model)
-                bbone &= set(model)
+                bbone &= set(self.oracle.get_model())
+
+                if self.rotate:
+                    bbone = self._filter_rotatable(bbone)
 
         return list(bbone)
 
     def _compute_chunking(self, chunk_size=100, focus_on=None):
         """
-            Algorithm 5: Chunking algorithm.
+            Chunking algorithm.
         """
 
         if self.verbose:
             print('c using chunking algorithm, with chunk size:', chunk_size)
 
         # initial estimate
-        bbone, model = [], self.model if focus_on is None else focus_on
+        bbone, model = [], list(self.model if focus_on is None else focus_on)
 
         # we are going to use clause selectors
         vpool = IDPool(start_from=self.formula.nv + 1)
@@ -421,7 +427,9 @@ class BBScan:
             else:
                 coex = set(self.oracle.get_model())
                 model = [l for l in model if l in coex]
-                model = self._process_model(model)
+
+                if self.rotate:
+                    model = list(self._filter_rotatable(set(model)))
 
         return bbone
 
@@ -434,21 +442,24 @@ class BBScan:
             print('c using core-based algorithm')
 
         # initial estimate
+        # using sets for model and assumps to save filtering time
         bbone, model = [], self.model if focus_on is None else focus_on
 
         # iterating until we find the backbone or determine there is none
         while model:
             # flipping all the literals
-            assumps = [-l for l in model]
+            assumps = {-l for l in model}
 
             # getting unsatisfiable cores with them
             while True:
                 self.calls += 1
 
                 if self.oracle.solve(assumptions=assumps):
-                    coex = set(self.oracle.get_model())
-                    model = [l for l in model if l in coex]
-                    model = self._process_model(model)
+                    model &= set(self.oracle.get_model())
+
+                    if self.rotate:
+                        model  = self._filter_rotatable(model)
+
                     break
 
                 else:
@@ -458,18 +469,12 @@ class BBScan:
                         self.oracle.add_clause([-core[0]])
 
                         # remove from the working model
-                        indx = model.index(-core[0])  # may be slow
-                        if indx < len(model) - 1:
-                            model[indx] = model.pop()
-                        else:
-                            model.pop()
+                        model.remove(-core[0])
 
                     # filtering out unnecessary flipped literals
-                    core = set(core)
-                    assumps = [l for l in assumps if l not in core]
+                    assumps -= set(core)
 
                     if not assumps:
-                        # resorting to the iterative traversal algorithm
                         self.model = model
                         return bbone + self._compute_iter()
 
@@ -484,7 +489,7 @@ class BBScan:
             print('c using core-based chunking, with chunk size:', chunk_size)
 
         # initial estimate
-        bbone, model = [], self.model if focus_on is None else focus_on
+        bbone, model = [], list(self.model if focus_on is None else focus_on)
 
         # we are going to use clause selectors
         vpool = IDPool(start_from=self.formula.nv + 1)
@@ -495,7 +500,7 @@ class BBScan:
             size = min(chunk_size, len(model))
 
             # flipping all the literals
-            assumps, skipped = [-model.pop() for i in range(size)], []
+            assumps, skipped = {-model.pop() for i in range(size)}, set()
 
             # getting unsatisfiable cores with them
             while True:
@@ -504,7 +509,9 @@ class BBScan:
                 if self.oracle.solve(assumptions=assumps):
                     coex = set(self.oracle.get_model())
                     model = [l for l in model if l in coex]
-                    model = self._process_model(model)
+
+                    if self.rotate:
+                        model = list(self._filter_rotatable(set(model)))
 
                     if skipped:
                         bbone += self._compute_iter(focus_on=skipped)
@@ -520,11 +527,10 @@ class BBScan:
                         self.oracle.add_clause([-core[0]])
                     else:
                         # all removed literals are going to be tested later
-                        skipped += [-l for l in core]
+                        skipped |= {-l for l in core}
 
                     # filtering out unnecessary flipped literals
-                    core = set(core)
-                    assumps = [l for l in assumps if l not in core]
+                    assumps -= set(core)
 
                     if not assumps:
                         # resorting to the iterative traversal algorithm
@@ -555,11 +561,10 @@ def parse_options():
 
     try:
         opts, args = getopt.getopt(sys.argv[1:],
-                                   'a:c:hlrs:v',
+                                   'a:c:hrs:v',
                                    ['algo=',
                                     'chunk=',
                                     'help',
-                                    'lift',
                                     'rotate',
                                     'solver=',
                                     'verbose'])
@@ -570,7 +575,6 @@ def parse_options():
 
     algo = 'iter'
     chunk = 100
-    lift = False
     rotate = False
     solver = 'g3'
     verbose = 0
@@ -580,12 +584,14 @@ def parse_options():
             algo = str(arg)
             assert algo in ('enum', 'iter', 'compl', 'chunk', 'core', 'corechunk'), 'Unknown algorithm'
         elif opt in ('-c', '--chunk'):
-            chunk = int(arg)
+            chunk = float(arg)
+            if chunk.is_integer():
+                chunk = int(chunk)
+            else:
+                assert 0 < chunk <= 1, f'Wrong chunk proportion {chunk_size}'
         elif opt in ('-h', '--help'):
             usage()
             sys.exit(0)
-        elif opt in ('-l', '--lift'):
-            lift = True
         elif opt in ('-r', '--rotate'):
             rotate = True
         elif opt in ('-s', '--solver'):
@@ -595,7 +601,7 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return algo, chunk, lift, rotate, solver, verbose, args
+    return algo, chunk, rotate, solver, verbose, args
 
 
 #
@@ -607,22 +613,21 @@ def usage():
 
     print('Usage:', os.path.basename(sys.argv[0]), '[options] file')
     print('Options:')
-    print('        -a, --algo=<string>      Algorithm to use')
-    print('                                 Available values: enum, iter, compl, chunk, core, corechunk (default: iter)')
-    print('        -c, --chunk=<int>        Chunk size for chunking algorithms')
-    print('                                 Available values: [1 .. INT_MAX] (default: 100)')
-    print('        -h, --help               Show this message')
-    print('        -l, --lift               Apply literal lifting for heuristic model reduction')
-    print('        -r, --rotate             Heuristically filter out rotatable literals')
-    print('        -s, --solver=<string>    SAT solver to use')
-    print('                                 Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default: g3)')
-    print('        -v, --verbose            Be verbose (can be used multiple times)')
+    print('        -a, --algo=<string>        Algorithm to use')
+    print('                                   Available values: enum, iter, compl, chunk, core, corechunk (default: iter)')
+    print('        -c, --chunk=<int,float>    Chunk size for chunking algorithms')
+    print('                                   Available values: [1 .. INT_MAX] or (0 .. 1] (default: 100)')
+    print('        -h, --help                 Show this message')
+    print('        -r, --rotate               Heuristically filter out rotatable literals')
+    print('        -s, --solver=<string>      SAT solver to use')
+    print('                                   Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default: g3)')
+    print('        -v, --verbose              Be verbose (can be used multiple times)')
 
 
 #
 #==============================================================================
 if __name__ == '__main__':
-    algo, chunk, lift, rotate, solver, verbose, files = parse_options()
+    algo, chunk, rotate, solver, verbose, files = parse_options()
 
     if files:
         # read CNF from file
@@ -635,8 +640,7 @@ if __name__ == '__main__':
                                                             len(formula.clauses)))
 
         # computing the backbone
-        with BBScan(formula, solver=solver, lift=lift, rotate=rotate,
-                    verbose=verbose) as bbscan:
+        with BBScan(formula, solver=solver, rotate=rotate, verbose=verbose) as bbscan:
             try:
                 bbone = bbscan.compute(algorithm=algo, chunk_size=chunk)
 
@@ -653,7 +657,7 @@ if __name__ == '__main__':
                 print('v 0')
 
             if verbose > 1:
-                print('c filtered: {0}; ({1:.2f})'.format(bbscan.filtered, 100. * bbscan.filtered / formula.nv))
+                print('c filtered: {0} ({1:.2f})'.format(bbscan.filtered, 100. * bbscan.filtered / formula.nv))
 
             print('c oracle time: {0:.4f}'.format(bbscan.oracle_time()))
             print('c oracle calls: {0}'.format(bbscan.calls))

{python_sat-1.8.dev22.data → python_sat-1.8.dev24.data}/scripts/bbscan.py

@@ -73,7 +73,7 @@
         >>> cnf = CNF(from_file='formula.wcnf.xz')
         >>>
         >>> # creating BBScan and running it
-        >>> with BBScan(cnf, solver='g3', lift=False, rotate=True) as bbscan:
+        >>> with BBScan(cnf, solver='g3', rotate=True) as bbscan:
         ...     bbone = bbscan.compute(algorithm='core')
         ...
         ...     # outputting the results
@@ -81,10 +81,10 @@
         ...         print(bbone)
         [1, -3]
 
-    Each of the available algorithms can be augmented with two simple
-    heuristics aiming at reducing satisfying assignments and, thus, filtering
-    out unnecessary literals: literal lifting and filtering rotatable
-    literals. Both are described in the aforementioned paper.
+    Each of the available algorithms can be augmented with a simple heuristic
+    aiming at reducing satisfying assignments and, thus, filtering out
+    unnecessary literals: namely, filtering rotatable literals. The heuristic
+    is described in the aforementioned paper.
 
     Note that most of the methods of the class :class:`BBScan` are made
     private. Therefore, the tool provides a minimalistic interface via which a
@@ -113,44 +113,42 @@ class BBScan:
     """
         A solver for computing all backbone literals of a given Boolean
         formula. It implements 6 algorithms for backbone computation described
-        in [1]_ augmented with two simple heuristics that can be speed up the
-        process.
+        in [1]_ augmented with a heuristic that can be speed up the process.
 
         Note that the input formula can be a :class:`.CNF` object but also any
         object of class :class:`.Formula`, thus the tool can used for
         computing backbone literals of non-clausal formulas.
 
         A user can select one of the SAT solvers available at hand
-        (``'glucose3'`` is used by default). The optional two heuristics can
-        be also specified as Boolean input arguments ``lift``, and ``rotate``
-        (turned off by default).
+        (``'glucose3'`` is used by default). The optional heuristic can be
+        also specified as a Boolean input arguments ``rotate`` (turned off by
+        default).
 
         The list of initialiser's arguments is as follows:
 
         :param formula: input formula whose backbone is sought
         :param solver: SAT oracle name
-        :param lift: apply literal lifting heuristic
         :param rotate: apply rotatable literal filtering
         :param verbose: verbosity level
 
         :type formula: :class:`.Formula` or :class:`.CNF`
         :type solver: str
-        :type lift: bool
         :type rotate: bool
         :type verbose: int
     """
 
-    def __init__(self, formula, solver='g3', lift=False, rotate=False, verbose=0):
+    def __init__(self, formula, solver='g3', rotate=False, verbose=0):
         """
             Constructor.
         """
 
         self.formula = formula
+        self.focuscl = list(range(len(formula.clauses))) if rotate else []
         self.verbose = verbose
         self.oracle  = None
 
         # implicant reduction heuristics
-        self.lift, self.rotate = lift, rotate
+        self.rotate = rotate
 
         # basic stats
         self.calls, self.filtered = 0, 0
@@ -204,13 +202,16 @@ class BBScan:
 
             If the chunking algorithm is selected (either ``'chunk'`` or
             ``'corechunk'``), the user may specify the size of the chunk,
-            which is set to 100 by default.
+            which is set to 100 by default. Note that the chunk_size can be a
+            floating-point number in the interval (0, 1], which will set the
+            actual chunk_size relative to the total number of literals of
+            interest.
 
             Finally, one may opt for computing backbone literals out of a
-            particular subset of literals / variables, which may run faster
-            than computing the entire formula's backbone. To focus on a
-            particular set of variables / literals, the user should use the
-            parameter ``focus_on``, which is set to ``None`` by default.
+            particular subset of literals, which may run faster than computing
+            the entire formula's backbone. To focus on a particular set of
+            literals, the user should use the parameter ``focus_on``, which is
+            set to ``None`` by default.
 
             .. note::
 
@@ -222,20 +223,38 @@ class BBScan:
             :param focus_on: a list of literals to focus on
 
             :type algorithm: str
-            :type chunk_size: int
+            :type chunk_size: int or float
             :type focus_on: iterable(int)
         """
 
         self.calls += 1
+        trivial = []
 
         if self.oracle.solve():
-            self.model = self.oracle.get_model()
+            self.model = set(self.oracle.get_model())
             if focus_on is not None:
-                model = set(self.model)
-                self.model = [l for l in focus_on if l in model]
+                self.model &= set(focus_on)
+
+                # if filtering rotatable literals is requested then
+                # we should be clever about the clauses to traverse
+                if self.rotate:
+                    self.focuscl = []
+                    for i, cl in enumerate(self.formula):
+                        for l in cl:
+                            if l in self.model:
+                                if len(cl) == 1:
+                                    trivial.append(l)
+                                    self.model.remove(l)
+                                else:
+                                    self.focuscl.append(i)
+                                break
         else:
             raise ValueError('Unsatisfiable formula')
 
+        if isinstance(chunk_size, float):
+            assert 0 < chunk_size <= 1, f'Wrong chunk proportion {chunk_size}'
+            chunk_size = int(min(self.formula.nv, len(self.model)) * chunk_size)
+
         if algorithm == 'enum':
             result = self._compute_enum()
         elif algorithm == 'iter':
@@ -251,50 +270,36 @@ class BBScan:
         else:
             assert 0, f'Unknown algorithm: {algorithm}'
 
-        return sorted(result, key=lambda l: abs(l))
-
-    def _get_implicant(self, model):
-        """
-            Simple literal lifting used to reduce a given model.
-        """
-
-        res, model = set(), set(model)
-
-        # traversing the clauses and collecting all literals
-        # that satisfy at least one clause of the formula
-        for cl in self.formula:
-            res |= set([l for l in cl if l in model])
-
-        return list(res)
+        return sorted(trivial + result, key=lambda l: abs(l))
 
     def _filter_rotatable(self, model):
         """
             Filter out rotatable literals.
         """
 
-        units, model = set([]), set(model)
+        def get_unit(cl):
+            # this is supposed to be a faster alternative to the
+            # complete clause traversal with a conditional inside
+            unit = None
+            for l in cl:
+                if l in model:
+                    if unit:
+                        return
+                    else:
+                        unit = l
+            return unit
+
+        # result of this procedure
+        units = set([])
 
         # determining unit literals
-        for cl in self.formula:
-            satisfied = [l for l in cl if l in model]
-            if len(satisfied) == 1:
-                units.add(satisfied[0])
+        for i in self.focuscl:
+            unit = get_unit(self.formula.clauses[i])
+            if unit:
+                units.add(unit)
 
         self.filtered += len(model) - len(units)
-        return list(units)
-
-    def _process_model(self, model):
-        """
-            Heuristically reduce a model.
-        """
-
-        if self.lift:
-            model = self._get_implicant(model)
-
-        if self.rotate:
-            model = self._filter_rotatable(model)
-
-        return model
+        return units
 
     def _compute_enum(self, focus_on=None):
         """
@@ -305,7 +310,7 @@ class BBScan:
             print('c using enumeration-based algorithm')
 
         # initial backbone estimate contains all literals
-        bbone = set(self.model) if focus_on is None else set(focus_on)
+        bbone = self.model if focus_on is None else focus_on
 
         while bbone:
             # counting the number of calls
@@ -315,17 +320,14 @@ class BBScan:
             if not self.oracle.solve():
                 break
 
-            self.model = self.oracle.get_model()
-            # if self.lift:
-            #     self.model = self._get_implicant(self.model)
-
-            self.model = self._process_model(self.model)
-
             # updating backbone estimate - intersection
-            bbone &= set(self.model)
+            bbone &= set(self.oracle.get_model())
+
+            if self.rotate:
+                bbone = self._filter_rotatable(bbone)
 
             # blocking the previously found implicant
-            self.oracle.add_clause([-l for l in self.model])
+            self.oracle.add_clause([-l for l in bbone])
 
         return list(bbone)
 
@@ -337,6 +339,8 @@ class BBScan:
         if self.verbose:
             print('c using iterative algorithm')
 
+        # initial estimate
+        # using sets for model and assumps to save filtering time
         bbone, model = [], self.model if focus_on is None else focus_on
 
         while model:
@@ -352,9 +356,10 @@ class BBScan:
             else:
                 # it isn't and we've got a counterexample
                 # => using it to filter out more literals
-                coex = set(self.oracle.get_model())
-                model = [l for l in model if l in coex]
-                model = self._process_model(model)
+                model &= set(self.oracle.get_model())
+
+                if self.rotate:
+                    model = self._filter_rotatable(model)
 
         return bbone
 
@@ -367,7 +372,7 @@ class BBScan:
             print('c using complement of backbone estimate algorithm')
 
         # initial estimate
-        bbone = set(self.model) if focus_on is None else set(focus_on)
+        bbone = self.model if focus_on is None else focus_on
 
         # iterating until we find the backbone or determine there is none
         while bbone:
@@ -380,22 +385,23 @@ class BBScan:
             if self.oracle.solve() == False:
                 break
             else:
-                model = self._process_model(self.oracle.get_model())
-                model = self._process_model(model)
-                bbone &= set(model)
+                bbone &= set(self.oracle.get_model())
+
+                if self.rotate:
+                    bbone = self._filter_rotatable(bbone)
 
         return list(bbone)
 
     def _compute_chunking(self, chunk_size=100, focus_on=None):
         """
-            Algorithm 5: Chunking algorithm.
+            Chunking algorithm.
         """
 
         if self.verbose:
             print('c using chunking algorithm, with chunk size:', chunk_size)
 
         # initial estimate
-        bbone, model = [], self.model if focus_on is None else focus_on
+        bbone, model = [], list(self.model if focus_on is None else focus_on)
 
         # we are going to use clause selectors
         vpool = IDPool(start_from=self.formula.nv + 1)
@@ -421,7 +427,9 @@ class BBScan:
             else:
                 coex = set(self.oracle.get_model())
                 model = [l for l in model if l in coex]
-                model = self._process_model(model)
+
+                if self.rotate:
+                    model = list(self._filter_rotatable(set(model)))
 
         return bbone
 
@@ -434,21 +442,24 @@ class BBScan:
             print('c using core-based algorithm')
 
         # initial estimate
+        # using sets for model and assumps to save filtering time
         bbone, model = [], self.model if focus_on is None else focus_on
 
         # iterating until we find the backbone or determine there is none
         while model:
             # flipping all the literals
-            assumps = [-l for l in model]
+            assumps = {-l for l in model}
 
             # getting unsatisfiable cores with them
             while True:
                 self.calls += 1
 
                 if self.oracle.solve(assumptions=assumps):
-                    coex = set(self.oracle.get_model())
-                    model = [l for l in model if l in coex]
-                    model = self._process_model(model)
+                    model &= set(self.oracle.get_model())
+
+                    if self.rotate:
+                        model  = self._filter_rotatable(model)
+
                     break
 
                 else:
@@ -458,18 +469,12 @@ class BBScan:
                         self.oracle.add_clause([-core[0]])
 
                         # remove from the working model
-                        indx = model.index(-core[0])  # may be slow
-                        if indx < len(model) - 1:
-                            model[indx] = model.pop()
-                        else:
-                            model.pop()
+                        model.remove(-core[0])
 
                     # filtering out unnecessary flipped literals
-                    core = set(core)
-                    assumps = [l for l in assumps if l not in core]
+                    assumps -= set(core)
 
                     if not assumps:
-                        # resorting to the iterative traversal algorithm
                         self.model = model
                         return bbone + self._compute_iter()
 
@@ -484,7 +489,7 @@ class BBScan:
             print('c using core-based chunking, with chunk size:', chunk_size)
 
         # initial estimate
-        bbone, model = [], self.model if focus_on is None else focus_on
+        bbone, model = [], list(self.model if focus_on is None else focus_on)
 
         # we are going to use clause selectors
         vpool = IDPool(start_from=self.formula.nv + 1)
@@ -495,7 +500,7 @@ class BBScan:
             size = min(chunk_size, len(model))
 
             # flipping all the literals
-            assumps, skipped = [-model.pop() for i in range(size)], []
+            assumps, skipped = {-model.pop() for i in range(size)}, set()
 
             # getting unsatisfiable cores with them
             while True:
@@ -504,7 +509,9 @@ class BBScan:
                 if self.oracle.solve(assumptions=assumps):
                     coex = set(self.oracle.get_model())
                     model = [l for l in model if l in coex]
-                    model = self._process_model(model)
+
+                    if self.rotate:
+                        model = list(self._filter_rotatable(set(model)))
 
                     if skipped:
                         bbone += self._compute_iter(focus_on=skipped)
@@ -520,11 +527,10 @@ class BBScan:
                         self.oracle.add_clause([-core[0]])
                     else:
                         # all removed literals are going to be tested later
-                        skipped += [-l for l in core]
+                        skipped |= {-l for l in core}
 
                     # filtering out unnecessary flipped literals
-                    core = set(core)
-                    assumps = [l for l in assumps if l not in core]
+                    assumps -= set(core)
 
                     if not assumps:
                         # resorting to the iterative traversal algorithm
@@ -555,11 +561,10 @@ def parse_options():
 
     try:
         opts, args = getopt.getopt(sys.argv[1:],
-                                   'a:c:hlrs:v',
+                                   'a:c:hrs:v',
                                    ['algo=',
                                     'chunk=',
                                     'help',
-                                    'lift',
                                     'rotate',
                                     'solver=',
                                     'verbose'])
@@ -570,7 +575,6 @@ def parse_options():
 
     algo = 'iter'
     chunk = 100
-    lift = False
     rotate = False
     solver = 'g3'
     verbose = 0
@@ -580,12 +584,14 @@ def parse_options():
             algo = str(arg)
             assert algo in ('enum', 'iter', 'compl', 'chunk', 'core', 'corechunk'), 'Unknown algorithm'
         elif opt in ('-c', '--chunk'):
-            chunk = int(arg)
+            chunk = float(arg)
+            if chunk.is_integer():
+                chunk = int(chunk)
+            else:
+                assert 0 < chunk <= 1, f'Wrong chunk proportion {chunk_size}'
         elif opt in ('-h', '--help'):
             usage()
             sys.exit(0)
-        elif opt in ('-l', '--lift'):
-            lift = True
         elif opt in ('-r', '--rotate'):
             rotate = True
         elif opt in ('-s', '--solver'):
@@ -595,7 +601,7 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return algo, chunk, lift, rotate, solver, verbose, args
+    return algo, chunk, rotate, solver, verbose, args
 
 
 #
@@ -607,22 +613,21 @@ def usage():
 
     print('Usage:', os.path.basename(sys.argv[0]), '[options] file')
     print('Options:')
-    print('        -a, --algo=<string>      Algorithm to use')
-    print('                                 Available values: enum, iter, compl, chunk, core, corechunk (default: iter)')
-    print('        -c, --chunk=<int>        Chunk size for chunking algorithms')
-    print('                                 Available values: [1 .. INT_MAX] (default: 100)')
-    print('        -h, --help               Show this message')
-    print('        -l, --lift               Apply literal lifting for heuristic model reduction')
-    print('        -r, --rotate             Heuristically filter out rotatable literals')
-    print('        -s, --solver=<string>    SAT solver to use')
-    print('                                 Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default: g3)')
-    print('        -v, --verbose            Be verbose (can be used multiple times)')
+    print('        -a, --algo=<string>        Algorithm to use')
+    print('                                   Available values: enum, iter, compl, chunk, core, corechunk (default: iter)')
+    print('        -c, --chunk=<int,float>    Chunk size for chunking algorithms')
+    print('                                   Available values: [1 .. INT_MAX] or (0 .. 1] (default: 100)')
+    print('        -h, --help                 Show this message')
+    print('        -r, --rotate               Heuristically filter out rotatable literals')
+    print('        -s, --solver=<string>      SAT solver to use')
+    print('                                   Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default: g3)')
+    print('        -v, --verbose              Be verbose (can be used multiple times)')
 
 
 #
 #==============================================================================
 if __name__ == '__main__':
-    algo, chunk, lift, rotate, solver, verbose, files = parse_options()
+    algo, chunk, rotate, solver, verbose, files = parse_options()
 
     if files:
         # read CNF from file
@@ -635,8 +640,7 @@ if __name__ == '__main__':
                                                             len(formula.clauses)))
 
         # computing the backbone
-        with BBScan(formula, solver=solver, lift=lift, rotate=rotate,
-                    verbose=verbose) as bbscan:
+        with BBScan(formula, solver=solver, rotate=rotate, verbose=verbose) as bbscan:
             try:
                 bbone = bbscan.compute(algorithm=algo, chunk_size=chunk)
 
@@ -653,7 +657,7 @@ if __name__ == '__main__':
                 print('v 0')
 
             if verbose > 1:
-                print('c filtered: {0}; ({1:.2f})'.format(bbscan.filtered, 100. * bbscan.filtered / formula.nv))
+                print('c filtered: {0} ({1:.2f})'.format(bbscan.filtered, 100. * bbscan.filtered / formula.nv))
 
             print('c oracle time: {0:.4f}'.format(bbscan.oracle_time()))
             print('c oracle calls: {0}'.format(bbscan.calls))

{python_sat-1.8.dev22.dist-info → python_sat-1.8.dev24.dist-info}/METADATA

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

@@ -1,10 +1,10 @@
-pysolvers.cpython-314t-darwin.so,sha256=7fX9k2H5fLUm72UxCV6VA7XZEldgr5NXgdclMf_53cs,3914016
-pycard.cpython-314t-darwin.so,sha256=EDIiLr7yaUWytybzaOXjaxZIZCUpJBEhb4xd6aGEoY4,97504
+pysolvers.cpython-314t-darwin.so,sha256=jfFfq_4jCiG939efTy1OkmQ0x7EtI2MFWTwM0lGsxyc,3914016
+pycard.cpython-314t-darwin.so,sha256=iv4v2w7csYZHRQlHbcouJd4FIcu0PdG0Vtf9_4lA2ho,97504
 pysat/pb.py,sha256=fLmfzPPtmEFp-ufHlxyfL1YAVNmxWZdm_ARRdwxUib4,16686
-pysat/_fileio.py,sha256=GawbH3lYAMxYM5KWw9Nx6Gg9UkwOeLZel335Z24Un9Y,6372
+pysat/_fileio.py,sha256=cmrqvhPXxC87lpvLlFDG7EWpusQOaqCGPMDfWhqT6dg,6373
 pysat/formula.py,sha256=3ZhI1ePvlreXJ7nRKMIftRsllm9lDDfXWYMt7AA8nSc,202858
 pysat/engines.py,sha256=PzcZJ4zFXDHfcSSHF7iPadtrwSVEt4t9B_cO5epwTZk,45182
-pysat/__init__.py,sha256=4b77R_gm1nOwqTsDYtZKtmar77O2mfr34EgWdLW6uVc,670
+pysat/__init__.py,sha256=q4ytD1iDnO0YnCvacaurDV1OAzxUoOgDbus24YL7_88,670
 pysat/solvers.py,sha256=00Y6yKNXvJOLA7l4aIDgueFbNM9lt3PkmT2OxB43aQ8,229975
 pysat/card.py,sha256=Np6HK2LfD-7YuOP53jMAm6JIO1lPFu_jqJP18n03uvM,30066
 pysat/process.py,sha256=8lNbpEKipFZjbQ9DCJPfdL8eZHx-ltNuu7h4geWWdJY,12739
@@ -20,29 +20,29 @@ pysat/examples/hitman.py,sha256=vHJEeSfoMQlDD3D3Poofaryv-k_dMH37XoqVXJUUuUg,2636
 pysat/examples/bica.py,sha256=OGcGQGQnMepCCurwRbygokFgoDkI7eBhjmsYvr3FM1M,27098
 pysat/examples/rc2.py,sha256=RnS_RLBryjTBk_jhYY1LV37DmOkeI0H-RV-OPC4d0fw,69981
 pysat/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pysat/examples/bbscan.py,sha256=x0YyuhJ_LLcNvONGtw6b95F32sWi8O8P25AF-Nhmejk,21783
+pysat/examples/bbscan.py,sha256=E4Y5j3Llr0-jIn-RDZIk-f02Sbujg4wX7uysoiFRnLg,22046
 pysat/examples/fm.py,sha256=e_s6wNBstEeoMw9zYyyDRgkE-Hqa902Iy_CxCS961CE,18136
 pysat/examples/mcsls.py,sha256=bP47P56OOP_uy0MuFA7TGxMdkAis7gX4E9AEEI0tSec,22093
 pysat/examples/optux.py,sha256=8eYHO_uhL_4ugb-hRv2s6cnOwTurfqkpbdnK9T4iDtw,27697
 pysat/examples/lsu.py,sha256=qyN2TvXG61EtMy-IrX5EYmLPM_iNOhtOkGTY5nHO_zo,16198
 pysat/examples/genhard.py,sha256=DFXtSVQ4qn78y0-ZMr2D6gBCLizZSzgkvcbDsjqjnKI,19017
 pysat/examples/usage.py,sha256=x9luw6pyKAAndlxAeUWFhS4aLSVmD2t_j_5uA9YddHg,2183
-python_sat-1.8.dev22.data/scripts/models.py,sha256=Ejojfty6n2REM2Di6aKoqQtQ_v_6MfHs7qkWLXruJuU,5728
-python_sat-1.8.dev22.data/scripts/primer.py,sha256=HufdaErta1gd_gvvSOFyHdxTnPgIM0q6Z2PvV6u0mGM,23362
-python_sat-1.8.dev22.data/scripts/lbx.py,sha256=PwvcU8eG2oaZpkNRLDsDOjTcOF0aS4CWg1MEuuK2_CA,23236
-python_sat-1.8.dev22.data/scripts/musx.py,sha256=RO7eP6alQ8qDZTvI1co3xUoni1xRKb4sT9rm9Of0qGk,10933
-python_sat-1.8.dev22.data/scripts/bica.py,sha256=Tc9RjYKO-Lj9GNQjXnM87PJ3Dx2f2bHd2V2Igb-B1FM,27085
-python_sat-1.8.dev22.data/scripts/rc2.py,sha256=eVaXQCbFrOtM6SbGj1ivLHqFQHjxt8cjhoBicOD85Oo,69968
-python_sat-1.8.dev22.data/scripts/bbscan.py,sha256=O749X1gvAQ0mZpSMxwibzMtE7qWql_-vU7ePyQMzF4c,21770
-python_sat-1.8.dev22.data/scripts/fm.py,sha256=nWL-TtQst6YMaHS_5amNZzeLkOrWeuv4HgU7xrBDu5o,18123
-python_sat-1.8.dev22.data/scripts/mcsls.py,sha256=STkPj4-WY6PaNklluGbfciZREJ--gXNMKZHQXohu4p8,22080
-python_sat-1.8.dev22.data/scripts/optux.py,sha256=kR3CD3h1Fve08eMt1aU4Vq5eTygWOHNIoZc008KgSdM,27684
-python_sat-1.8.dev22.data/scripts/lsu.py,sha256=dBW9gqzXR6xTLRzjeIhMVREaaiSvGAnIuzLIZRKqEuE,16185
-python_sat-1.8.dev22.data/scripts/genhard.py,sha256=o8qSa7sksQxyhbRahmRBws3F6emQu3pe_rkxY_aXEkw,19004
-python_sat-1.8.dev22.data/scripts/unigen.py,sha256=_tk18u_4Jg8tOhZe1CmPOHzbEJ-mJqs-mFzBfcupXuQ,16705
-python_sat-1.8.dev22.data/scripts/approxmc.py,sha256=Y_aUYOqQ-S1ABrkzFZx4sh4dP7Ua7J9Gn47XsHcAdM8,13573
-python_sat-1.8.dev22.dist-info/RECORD,,
-python_sat-1.8.dev22.dist-info/WHEEL,sha256=UlOYVXZUoedBznR7TtcHLe8dLSyBBw50dixq5hWMaMI,139
-python_sat-1.8.dev22.dist-info/top_level.txt,sha256=fgEEGhMLivlF1ExCX8Y3niWsr4pDPRb5HdaWjNtabFI,23
-python_sat-1.8.dev22.dist-info/METADATA,sha256=eUquMB6sHQTr5F3kCJ9Gm8v9HMBAWBhALdj57bAkBgA,1739
-python_sat-1.8.dev22.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
+python_sat-1.8.dev24.dist-info/RECORD,,
+python_sat-1.8.dev24.dist-info/WHEEL,sha256=UlOYVXZUoedBznR7TtcHLe8dLSyBBw50dixq5hWMaMI,139
+python_sat-1.8.dev24.dist-info/top_level.txt,sha256=fgEEGhMLivlF1ExCX8Y3niWsr4pDPRb5HdaWjNtabFI,23
+python_sat-1.8.dev24.dist-info/METADATA,sha256=R_7J8Y-D1s7n7ix1OlAGzu2MhAepsbob2QYQrl5vsQo,1739
+python_sat-1.8.dev24.dist-info/licenses/LICENSE.txt,sha256=6QMvEzxqdPXEoiAZUBaZLeLF4hW2S81fjKz_THER0uQ,1109
+python_sat-1.8.dev24.data/scripts/models.py,sha256=Ejojfty6n2REM2Di6aKoqQtQ_v_6MfHs7qkWLXruJuU,5728
+python_sat-1.8.dev24.data/scripts/primer.py,sha256=HufdaErta1gd_gvvSOFyHdxTnPgIM0q6Z2PvV6u0mGM,23362
+python_sat-1.8.dev24.data/scripts/lbx.py,sha256=PwvcU8eG2oaZpkNRLDsDOjTcOF0aS4CWg1MEuuK2_CA,23236
+python_sat-1.8.dev24.data/scripts/musx.py,sha256=RO7eP6alQ8qDZTvI1co3xUoni1xRKb4sT9rm9Of0qGk,10933
+python_sat-1.8.dev24.data/scripts/bica.py,sha256=Tc9RjYKO-Lj9GNQjXnM87PJ3Dx2f2bHd2V2Igb-B1FM,27085
+python_sat-1.8.dev24.data/scripts/rc2.py,sha256=eVaXQCbFrOtM6SbGj1ivLHqFQHjxt8cjhoBicOD85Oo,69968
+python_sat-1.8.dev24.data/scripts/bbscan.py,sha256=NpCCeJ0HAtQT41c06R2h_xYvkKgJtsCraCktUPmj7GQ,22033
+python_sat-1.8.dev24.data/scripts/fm.py,sha256=nWL-TtQst6YMaHS_5amNZzeLkOrWeuv4HgU7xrBDu5o,18123
+python_sat-1.8.dev24.data/scripts/mcsls.py,sha256=STkPj4-WY6PaNklluGbfciZREJ--gXNMKZHQXohu4p8,22080
+python_sat-1.8.dev24.data/scripts/optux.py,sha256=kR3CD3h1Fve08eMt1aU4Vq5eTygWOHNIoZc008KgSdM,27684
+python_sat-1.8.dev24.data/scripts/lsu.py,sha256=dBW9gqzXR6xTLRzjeIhMVREaaiSvGAnIuzLIZRKqEuE,16185
+python_sat-1.8.dev24.data/scripts/genhard.py,sha256=o8qSa7sksQxyhbRahmRBws3F6emQu3pe_rkxY_aXEkw,19004
+python_sat-1.8.dev24.data/scripts/unigen.py,sha256=_tk18u_4Jg8tOhZe1CmPOHzbEJ-mJqs-mFzBfcupXuQ,16705
+python_sat-1.8.dev24.data/scripts/approxmc.py,sha256=Y_aUYOqQ-S1ABrkzFZx4sh4dP7Ua7J9Gn47XsHcAdM8,13573