python-sat 0.1.8.dev10__cp310-cp310-win_amd64.whl → 1.8.dev26__cp310-cp310-win_amd64.whl

pysat/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,30 +113,46 @@ 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
         # this can be done only if the Minicard solver is in use
         if isinstance(formula, WCNFPlus) and formula.atms:
+            # we are using CaDiCaL195 and it can use external linear engine
+            if solver_name in SolverNames.cadical195:
+                self.oracle.activate_atmost()
+
             assert self.oracle.supports_atmost(), \
                     '{0} does not support native cardinality constraints. Make sure you use the right type of formula.'.format(solver_name)
 
@@ -163,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.
@@ -485,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:
@@ -498,6 +530,7 @@ def parse_options():
 
     dcalls = False
     to_enum = 1
+    process = 0
     solver = 'm22'
     verbose = 0
 
@@ -511,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'):
@@ -518,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
 
 
 #
@@ -534,28 +569,31 @@ 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: g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = m22)')
+    print('                               Available values: cd15, cd19, g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = m22)')
     print('        -v, --verbose          Be verbose')
 
 
 #
 #==============================================================================
 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
 
     if files:
         # reading standard CNF, WCNF, or (W)CNF+
-        if re.search('cnf[p|+]?(\.(gz|bz2|lzma|xz))?$', files[0]):
-            if re.search('\.wcnf[p|+]?(\.(gz|bz2|lzma|xz))?$', files[0]):
-                formula = WCNFPlus(from_file=files[0])
-            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:
+        assert re.search(r'cnf[p|+]?(\.(gz|bz2|lzma|xz|zst))?$', files[0]), 'Unknown input file extension'
+        if re.search(r'\.wcnf[p|+]?(\.(gz|bz2|lzma|xz|zst))?$', files[0]):
+            formula = WCNFPlus(from_file=files[0])
+        else:  # expecting '*.cnf[,p,+].*'
+            formula = CNFPlus(from_file=files[0]).weighted()
+
+        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')

pysat/examples/models.py

@@ -87,10 +87,12 @@ def enumerate_models(formula, to_enum, solver, warm=False):
                 use_timer=True, warm_start=warm) as s:
         # adding native cardinality constraints if needed
         if formula.atmosts:
-            assert solver_name in SolverNames.minicard or \
-                    solver_name in SolverNames.gluecard3 or \
-                    solver_name in SolverNames.gluecard4, \
-                    '{0} does not support native cardinality constraints'.format(solver_name)
+            # we are using CaDiCaL195 and it can use external linear engine
+            if solver in SolverNames.cadical195:
+                s.activate_atmost()
+
+            assert s.supports_atmost(), \
+                    '{0} does not support native cardinality constraints'.format(solver)
 
             for atm in formula.atmosts:
                 s.add_atmost(*atm)

pysat/examples/musx.py

@@ -99,7 +99,7 @@
 from __future__ import print_function
 import getopt
 import os
-from pysat.formula import CNFPlus, WCNFPlus
+from pysat.formula import CNFPlus, WCNFPlus, CNF
 from pysat.solvers import Solver, SolverNames
 import re
 import sys
@@ -116,7 +116,7 @@ class MUSX(object):
         soft clauses is still unsatisfiable together with the hard clauses.
 
         The constructor of :class:`MUSX` objects receives a target
-        :class:`.WCNF` formula, a SAT solver name, and a verbosity level. Note
+        :class:`.CNF` or `.WCNF` formula, a SAT solver name, and a verbosity level. Note
         that the default SAT solver is MiniSat22 (referred to as ``'m22'``, see
         :class:`.SolverNames` for details). The default verbosity level is
         ``1``.
@@ -140,13 +140,21 @@ class MUSX(object):
         # clause selectors and a mapping from selectors to clause ids
         self.sels, self.vmap = [], {}
 
+        # to deal with a CNF* formula, we create its weighted version
+        if isinstance(formula, CNF):
+            formula = formula.weighted()
+
         # constructing the oracle
         self.oracle = Solver(name=solver, bootstrap_with=formula.hard,
                 use_timer=True)
 
         if isinstance(formula, WCNFPlus) and formula.atms:
-            assert self.oracle.supports_atmost(), \
-                    '{0} does not support native cardinality constraints. Make sure you use the right type of formula.'.format(solver_name)
+            # we are using CaDiCaL195 and it can use external linear engine
+            if solver in SolverNames.cadical195:
+                self.oracle.activate_atmost()
+
+            assert self.oracle.supports_atmost(), ('{0} does not support native cardinality constraints. Make sure you'
+                                                   ' use the right type of formula.').format(solver)
 
             for atm in formula.atms:
                 self.oracle.add_atmost(*atm)
@@ -219,7 +227,7 @@ class MUSX(object):
 
             Soft clauses are (de)activated using the standard MiniSat-like
             assumptions interface [2]_. Each soft clause :math:`c` is augmented
-            with a selector literal :math:`s`, e.g. :math:`(c) \gets (c \\vee
+            with a selector literal :math:`s`, e.g. :math:`(c) \\gets (c \\vee
             \\neg{s})`. As a result, clause :math:`c` can be activated by
             assuming literal :math:`s`. The over-approximation provided as an
             input is specified as a list of selector literals for clauses in
@@ -308,7 +316,7 @@ def usage():
     print('Options:')
     print('        -h, --help')
     print('        -s, --solver     SAT solver to use')
-    print('                         Available values: g3, lgl, mcb, mcm, mpl, m22, mc, mgh (default: m22)')
+    print('                         Available values: cd15, cd19, g3, lgl, mcb, mcm, mpl, m22, mc, mgh (default: m22)')
     print('        -v, --verbose    Be verbose')
 
 
@@ -319,7 +327,7 @@ if __name__ == '__main__':
 
     if files:
         # parsing the input formula
-        if re.search('\.wcnf[p|+]?(\.(gz|bz2|lzma|xz))?$', files[0]):
+        if re.search(r'\.wcnf[p|+]?(\.(gz|bz2|lzma|xz|zst))?$', files[0]):
             formula = WCNFPlus(from_file=files[0])
         else:  # expecting '*.cnf[,p,+].*'
             formula = CNFPlus(from_file=files[0]).weighted()

pysat/examples/optux.py

@@ -111,7 +111,8 @@ import os
 from pysat.examples.hitman import Atom, Hitman
 from pysat.examples.rc2 import RC2
 from pysat.formula import CNFPlus, WCNFPlus
-from pysat.solvers import Solver
+from pysat.process import Processor
+from pysat.solvers import Solver, SolverNames
 import re
 import sys
 
@@ -130,10 +131,12 @@ class OptUx(object):
 
         As a result, OptUx applies exhaustive *disjoint* minimal correction
         subset (MCS) enumeration [1]_, [2]_, [3]_, [4]_ with the incremental
-        use of RC2 [5]_ as an underlying MaxSAT solver. Once disjoint MCSes
-        are enumerated, they are used to bootstrap a hitting set solver. This
-        implementation uses :class:`.Hitman` as a hitting set solver, which is
-        again based on RC2.
+        use of RC2 [5]_ as an underlying MaxSAT solver. Disjoint MCS
+        enumeration is run only if the corresponding input parameter
+        ``nodisj`` is set to ``False``. Once disjoint MCSes are enumerated,
+        they are used to bootstrap a hitting set solver. This implementation
+        uses :class:`.Hitman` as a hitting set solver, which is again based on
+        RC2.
 
         Note that in the main implicit hitting enumeration loop of the
         algorithm, OptUx follows Forqes in that it does not reduce correction
@@ -166,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
@@ -195,6 +203,8 @@ class OptUx(object):
         :param dcalls: apply clause D oracle calls (for unsorted enumeration only)
         :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
@@ -207,6 +217,8 @@ class OptUx(object):
         :type dcalls: bool
         :type exhaust: bool
         :type minz: bool
+        :type nodisj: bool
+        :type process: int
         :type puresat: str
         :type unsorted: bool
         :type trim: int
@@ -214,8 +226,8 @@ class OptUx(object):
     """
 
     def __init__(self, formula, solver='g3', adapt=False, cover=None,
-            dcalls=False, exhaust=False, minz=False, puresat=False,
-                 unsorted=False, trim=False, verbose=0):
+            dcalls=False, exhaust=False, minz=False, nodisj=False, process=0,
+            puresat=False, unsorted=False, trim=False, verbose=0):
         """
             Constructor.
         """
@@ -243,13 +255,25 @@ 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]
 
-        # enumerating disjoint MCSes (including unit-size MCSes)
-        to_hit, self.units = self._disjoint(unweighted, solver, adapt, exhaust,
-                minz, trim)
+        if not nodisj:
+            # enumerating disjoint MCSes (including unit-size MCSes)
+            to_hit, self.units = self._disjoint(unweighted, solver, adapt, exhaust,
+                    minz, trim)
+        else:
+            to_hit, self.units, self.disj_time = [], [], 0.
 
         if self.verbose > 2:
             print('c mcses: {0} unit, {1} disj'.format(len(self.units),
@@ -286,9 +310,13 @@ class OptUx(object):
         # SAT oracle bootstrapped with the hard clauses; note that
         # clauses of the unit-size MCSes are enforced to be enabled
         self.oracle = Solver(name=solver, bootstrap_with=unweighted.hard +
-                [[mcs] for mcs in self.units])
+                [[mcs] for mcs in self.units], use_timer=True)
 
         if unweighted.atms:
+            if solver in SolverNames.cadical195:
+                # we are using CaDiCaL195 and it can use external linear engine
+                self.oracle.activate_atmost()
+
             assert self.oracle.supports_atmost(), \
                     '{0} does not support native cardinality constraints. Make sure you use the right type of formula.'.format(self.solver)
 
@@ -434,7 +462,7 @@ class OptUx(object):
                     break
 
                 # extracting the MCS corresponding to the model
-                falsified = list(filter(lambda l: model[abs(l) - 1] == -l, self.sels))
+                falsified = [l for l in self.sels if model[abs(l) - 1] == -l]
 
                 # unit size or not?
                 if len(falsified) > 1:
@@ -500,7 +528,7 @@ class OptUx(object):
                 # the candidate subset is satisfiable,
                 # thus extracting a correction subset
                 model = self.oracle.get_model()
-                cs = list(filter(lambda l: model[abs(l) - 1] == -l, self.sels))
+                cs = [l for l in self.sels if model[abs(l) - 1] == -l]
 
                 # hitting the new correction subset
                 self.hitman.hit(cs, weights=self.weights)
@@ -543,10 +571,11 @@ def parse_options():
     """
 
     try:
-        opts, args = getopt.getopt(sys.argv[1:], 'ac:de:hmp:s:t:uvx',
-                ['adapt', 'cover=', 'dcalls', 'enum=', 'exhaust', 'help',
-                    'minimize', 'solver=', 'puresat=', 'unsorted', 'trim=',
-                    'verbose'])
+        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=', 'process=',
+                                    'unsorted', 'trim=', 'verbose'])
     except getopt.GetoptError as err:
         sys.stderr.write(str(err).capitalize() + '\n')
         usage()
@@ -557,8 +586,10 @@ def parse_options():
     dcalls = False
     exhaust = False
     minz = False
+    no_disj = False
     to_enum = 1
-    solver = 'm22'
+    solver = 'g3'
+    process = 0
     puresat = False
     unsorted = False
     trim = 0
@@ -582,8 +613,12 @@ def parse_options():
             sys.exit(0)
         elif opt in ('-m', '--minimize'):
             minz = True
+        elif opt in ('-n', '--no-disj'):
+            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'):
@@ -597,8 +632,8 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return adapt, cover, dcalls, exhaust, minz, trim, to_enum, solver, \
-            puresat, unsorted, verbose, args
+    return adapt, cover, dcalls, exhaust, minz, no_disj, trim, to_enum, \
+            solver, process, puresat, unsorted, verbose, args
 
 
 #
@@ -618,11 +653,14 @@ def usage():
     print('                                  Available values: [1 .. INT_MAX], all (default: 1)')
     print('        -h, --help                Show this message')
     print('        -m, --minimize            Use a heuristic unsatisfiable core minimizer')
+    print('        -n, --no-disj             Do not enumerate disjoint MCSes')
     print('        -p, --puresat=<string>    Use a pure SAT-based hitting set enumerator')
-    print('                                  Available values: cd15, lgl, mgh (default = mgh)')
+    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: g3, g4, lgl, mcb, mcm, mpl, m22, mc, mgh (default = m22)')
+    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')
     print('                                  Available values: [0 .. INT_MAX] (default = 0)')
     print('        -u, --unsorted            Enumerate MUSes in an unsorted way')
@@ -633,25 +671,26 @@ def usage():
 #
 #==============================================================================
 if __name__ == '__main__':
-    adapt, cover, dcalls, exhaust, minz, trim, to_enum, solver, puresat, \
-            unsorted, verbose, files = parse_options()
+    adapt, cover, dcalls, exhaust, minz, no_disj, trim, to_enum, solver, \
+            process, puresat, unsorted, verbose, files = parse_options()
 
     if files:
         # reading standard CNF, WCNF, or (W)CNF+
-        if re.search(r'cnf[p|+]?(\.(gz|bz2|lzma|xz))?$', files[0]):
-            if re.search(r'\.wcnf[p|+]?(\.(gz|bz2|lzma|xz))?$', files[0]):
-                formula = WCNFPlus(from_file=files[0])
-            else:  # expecting '*.cnf[,p,+].*'
-                formula = CNFPlus(from_file=files[0]).weighted()
+        assert re.search(r'cnf[p|+]?(\.(gz|bz2|lzma|xz|zst))?$', files[0]), 'Unknown input file extension'
+        if re.search(r'\.wcnf[p|+]?(\.(gz|bz2|lzma|xz|zst))?$', files[0]):
+            formula = WCNFPlus(from_file=files[0])
+        else:  # expecting '*.cnf[,p,+].*'
+            formula = CNFPlus(from_file=files[0]).weighted()
 
         if cover:  # expecting  '*.cnf[,p,+].*' only!
-            assert re.search(r'cnf[p|+]?(\.(gz|bz2|lzma|xz))?$', cover), 'wrong file for formula to cover'
+            assert re.search(r'cnf[p|+]?(\.(gz|bz2|lzma|xz|zst))?$', cover), 'Wrong file for formula to cover'
             cover = CNFPlus(from_file=cover)
 
         # creating an object of OptUx
         with OptUx(formula, solver=solver, adapt=adapt, cover=cover,
-                dcalls=dcalls, exhaust=exhaust, minz=minz, puresat=puresat,
-                unsorted=unsorted, trim=trim, verbose=verbose) as optux:
+                   dcalls=dcalls, exhaust=exhaust, minz=minz, nodisj=no_disj,
+                   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()):