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

pysat/examples/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()

pysat/examples/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]_.
 

pysat/examples/hitman.py

@@ -35,14 +35,14 @@
     by size) subset-minimal hitting enumeration.
 
     The minimal hitting set problem is trivially formulated as a MaxSAT formula
-    in WCNF, as follows. Assume :math:`E=\{e_1,\ldots,e_n\}` to be a universe
+    in WCNF, as follows. Assume :math:`E=\\{e_1,\\ldots,e_n\\}` to be a universe
     of elements. Also assume there are :math:`k` sets to hit:
-    :math:`s_i=\{e_{i,1},\ldots,e_{i,j_i}\}` s.t. :math:`e_{i,l}\in E`. Every
-    set :math:`s_i=\{e_{i,1},\ldots,e_{i,j_i}\}` is translated into a hard
-    clause :math:`(e_{i,1} \\vee \ldots \\vee e_{i,j_i})`. This results in the
+    :math:`s_i=\\{e_{i,1},\\ldots,e_{i,j_i}\\}` s.t. :math:`e_{i,l}\\in E`. Every
+    set :math:`s_i=\\{e_{i,1},\\ldots,e_{i,j_i}\\}` is translated into a hard
+    clause :math:`(e_{i,1} \\vee \\ldots \\vee e_{i,j_i})`. This results in the
     set of hard clauses having size :math:`k`. The set of soft clauses
     comprises unit clauses of the form :math:`(\\neg{e_{j}})` s.t.
-    :math:`e_{j}\in E`, each having weight 1.
+    :math:`e_{j}\\in E`, each having weight 1.
 
     Taking into account this problem formulation as MaxSAT, ordered hitting
     enumeration is done with the use of the state-of-the-art MaxSAT solver
@@ -387,21 +387,27 @@ class Hitman(object):
                         nohard=True, trim=self.trim)
         elif self.htype == 'lbx':
             self.oracle = LBX(formula, solver_name=self.solver,
-                    use_cld=self.usecld)
+                    use_cld=self.usecld, use_timer=True)
         elif self.htype == 'mcsls':
             self.oracle = MCSls(formula, solver_name=self.solver,
-                    use_cld=self.usecld)
+                    use_cld=self.usecld, use_timer=True)
         else:  # 'sat'
             assert self.solver in SolverNames.minisatgh + \
-                    SolverNames.lingeling + SolverNames.cadical153, \
-                    'Hard polarity setting is unsupported by {0}'.format(self.solver)
-
-            assert formula.atms == [], 'Native AtMostK constraints aren\'t' \
-            'supported by MinisatGH, Lingeling, or CaDiCaL 153'
+                    SolverNames.lingeling + SolverNames.cadical153 + \
+                    SolverNames.cadical195, 'Hard polarity setting is unsupported by {0}'.format(self.solver)
 
             # setting up a SAT solver, so that it supports the same interface
-            self.oracle = Solver(name=self.solver, bootstrap_with=formula.hard,
-                                 use_timer=True)
+            if formula.atms == []:
+                self.oracle = Solver(name=self.solver, bootstrap_with=formula.hard,
+                                    use_timer=True)
+            elif self.solver in SolverNames.cadical195:
+                self.oracle = Solver(name=self.solver, bootstrap_with=formula.hard,
+                                    use_timer=True, native_card=True)
+
+                for atm in formula.atms:
+                    self.oracle.add_atmost(*atm)
+            else:
+                assert 0, 'Native AtMostK constraints aren\'t supported by MinisatGH, Lingeling, or CaDiCaL 153'
 
             # MinisatGH supports warm start mode
             if self.solver in SolverNames.minisatgh:
@@ -440,7 +446,7 @@ class Hitman(object):
             # updating the preferences
             self.oracle.set_phases(literals=[self.phase * (-v) for v in self.idpool.id2obj])
 
-    def add_hard(self, clause, weights=None):
+    def add_hard(self, clause, weights=None, no_obj=False):
         """
             Add a hard constraint, which can be either a pure clause or an
             AtMostK constraint.
@@ -450,47 +456,57 @@ class Hitman(object):
             question into weights. Also note that the weight of an object must
             not change from one call of :meth:`hit` to another.
 
+            Finally, note that if ``no_obj`` is set to True, no new objects
+            will be added to the hitting set enumerator. This is useful if the
+            variables in the clause are either already present or are
+            auxiliary. This is turned off by default.
+
             :param clause: hard constraint (either a clause or a native AtMostK constraint)
             :param weights: a mapping from objects to weights
+            :param no_obj: if True, no new objects are added to the oracle
 
             :type clause: iterable(obj)
             :type weights: dict(obj)
+            :type no_obj: bool
         """
 
         if not len(clause) == 2 or not type(clause[0]) in (list, tuple, set):
             # this is a pure clause
             clause = list(map(lambda a: self.idpool.id(a.obj) * (2 * a.sign - 1), clause))
 
-            # a soft clause should be added for each new object
-            new_obj = filter(lambda vid: abs(vid) not in self.oracle.vmap.e2i, clause)
+            if no_obj is False:
+                # a soft clause should be added for each new object
+                new_obj = filter(lambda vid: abs(vid) not in self.oracle.vmap.e2i, clause)
         else:
             # this is a native AtMostK constraint
             clause = [list(map(lambda a: self.idpool.id(a.obj) * (2 * a.sign - 1), clause[0])), clause[1]]
 
-            # a soft clause should be added for each new object
-            new_obj = filter(lambda vid: abs(vid) not in self.oracle.vmap.e2i, clause[0])
+            if no_obj is False:
+                # a soft clause should be added for each new object
+                new_obj = filter(lambda vid: abs(vid) not in self.oracle.vmap.e2i, clause[0])
 
-            # there may be duplicate literals if the constraint is weighted
-            new_obj = list(set(new_obj))
-
-        # some of the literals may also have the opposite polarity
-        new_obj = [l if l in self.idpool.obj2id else -l for l in new_obj]
+                # there may be duplicate literals if the constraint is weighted
+                new_obj = list(set(new_obj))
 
         # adding the hard clause
         self.oracle.add_clause(clause)
 
-        if self.htype != 'sat':
-            # new soft clauses
-            for vid in new_obj:
-                self.oracle.add_clause([-vid], 1 if not weights else weights[self.idpool.obj(vid)])
-        else:
-            # dummy variable id mapping
-            for vid in new_obj:
-                self.oracle.vmap.e2i[vid] = vid
-                self.oracle.vmap.i2e[vid] = vid
+        if no_obj is False:
+            # some of the literals may also have the opposite polarity
+            new_obj = [l if l in self.idpool.obj2id else -l for l in new_obj]
 
-            # setting variable polarities
-            self.oracle.set_phases(literals=[self.phase * (-vid) for vid in new_obj])
+            if self.htype != 'sat':
+                # new soft clauses
+                for vid in new_obj:
+                    self.oracle.add_clause([-vid], 1 if not weights else weights[self.idpool.obj(vid)])
+            else:
+                # dummy variable id mapping
+                for vid in new_obj:
+                    self.oracle.vmap.e2i[vid] = vid
+                    self.oracle.vmap.i2e[vid] = vid
+
+                # setting variable polarities
+                self.oracle.set_phases(literals=[self.phase * (-vid) for vid in new_obj])
 
     def delete(self):
         """
@@ -545,7 +561,7 @@ class Hitman(object):
         to_hit = list(map(lambda obj: self.idpool.id(obj), to_hit))
 
         # a soft clause should be added for each new object
-        new_obj = list(filter(lambda vid: vid not in self.oracle.vmap.e2i, to_hit))
+        new_obj = [vid for vid in to_hit if vid not in self.oracle.vmap.e2i]
 
         # new hard clause; phase multiplication is needed
         # for making phase switching possible (pure SAT only)
@@ -588,7 +604,7 @@ class Hitman(object):
         to_block = list(map(lambda obj: self.idpool.id(obj), to_block))
 
         # a soft clause should be added for each new object
-        new_obj = list(filter(lambda vid: vid not in self.oracle.vmap.e2i, to_block))
+        new_obj = [vid for vid in to_block if vid not in self.oracle.vmap.e2i]
 
         # new hard clause; phase multiplication is needed
         # for making phase switching possible (pure SAT only)

pysat/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,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')

pysat/examples/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: