python-sat 1.8.dev19__tar.gz → 1.8.dev21__tar.gz

{python_sat-1.8.dev19/python_sat.egg-info → python_sat-1.8.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-sat
-Version: 1.8.dev19
+Version: 1.8.dev21
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado
@@ -19,6 +19,16 @@ Provides-Extra: pblib
 Requires-Dist: pypblib>=0.0.3; extra == "pblib"
 Provides-Extra: unigen
 Requires-Dist: pyunigen>=4.1.20; extra == "unigen"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 
 A Python library providing a simple interface to a number of state-of-art

{python_sat-1.8.dev19 → python_sat-1.8.dev21}/examples/lbx.py

@@ -90,6 +90,7 @@ import getopt
 from math import copysign
 import os
 from pysat.formula import CNFPlus, WCNFPlus
+from pysat.process import Processor
 from pysat.solvers import Solver, SolverNames
 import re
 from six.moves import range
@@ -112,25 +113,37 @@ class LBX(object):
         ``use_cld`` is set to ``False``. Internal SAT solver's timer is also
         disabled by default, i.e. ``use_timer`` is ``False``.
 
+        Additionally, the input formula can be preprocessed before running MCS
+        enumeration. This is controlled by the input parameter ``process``
+        whose integer value signifies the number of processing rounds to be
+        applied. The number of rounds is set to 0 by default.
+
         :param formula: unsatisfiable partial CNF formula
         :param use_cld: whether or not to use "clause :math:`D`"
         :param solver_name: SAT oracle name
+        :param process: apply formula preprocessing this many times
         :param use_timer: whether or not to use SAT solver's timer
 
         :type formula: :class:`.WCNF`
         :type use_cld: bool
         :type solver_name: str
+        :type process: int
         :type use_timer: bool
     """
 
-    def __init__(self, formula, use_cld=False, solver_name='m22', use_timer=False):
+    def __init__(self, formula, use_cld=False, solver_name='m22', process=0,
+                 use_timer=False):
         """
             Constructor.
         """
 
+        # dealing with preprocessing, if required
+        hard = formula.hard if process > 0 else []
+
         # bootstrapping the solver with hard clauses
-        self.oracle = Solver(name=solver_name, bootstrap_with=formula.hard,
-                use_timer=use_timer)
+        self.oracle = Solver(name=solver_name,
+                             bootstrap_with=formula.hard if process == 0 else [],
+                             use_timer=use_timer)
         self.solver = solver_name
 
         # adding native cardinality constraints (if any) as hard clauses
@@ -166,10 +179,27 @@ class LBX(object):
                 self.topv += 1
                 sel = self.topv
 
-                self.oracle.add_clause(cl + [-sel])
+                if process == 0:
+                    self.oracle.add_clause(cl + [-sel])
+                else:
+                    # adding to formula's hard clauses
+                    # if any preprocessing is required
+                    hard.append(cl + [-sel])
 
             self.sels.append(sel)
 
+        # finally, applying formula processing, if any
+        if process:
+            # the processor is immediately destroyed,
+            # as we do not need to restore the models
+            with Processor(bootstrap_with=hard) as processor:
+                proc = processor.process(rounds=process, freeze=self.sels)
+                self.oracle.append_formula(proc)
+
+                # we won't have access to the original soft
+                # clauses in the case of formula preprocessing
+                self.soft = [[l] for l in self.sels]
+
     def __del__(self):
         """
             Destructor.
@@ -514,10 +544,11 @@ def parse_options():
 
     try:
         opts, args = getopt.getopt(sys.argv[1:],
-                                   'de:hs:v',
+                                   'de:hp:p:s:v',
                                    ['dcalls',
                                     'enum=',
                                     'help',
+                                    'process=',
                                     'solver=',
                                     'verbose'])
     except getopt.GetoptError as err:
@@ -527,6 +558,7 @@ def parse_options():
 
     dcalls = False
     to_enum = 1
+    process = 0
     solver = 'm22'
     verbose = 0
 
@@ -540,6 +572,8 @@ def parse_options():
         elif opt in ('-h', '--help'):
             usage()
             sys.exit(0)
+        elif opt in ('-p', '--process'):
+            process = int(arg)
         elif opt in ('-s', '--solver'):
             solver = str(arg)
         elif opt in ('-v', '--verbose'):
@@ -547,7 +581,7 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return dcalls, to_enum, solver, verbose, args
+    return dcalls, to_enum, solver, process, verbose, args
 
 
 #
@@ -563,6 +597,8 @@ def usage():
     print('        -e, --enum=<string>    How many solutions to compute')
     print('                               Available values: [1 .. all] (default: 1)')
     print('        -h, --help')
+    print('        -p, --process=<int>    Number of processing rounds')
+    print('                               Available values: [0 .. INT_MAX] (default = 0)')
     print('        -s, --solver           SAT solver to use')
     print('                               Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = m22)')
     print('        -v, --verbose          Be verbose')
@@ -571,7 +607,7 @@ def usage():
 #
 #==============================================================================
 if __name__ == '__main__':
-    dcalls, to_enum, solver, verbose, files = parse_options()
+    dcalls, to_enum, solver, process, verbose, files = parse_options()
 
     if type(to_enum) == str:
         to_enum = 0
@@ -584,7 +620,8 @@ if __name__ == '__main__':
             else:  # expecting '*.cnf[,p,+].*'
                 formula = CNFPlus(from_file=files[0]).weighted()
 
-        with LBX(formula, use_cld=dcalls, solver_name=solver, use_timer=True) as mcsls:
+        with LBX(formula, use_cld=dcalls, solver_name=solver, process=process,
+                 use_timer=True) as mcsls:
             for i, mcs in enumerate(mcsls.enumerate()):
                 if verbose:
                     print('c MCS:', ' '.join([str(cl_id) for cl_id in mcs]), '0')

{python_sat-1.8.dev19 → python_sat-1.8.dev21}/examples/mcsls.py

@@ -90,6 +90,7 @@ import getopt
 from math import copysign
 import os
 from pysat.formula import CNFPlus, WCNFPlus
+from pysat.process import Processor
 from pysat.solvers import Solver, SolverNames
 import re
 import sys
@@ -112,25 +113,37 @@ class MCSls(object):
         ``use_cld`` is set to ``False``. Internal SAT solver's timer is also
         disabled by default, i.e. ``use_timer`` is ``False``.
 
+        Additionally, the input formula can be preprocessed before running MCS
+        enumeration. This is controlled by the input parameter ``process``
+        whose integer value signifies the number of processing rounds to be
+        applied. The number of rounds is set to 0 by default.
+
         :param formula: unsatisfiable partial CNF formula
         :param use_cld: whether or not to use "clause :math:`D`"
         :param solver_name: SAT oracle name
+        :param process: apply formula preprocessing this many times
         :param use_timer: whether or not to use SAT solver's timer
 
         :type formula: :class:`.WCNF`
         :type use_cld: bool
         :type solver_name: str
+        :type process: int
         :type use_timer: bool
     """
 
-    def __init__(self, formula, use_cld=False, solver_name='m22', use_timer=False):
+    def __init__(self, formula, use_cld=False, solver_name='m22', process=0,
+                 use_timer=False):
         """
             Constructor.
         """
 
+        # dealing with preprocessing, if required
+        hard = formula.hard if process > 0 else []
+
         # bootstrapping the solver with hard clauses
-        self.oracle = Solver(name=solver_name, bootstrap_with=formula.hard,
-                use_timer=use_timer)
+        self.oracle = Solver(name=solver_name,
+                             bootstrap_with=formula.hard if process == 0 else [],
+                             use_timer=use_timer)
         self.solver = solver_name
 
         # adding native cardinality constraints (if any) as hard clauses
@@ -167,13 +180,27 @@ class MCSls(object):
                 sel = self.topv
 
                 new_cl.append(-sel)  # creating a new selector
-                self.oracle.add_clause(new_cl)
+
+                if process == 0:
+                    self.oracle.add_clause(new_cl)
+                else:
+                    # adding to formula's hard clauses
+                    # if any preprocessing is required
+                    hard.append(new_cl)
             else:
                 sel = cl[0]
 
             self.sels.append(sel)
             self.smap[sel] = len(self.sels)
 
+        # finally, applying formula processing, if any
+        if process:
+            # the processor is immediately destroyed,
+            # as we do not need to restore the models
+            with Processor(bootstrap_with=hard) as processor:
+                proc = processor.process(rounds=process, freeze=self.sels)
+                self.oracle.append_formula(proc)
+
     def __del__(self):
         """
             Destructor.
@@ -489,10 +516,11 @@ def parse_options():
 
     try:
         opts, args = getopt.getopt(sys.argv[1:],
-                                   'de:hs:v',
+                                   'de:hp:s:v',
                                    ['dcalls',
                                     'enum=',
                                     'help',
+                                    'process=',
                                     'solver=',
                                     'verbose'])
     except getopt.GetoptError as err:
@@ -502,6 +530,7 @@ def parse_options():
 
     dcalls = False
     to_enum = 1
+    process = 0
     solver = 'm22'
     verbose = 0
 
@@ -515,6 +544,8 @@ def parse_options():
         elif opt in ('-h', '--help'):
             usage()
             sys.exit(0)
+        elif opt in ('-p', '--process'):
+            process = int(arg)
         elif opt in ('-s', '--solver'):
             solver = str(arg)
         elif opt in ('-v', '--verbose'):
@@ -522,7 +553,7 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return dcalls, to_enum, solver, verbose, args
+    return dcalls, to_enum, solver, process, verbose, args
 
 
 #
@@ -538,6 +569,8 @@ def usage():
     print('        -e, --enum=<string>    How many solutions to compute')
     print('                               Available values: [1 .. all] (default: 1)')
     print('        -h, --help')
+    print('        -p, --process=<int>    Number of processing rounds')
+    print('                               Available values: [0 .. INT_MAX] (default = 0)')
     print('        -s, --solver           SAT solver to use')
     print('                               Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = m22)')
     print('        -v, --verbose          Be verbose')
@@ -546,7 +579,7 @@ def usage():
 #
 #==============================================================================
 if __name__ == '__main__':
-    dcalls, to_enum, solver, verbose, files = parse_options()
+    dcalls, to_enum, solver, process, verbose, files = parse_options()
 
     if type(to_enum) == str:
         to_enum = 0
@@ -559,7 +592,8 @@ if __name__ == '__main__':
             else:  # expecting '*.cnf[,p,+].*'
                 formula = CNFPlus(from_file=files[0]).weighted()
 
-        with MCSls(formula, use_cld=dcalls, solver_name=solver, use_timer=True) as mcsls:
+        with MCSls(formula, use_cld=dcalls, solver_name=solver,
+                   process=process, use_timer=True) as mcsls:
             for i, mcs in enumerate(mcsls.enumerate()):
                 if verbose:
                     print('c MCS:', ' '.join([str(cl_id) for cl_id in mcs]), '0')

{python_sat-1.8.dev19 → python_sat-1.8.dev21}/examples/optux.py

@@ -111,6 +111,7 @@ import os
 from pysat.examples.hitman import Atom, Hitman
 from pysat.examples.rc2 import RC2
 from pysat.formula import CNFPlus, WCNFPlus
+from pysat.process import Processor
 from pysat.solvers import Solver, SolverNames
 import re
 import sys
@@ -168,6 +169,11 @@ class OptUx(object):
         support *hard* phase setting, i.e. user preferences will not be
         overwritten by the *phase saving* heuristic [8]_.
 
+        Additionally, the input formula can be preprocessed before running MUS
+        enumeration. This is controlled by the input parameter ``process``
+        whose integer value signifies the number of processing rounds to be
+        applied. The number of rounds is set to 0 by default.
+
         Finally, one more optional input parameter ``cover`` is to be used
         when exhaustive enumeration of MUSes is not necessary and the tool can
         stop as soon as a given formula is covered by the set of currently
@@ -198,6 +204,7 @@ class OptUx(object):
         :param exhaust: do core exhaustion
         :param minz: do heuristic core reduction
         :param nodisj: do not enumerate disjoint MCSes
+        :param process: apply formula preprocessing this many times
         :param puresat: use pure SAT-based hitting set enumeration
         :param unsorted: apply unsorted MUS enumeration
         :param trim: do core trimming at most this number of times
@@ -211,6 +218,7 @@ class OptUx(object):
         :type exhaust: bool
         :type minz: bool
         :type nodisj: bool
+        :type process: int
         :type puresat: str
         :type unsorted: bool
         :type trim: int
@@ -218,7 +226,7 @@ class OptUx(object):
     """
 
     def __init__(self, formula, solver='g3', adapt=False, cover=None,
-            dcalls=False, exhaust=False, minz=False, nodisj=False,
+            dcalls=False, exhaust=False, minz=False, nodisj=False, process=0,
             puresat=False, unsorted=False, trim=False, verbose=0):
         """
             Constructor.
@@ -247,6 +255,15 @@ class OptUx(object):
         self._process_soft(formula)
         self.formula.nv = self.topv
 
+        # applying formula processing (if any)
+        if process:
+            # the processor is immediately destroyed,
+            # as we do not need to restore the models
+            with Processor(bootstrap_with=self.formula.hard) as processor:
+                proc = processor.process(rounds=process, freeze=self.sels)
+                self.formula.hard = proc.clauses
+                self.formula.nv = max(self.formula.nv, proc.nv)
+
         # creating an unweighted copy
         unweighted = self.formula.copy()
         unweighted.wght = [1 for w in unweighted.wght]
@@ -554,11 +571,11 @@ def parse_options():
     """
 
     try:
-        opts, args = getopt.getopt(sys.argv[1:], 'ac:de:hmnp:s:t:uvx',
+        opts, args = getopt.getopt(sys.argv[1:], 'ac:de:hmnp:P:s:t:uvx',
                                    ['adapt', 'cover=', 'dcalls', 'enum=',
                                     'exhaust', 'help', 'minimize', 'no-disj',
-                                    'solver=', 'puresat=', 'unsorted',
-                                    'trim=', 'verbose'])
+                                    'solver=', 'puresat=', 'process=',
+                                    'unsorted', 'trim=', 'verbose'])
     except getopt.GetoptError as err:
         sys.stderr.write(str(err).capitalize() + '\n')
         usage()
@@ -572,6 +589,7 @@ def parse_options():
     no_disj = False
     to_enum = 1
     solver = 'g3'
+    process = 0
     puresat = False
     unsorted = False
     trim = 0
@@ -599,6 +617,8 @@ def parse_options():
             no_disj = True
         elif opt in ('-p', '--puresat'):
             puresat = str(arg)
+        elif opt in ('-P', '--process'):
+            process = int(arg)
         elif opt in ('-s', '--solver'):
             solver = str(arg)
         elif opt in ('-u', '--unsorted'):
@@ -613,7 +633,7 @@ def parse_options():
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
     return adapt, cover, dcalls, exhaust, minz, no_disj, trim, to_enum, \
-            solver, puresat, unsorted, verbose, args
+            solver, process, puresat, unsorted, verbose, args
 
 
 #
@@ -637,6 +657,8 @@ def usage():
     print('        -p, --puresat=<string>    Use a pure SAT-based hitting set enumerator')
     print('                                  Available values: cd15, cd19, lgl, mgh (default = mgh)')
     print('                                  Requires: unsorted mode, i.e. \'-u\'')
+    print('        -P, --process=<int>       Number of processing rounds')
+    print('                                  Available values: [0 .. INT_MAX] (default = 0)')
     print('        -s, --solver              SAT solver to use')
     print('                                  Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = g3)')
     print('        -t, --trim=<int>          How many times to trim unsatisfiable cores')
@@ -650,7 +672,7 @@ def usage():
 #==============================================================================
 if __name__ == '__main__':
     adapt, cover, dcalls, exhaust, minz, no_disj, trim, to_enum, solver, \
-            puresat, unsorted, verbose, files = parse_options()
+            process, puresat, unsorted, verbose, files = parse_options()
 
     if files:
         # reading standard CNF, WCNF, or (W)CNF+
@@ -667,8 +689,8 @@ if __name__ == '__main__':
         # creating an object of OptUx
         with OptUx(formula, solver=solver, adapt=adapt, cover=cover,
                    dcalls=dcalls, exhaust=exhaust, minz=minz, nodisj=no_disj,
-                   puresat=puresat, unsorted=unsorted, trim=trim,
-                   verbose=verbose) as optux:
+                   process=process, puresat=puresat, unsorted=unsorted,
+                   trim=trim, verbose=verbose) as optux:
 
             # iterating over the necessary number of optimal MUSes
             for i, mus in enumerate(optux.enumerate()):