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

{python_sat-0.1.8.dev10.data → python_sat-1.8.dev26.data}/scripts/fm.py

@@ -209,6 +209,10 @@ class FM(object):
         self.oracle = Solver(name=self.solver, bootstrap_with=self.hard, use_timer=True)
 
         if self.atm1:  # this check is needed at the beggining (before iteration 1)
+            # we are using CaDiCaL195 and it can use external linear engine
+            if self.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_name)
 
@@ -288,8 +292,7 @@ class FM(object):
 
         while True:
             if self.oracle.solve(assumptions=self.sels):
-                self.model = self.oracle.get_model()
-                self.model = list(filter(lambda l: abs(l) <= self.orig_nv, self.model))
+                self.model = [l for l in self.oracle.get_model() if abs(l) <= self.orig_nv]
                 return
             else:
                 self.treat_core()
@@ -382,12 +385,12 @@ class FM(object):
 
             Otherwise (if the core contains more than one clause), every clause
             :math:`c` of the core is *relaxed*. This means a new *relaxation
-            literal* is added to the clause, i.e. :math:`c\gets c\\vee r`,
+            literal* is added to the clause, i.e. :math:`c\\gets c\\vee r`,
             where :math:`r` is a fresh (unused) relaxation variable. After the
             clauses get relaxed, a new cardinality encoding is added to the
             formula enforcing the sum of the new relaxation variables to be not
-            greater than 1, :math:`\sum_{c\in\phi}{r\leq 1}`, where
-            :math:`\phi` denotes the unsatisfiable core.
+            greater than 1, :math:`\\sum_{c\\in\\phi}{r\\leq 1}`, where
+            :math:`\\phi` denotes the unsatisfiable core.
         """
 
         if len(self.core) > 1:
@@ -471,7 +474,8 @@ def parse_options():
     cardenc = encmap[cardenc]
 
     # using minicard's native implementation of AtMost1 constraints
-    if solver in SolverNames.minicard or solver in SolverNames.gluecard3 or solver in SolverNames.gluecard4:
+    if solver in SolverNames.minicard + SolverNames.gluecard3 + \
+            SolverNames.gluecard4 + SolverNames.cadical195:
         cardenc = encmap['native']
     else:
         assert cardenc != encmap['native'], 'Only Minicard can handle cardinality constraints natively'
@@ -491,7 +495,7 @@ def usage():
     print('                         Available values: bw, cardn, kmtot, ladder, mtot, pw, seqc, sortn, tot (default = seqc)')
     print('        -h, --help')
     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')
 
 
@@ -502,7 +506,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()

{python_sat-0.1.8.dev10.data → python_sat-1.8.dev26.data}/scripts/genhard.py

@@ -129,7 +129,7 @@ class PHP(CNF, object):
     """
         Generator of :math:`k` pigeonhole principle (:math:`k`-PHP) formulas.
         Given integer parameters :math:`m` and :math:`k`, the :math:`k`
-        pigeonhole principle states that if :math:`k\cdot m+1` pigeons are
+        pigeonhole principle states that if :math:`k\\cdot m+1` pigeons are
         distributes by :math:`m` holes, then at least one hole contains more
         than :math:`k` pigeons.
 
@@ -139,9 +139,9 @@ class PHP(CNF, object):
 
         Assume that a Boolean variable :math:`x_{ij}` encodes that pigeon
         :math:`i` resides in hole :math:`j`. Then a PHP formula can be seen as
-        a conjunction: :math:`\\bigwedge_{i=1}^{k\cdot
-        m+1}{\\textsf{AtLeast1}(x_{i1},\ldots,x_{im})}\wedge
-        \\bigwedge_{j=1}^{m}{\\textsf{AtMost}k(x_{1j},\ldots,x_{k\cdot
+        a conjunction: :math:`\\bigwedge_{i=1}^{k\\cdot
+        m+1}{\\textsf{AtLeast1}(x_{i1},\\ldots,x_{im})}\\wedge
+        \\bigwedge_{j=1}^{m}{\\textsf{AtMost}k(x_{1j},\\ldots,x_{k\\cdot
         m+1,j})}`. Here each :math:`\\textsf{AtLeast1}` constraint forces every
         pigeon to be placed into at least one hole while each
         :math:`\\textsf{AtMost}k` constraint allows the corresponding hole to
@@ -204,16 +204,17 @@ class GT(CNF, object):
     """
         Generator of ordering (or *greater than*, GT) principle formulas. Given
         an integer parameter :math:`n`, the principle states that any partial
-        order on the set :math:`\{1,2,\ldots,n\}` must have a maximal element.
-
-        Assume variable :math:`x_{ij}`, for :math:`i,j\in[n],i\\neq j`, denotes
-        the fact that :math:`i \succ j`. Clauses :math:`(\\neg{x_{ij}} \\vee
-        \\neg{x_{ji}})` and :math:`(\\neg{x_{ij}} \\vee \\neg{x_{jk}} \\vee
-        x_{ik})` ensure that the relation :math:`\succ` is anti-symmetric and
-        transitive. As a result, :math:`\succ` is a partial order on
-        :math:`[n]`. The additional requirement that each element :math:`i` has
-        a successor in :math:`[n]\setminus\{i\}` represented a clause
-        :math:`(\\vee_{j \\neq i}{x_{ji}})` makes the formula unsatisfiable.
+        order on the set :math:`\\{1,2,\\ldots,n\\}` must have a maximal element.
+
+        Assume variable :math:`x_{ij}`, for :math:`i,j\\in[n],i\\neq j`,
+        denotes the fact that :math:`i \\succ j`. Clauses
+        :math:`(\\neg{x_{ij}} \\vee \\neg{x_{ji}})` and :math:`(\\neg{x_{ij}}
+        \\vee \\neg{x_{jk}} \\vee x_{ik})` ensure that the relation
+        :math:`\\succ` is anti-symmetric and transitive. As a result,
+        :math:`\\succ` is a partial order on :math:`[n]`. The additional
+        requirement that each element :math:`i` has a successor in
+        :math:`[n]\\setminus\\{i\\}` represented a clause :math:`(\\vee_{j
+        \\neq i}{x_{ji}})` makes the formula unsatisfiable.
 
         GT formulas were originally conjectured [2]_ to be hard for resolution.
         However, [5]_ proved the existence of a polynomial size resolution
@@ -276,18 +277,18 @@ class CB(CNF, object):
     """
         Mutilated chessboard principle (CB). Given an integer :math:`n`, the
         principle states that it is impossible to cover a chessboard of size
-        :math:`2n\cdot 2n` by domino tiles if two diagonally opposite corners
+        :math:`2n\\cdot 2n` by domino tiles if two diagonally opposite corners
         of the chessboard are removed.
 
         Note that the chessboard has :math:`4n^2-2` cells. Introduce a Boolean
-        variable :math:`x_{ij}` for :math:`i,j\in[4n^2-2]` s.t. cells :math:`i`
-        and :math:`j` are adjacent (no variables are introduced for pairs of
-        non-adjacent cells). CB formulas comprise clauses (1)
+        variable :math:`x_{ij}` for :math:`i,j\\in[4n^2-2]` s.t. cells
+        :math:`i` and :math:`j` are adjacent (no variables are introduced for
+        pairs of non-adjacent cells). CB formulas comprise clauses (1)
         :math:`(\\neg{x_{ji} \\vee \\neg{x_{ki}}})` for every :math:`i,j \\neq
         k` meaning that no more than one adjacent cell can be paired with the
-        current one; and (2) :math:`(\\vee_{j \in \\text{Adj}(i)} {x_{ij}})\,\,
-        \\forall i` enforcing that every cell :math:`i` should be paired with
-        at least one adjacent cell.
+        current one; and (2) :math:`(\\vee_{j \\in \\text{Adj}(i)}
+        {x_{ij}})\\,\\, \\forall i` enforcing that every cell :math:`i` should
+        be paired with at least one adjacent cell.
 
         Clearly, since the two diagonal corners are removed, the formula is
         unsatisfiable. Also note the following. Assuming that the number of
@@ -389,8 +390,8 @@ class PAR(CNF, object):
         variables :math:`x_{ij},i \\neq j`. If variable :math:`x_{ij}` is
         *true*, then there is an edge between nodes :math:`i` and :math:`j`.
         The formula consists of the following clauses: :math:`(\\vee_{j \\neq
-        i}{x_{ij}})` for every :math:`i\in[2n+1]`, and :math:`(\\neg{x_{ij}}
-        \\vee \\neg{x_{kj}})` for all distinct :math:`i,j,k \in [2n+1]`.
+        i}{x_{ij}})` for every :math:`i\\in[2n+1]`, and :math:`(\\neg{x_{ij}}
+        \\vee \\neg{x_{kj}})` for all distinct :math:`i,j,k \\in [2n+1]`.
 
         The parity principle is known to be hard for resolution [4]_.
 

{python_sat-0.1.8.dev10.data → python_sat-1.8.dev26.data}/scripts/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,30 +113,46 @@ 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
         # 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)
 
@@ -162,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.
@@ -510,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:
@@ -523,6 +558,7 @@ def parse_options():
 
     dcalls = False
     to_enum = 1
+    process = 0
     solver = 'm22'
     verbose = 0
 
@@ -536,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'):
@@ -543,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
 
 
 #
@@ -559,28 +597,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 LBX(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 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-0.1.8.dev10.data → python_sat-1.8.dev26.data}/scripts/lsu.py

@@ -118,22 +118,25 @@ class LSU:
 
         :param formula: input MaxSAT formula
         :param solver: name of SAT solver
+        :param incr: enable incremental mode of Glucose
         :param expect_interrupt: whether or not an :meth:`interrupt` call is expected
         :param verbose: verbosity level
 
         :type formula: :class:`.WCNF`
         :type solver: str
+        :type incr: bool
         :type expect_interrupt: bool
         :type verbose: int
     """
 
-    def __init__(self, formula, solver='g4', expect_interrupt=False, verbose=0):
+    def __init__(self, formula, solver='g4', incr=False, expect_interrupt=False, verbose=0):
         """
             Constructor.
         """
 
         self.verbose = verbose
         self.solver = solver
+        self.incr = incr
         self.expect_interrupt = expect_interrupt
         self.formula = formula
         self.topv = formula.nv  # largest variable index
@@ -154,7 +157,7 @@ class LSU:
         """
 
         self.oracle = Solver(name=self.solver, bootstrap_with=formula.hard,
-                incr=True, use_timer=True)
+                incr=self.incr, use_timer=True)
 
         for i, cl in enumerate(formula.soft):
             # TODO: if clause is unit, use its literal as selector
@@ -353,18 +356,23 @@ class LSUPlus(LSU, object):
         :type verbose: int
     """
 
-    def __init__(self, formula, solver, expect_interrupt=False, verbose=0):
+    def __init__(self, formula, solver='g4', incr=False, expect_interrupt=False, verbose=0):
         """
             Constructor.
         """
 
         assert solver in SolverNames.gluecard3 or \
                 solver in SolverNames.gluecard4 or \
-                solver in SolverNames.minicard, '{0} does not support native cardinality constraints'.format(solver)
+                solver in SolverNames.minicard or \
+                solver in SolverNames.cadical195, '{0} does not support native cardinality constraints'.format(solver)
 
-        super(LSUPlus, self).__init__(formula, solver=solver,
+        super(LSUPlus, self).__init__(formula, solver=solver, incr=incr,
                 expect_interrupt=expect_interrupt, verbose=verbose)
 
+        # we are using CaDiCaL195 and it can use external linear engine
+        if solver in SolverNames.cadical195:
+            self.oracle.activate_atmost()
+
         # adding atmost constraints
         for am in formula.atms:
             self.oracle.add_atmost(*am)
@@ -391,13 +399,14 @@ def parse_options():
     """
 
     try:
-        opts, args = getopt.getopt(sys.argv[1:], 'hms:t:v', ['help', 'model', 'solver=', 'timeout=', 'verbose'])
+        opts, args = getopt.getopt(sys.argv[1:], 'hims:t:v', ['help', 'incr', 'model', 'solver=', 'timeout=', 'verbose'])
     except getopt.GetoptError as err:
         sys.stderr.write(str(err).capitalize())
         print_usage()
         sys.exit(1)
 
     solver = 'g4'
+    incr = False
     verbose = 1
     print_model = False
     timeout = None
@@ -406,6 +415,8 @@ def parse_options():
         if opt in ('-h', '--help'):
             print_usage()
             sys.exit(0)
+        elif opt in ('-i', '--incr'):
+            incr = True
         elif opt in ('-m', '--model'):
             print_model = True
         elif opt in ('-s', '--solver'):
@@ -418,7 +429,7 @@ def parse_options():
         else:
             assert False, 'Unhandled option: {0} {1}'.format(opt, arg)
 
-    return print_model, solver, timeout, verbose, args
+    return incr, print_model, solver, timeout, verbose, args
 
 
 #
@@ -431,9 +442,10 @@ def print_usage():
     print('Usage: ' + os.path.basename(sys.argv[0]) + ' [options] dimacs-file')
     print('Options:')
     print('        -h, --help               Show this message')
+    print('        -i, --incr               Enable incremental model (for Glucose only)')
     print('        -m, --model              Print model')
     print('        -s, --solver=<string>    SAT solver to use')
-    print('                                 Available values: g3, g4, mc, m22, mgh (default = g4)')
+    print('                                 Available values: cd15, cd19, g3, g4, mc, m22, mgh (default = g4)')
     print('        -t, --timeout=<float>    Set time limit for MaxSAT solver')
     print('                                 Available values: [0 .. FLOAT_MAX], none (default: none)')
     print('        -v, --verbose            Be verbose')
@@ -442,24 +454,26 @@ def print_usage():
 #
 #==============================================================================
 if __name__ == '__main__':
-    print_model, solver, timeout, verbose, files = parse_options()
+    incr, print_model, solver, timeout, verbose, files = parse_options()
 
     if files:
         # reading standard CNF or WCNF
-        if re.search('cnf(\.(gz|bz2|lzma|xz))?$', files[0]):
-            if re.search('\.wcnf(\.(gz|bz2|lzma|xz))?$', files[0]):
+        if re.search(r'cnf(\.(gz|bz2|lzma|xz|zst))?$', files[0]):
+            if re.search(r'\.wcnf(\.(gz|bz2|lzma|xz|zst))?$', files[0]):
                 formula = WCNF(from_file=files[0])
             else:  # expecting '*.cnf'
                 formula = CNF(from_file=files[0]).weighted()
 
-            lsu = LSU(formula, solver=solver,
+            lsu = LSU(formula, solver=solver, incr=incr,
                     expect_interrupt=(timeout != None), verbose=verbose)
 
         # reading WCNF+
-        elif re.search('\.wcnf[p,+](\.(gz|bz2|lzma|xz))?$', files[0]):
+        elif re.search(r'\.wcnf[p,+](\.(gz|bz2|lzma|xz|zst))?$', files[0]):
             formula = WCNFPlus(from_file=files[0])
-            lsu = LSUPlus(formula, solver=solver,
+            lsu = LSUPlus(formula, solver=solver, incr=incr,
                     expect_interrupt=(timeout != None), verbose=verbose)
+        else:
+            assert False, 'Unknown input file extension'
 
         # setting a timer if necessary
         if timeout is not None:

{python_sat-0.1.8.dev10.data → python_sat-1.8.dev26.data}/scripts/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')

{python_sat-0.1.8.dev10.data → python_sat-1.8.dev26.data}/scripts/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)