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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev19
+Version: 1.9.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

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

@@ -247,6 +247,10 @@ class LBX(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param soft: whether or not the clause is soft
 

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

@@ -248,6 +248,10 @@ class MCSls(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param soft: whether or not the clause is soft
 

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/examples/rc2.py

@@ -362,6 +362,9 @@ class RC2(object):
         self.sels_set = set(self.sels)
         self.sall = self.sels[:]
 
+        # original weights (as opposed to those after splitting)
+        self.owgt = dict(self.wght)
+
         # we may end up having zero-weighed soft clauses
         self.garbage = set([l for l in self.sels if self.wght[l] == 0])
         if self.garbage:
@@ -403,6 +406,10 @@ class RC2(object):
             native cardinality constraints represented as a pair ``(lits,
             bound)``. Only hard cardinality constraints can be added.
 
+            Finally, note that clauses cannot be safely added if formula
+            processing is used (see parameter ``process``) as they may
+            refer to variables eliminated by the processor.
+
             :param clause: a clause to add
             :param weight: weight of the clause (if any)
 
@@ -475,6 +482,7 @@ class RC2(object):
                     # selector is not new; increment its weight
                     self.wght[selv] += weight
 
+                self.owgt[selv] = self.owgt.get(selv, 0) + weight
                 self.sall.append(selv)
                 self.sels_set.add(selv)
 
@@ -560,15 +568,15 @@ class RC2(object):
                 # so let's transform the None model returned to []
                 self.model = []
 
+            # if formula processing was used, we should restore the model
+            # for the original formula (before selectors are filtered out)
+            if self.processor:
+                self.model = self.processor.restore(self.model)
+
             self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
             self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
             self.model = sorted(self.model, key=lambda l: abs(l))
 
-            # if formula processing was used, we should
-            # restore the model for the original formula
-            if self.processor:
-                self.model = self.processor.restore(self.model)
-
             return self.model
 
     def enumerate(self, block=0, expect_interrupt=False):
@@ -583,7 +591,8 @@ class RC2(object):
             (MSSes) or minimal correction subsets (MCSes). To block MSSes, one
             should set the ``block`` parameter to ``1``. To block MCSes, set
             it to ``-1``. By the default (for blocking MaxSAT models),
-            ``block`` is set to ``0``.
+            ``block`` is set to ``0``. Note that if formula processing is
+            used (see parameter ``process``), only MCSes can be blocked.
 
             This MaxSAT enumeration call can be asynchronously interrupted, in
             which case the value of ``expect_interrupt`` must be set to
@@ -621,6 +630,9 @@ class RC2(object):
                 >>> rc2.delete()
         """
 
+        assert not self.processor or block == -1, \
+                'Only MCSes can be blocked if formula processing is used'
+
         done = False
         while not done:
             model = self.compute(expect_interrupt=expect_interrupt)
@@ -1471,6 +1483,9 @@ class RC2Stratified(RC2, object):
         # do clause hardening
         self.hard = nohard == False
 
+        # upper bound on the cost (trivial at first)
+        self.ubnd = sum(self.owgt.values())
+
         # backing up selectors
         self.bckp, self.bckp_set = self.sels, self.sels_set
         self.sels = []
@@ -1571,15 +1586,15 @@ class RC2Stratified(RC2, object):
             # so let's transform the None model returned to []
             self.model = []
 
+        # if formula processing was used, we should restore the model
+        # for the original formula (before selectors are filtered out)
+        if self.processor:
+            self.model = self.processor.restore(self.model)
+
         self.model = filter(lambda l: abs(l) in self.vmap.i2e, self.model)
         self.model = map(lambda l: int(copysign(self.vmap.i2e[abs(l)], l)), self.model)
         self.model = sorted(self.model, key=lambda l: abs(l))
 
-        # if formula processing was used, we should
-        # restore the model for the original formula
-        if self.processor:
-            self.model = self.processor.restore(self.model)
-
         return self.model
 
     def next_level(self):
@@ -1648,14 +1663,17 @@ class RC2Stratified(RC2, object):
             to optimization levels up to the newly computed level. It
             also reactivates previously deactivated clauses (see
             :func:`process_sels` and :func:`process_sums` for
-            details).
+            details). Clauses whose weight exceeds the gap between
+            the upper and lower bounds are hardened instead.
         """
 
         end = min(self.levl + 1, len(self.blop))
 
         for l in range(beg, end):
             for sel in self.wstr[self.blop[l]]:
-                if sel in self.bckp_set:
+                if self.hard and self.blop[l] > self.ubnd - self.cost:
+                    self.oracle.add_clause([sel])
+                elif sel in self.bckp_set:
                     self.sels.append(sel)
                 else:
                     self.sums.append(sel)
@@ -1670,7 +1688,8 @@ class RC2Stratified(RC2, object):
             This method does postprocessing of the current
             optimization level after it is solved. This includes
             *hardening* some of the soft clauses (depending on their
-            remaining weights) and also garbage collection.
+            remaining weights) and also garbage collection. The
+            level's model is used to tighten the upper bound.
         """
 
         # assumptions to remove
@@ -1679,9 +1698,15 @@ class RC2Stratified(RC2, object):
         # sum of weights of the remaining levels
         sumw = sum([w * len(self.wstr[w]) for w in self.blop[(self.levl + 1):]])
 
+        # upper bound given by the current model;
+        # selectors unknown to the oracle are deemed to be falsified
+        model = self.oracle.get_model()
+        cost = sum([w for s, w in six.iteritems(self.owgt) if abs(s) > len(model) or model[abs(s) - 1] != s])
+        self.ubnd = min(self.ubnd, cost)
+
         # trying to harden selectors and sums
         for s in self.sels + self.sums:
-            if self.wght[s] > sumw:
+            if self.wght[s] > min(sumw, self.ubnd - self.cost):
                 self.oracle.add_clause([s])
                 self.garbage.add(s)
 
@@ -1983,6 +2008,12 @@ if __name__ == '__main__':
         else:
             MXS = RC2
 
+        if process and to_enum != 1 and block != -1:
+            # no formula processing in case we enumerate multiple models or
+            # MSSes, as blocking them refers to variables it may eliminate
+            print('c formula processing is disabled for model enumeration')
+            process = 0
+
         # starting the solver
         with MXS(formula, solver=solver, adapt=adapt, exhaust=exhaust,
                 incr=incr, minz=minz, process=process, trim=trim,

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 9, 'dev', 19)
+VERSION = (1, 9, 'dev', 21)
 
 
 # PEP440 Format

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/pysat/process.py

@@ -23,7 +23,8 @@
     ==================
 
     This module provides access to the preprocessor functionality of `CaDiCaL
-    1.5.3 <https://github.com/arminbiere/cadical>`__. It can be used to
+    <https://github.com/arminbiere/cadical>`__, version 1.5.3 by default
+    (versions 1.9.5 and 3.0.0 can be selected instead). It can be used to
     process [1]_ (also see references therein) a given CNF formula and output
     a another formula, which is guaranteed to be *equisatisfiable* with the
     original formula. The processor can be invoked for a user-provided number
@@ -85,20 +86,30 @@
 #
 #==============================================================================
 from pysat.formula import CNF
-from pysat.solvers import Cadical153
+from pysat.solvers import Cadical153, Cadical195, Cadical300, NoSuchSolverError, SolverNames
 
 
 #
 #==============================================================================
 class Processor(object):
     """
-        This class provides interface to CaDiCaL's preprocessor. The only
-        input parameter is ``bootstrap_with``, which is expected to be a
-        :class:`.CNF` formula or a list (or iterable) of clauses.
+        This class provides interface to CaDiCaL's preprocessor. The input
+        parameters are ``bootstrap_with``, which is expected to be a
+        :class:`.CNF` formula or a list (or iterable) of clauses, and
+        ``engine``, which is the name of a CaDiCaL version to use, i.e. one of
+        the names of :class:`.Cadical153` (default), :class:`.Cadical195`, and
+        :class:`.Cadical300`. Note that preprocessing in CaDiCaL 1.9.5 should
+        not differ from that of CaDiCaL 1.5.3, as the two versions apply the
+        same techniques. In contrast, CaDiCaL 3.0.0 additionally applies
+        congruence closure, SAT sweeping, and binary clause backbone
+        computation.
 
         :param bootstrap_with: a list of clauses for processor initialization.
         :type bootstrap_with: :class:`.CNF` or iterable(iterable(int))
 
+        :param engine: name of the CaDiCaL version to use
+        :type engine: str
+
         Once created and used, a processor must be deleted with the
         :meth:`delete` method. Alternatively, if created using the ``with``
         statement, deletion is done automatically when the end of the ``with``
@@ -119,7 +130,7 @@ class Processor(object):
             >>> from pysat.process import Processor
             >>> from pysat.solvers import Solver
             >>>
-            >>> processor = Processor(bootstrap_with=[[-1, 2], [1, -2]])
+            >>> processor = Processor(bootstrap_with=[[-1, 2], [1, -2]], engine='cd195')
             >>> processor.append_formula([[-2, 3], [1]])
             >>> processor.add_clause([-3, 4])
             >>>
@@ -140,13 +151,23 @@ class Processor(object):
             >>> processor.delete()
     """
 
-    def __init__(self, bootstrap_with=None):
+    def __init__(self, bootstrap_with=None, engine='cd15'):
         """
             Basic constructor.
         """
 
+        self.cadical = None
+
         # immediately creating a CaDiCaL object
-        self.cadical = Cadical153()
+        engine_ = engine.lower()
+        if engine_ in SolverNames.cadical153:
+            self.cadical = Cadical153()
+        elif engine_ in SolverNames.cadical195:
+            self.cadical = Cadical195()
+        elif engine_ in SolverNames.cadical300:
+            self.cadical = Cadical300()
+        else:
+            raise(NoSuchSolverError(engine))
 
         # status of processor is True by default meaning
         # that the input formula *is not* unsatisfiable
@@ -219,14 +240,18 @@ class Processor(object):
         if self.cadical:
             self.cadical.append_formula(formula)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
-                decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+    def process(self, rounds=1, backbone=True, block=False, condition=False,
+                congruence=True, cover=False, decompose=True, elim=True,
+                probe=True, probehbr=True, subsume=True, sweep=True,
+                ternary=True, transred=True, vivify=True, freeze=[]):
         """
             Runs CaDiCaL's preprocessor for the internal formula for a given
             number of rounds and using the techniques specified in the
             arguments. Note that the default values of all the arguments used
-            are set as in the default configuration of CaDiCaL 1.5.3.
+            are set as in the default configuration of CaDiCaL 1.5.3 and
+            3.0.0. Arguments ``backbone``, ``congruence``, and ``sweep`` are
+            used by CaDiCaL 3.0.0 only, as the older versions do not support
+            these techniques.
 
             As the result, the method returns a :class:`.CNF` object
             containing the processed formula. Additionally to the clauses, the
@@ -241,7 +266,11 @@ class Processor(object):
             and covered clause elimination is invoked only if bounded variable
             elimination is active. Subsumption elimination in turn may trigger
             vivification and transitive reduction if the corresponding flags
-            are set.
+            are set. Also, in CaDiCaL 3.0.0, flag ``probe`` controls only
+            failed literal probing while the other techniques applied along
+            with probing are controlled by their own flags. Flag ``elim``
+            there controls both bounded variable elimination and its fast
+            variant applied at the beginning of preprocessing.
 
             Finally, note that the ``freeze`` argument can be used to keep
             some of the variables of the original formula unchanged during
@@ -251,15 +280,21 @@ class Processor(object):
             :param rounds: number of preprocessing rounds
             :type rounds: int
 
+            :param backbone: compute backbones of the binary clauses (CaDiCaL 3.0.0 only)
+            :type backbone: bool
+
             :param block: apply blocked clause elimination
             :type block: bool
 
-            :param cover: apply covered clause elimination
-            :type cover: bool
-
             :param condition: detect conditional autarkies and apply globally-blocked clause elimination
             :type condition: bool
 
+            :param congruence: detect AND, XOR, and ITE gates and merge equivalent gate outputs (CaDiCaL 3.0.0 only)
+            :type congruence: bool
+
+            :param cover: apply covered clause elimination
+            :type cover: bool
+
             :param decompose: detect strongly connected components (SCCs) in the binary implication graph (BIG) and apply equivalent literal substitution (ELS)
             :type decompose: bool
 
@@ -275,6 +310,15 @@ class Processor(object):
             :param subsume: apply global forward clause subsumption
             :type subsume: bool
 
+            :param sweep: apply SAT sweeping to detect equivalent literals and backbones (CaDiCaL 3.0.0 only)
+            :type sweep: bool
+
+            :param ternary: apply hyper ternary resolution
+            :type ternary: bool
+
+            :param transred: apply transitive reduction of the binary implication graph (BIG)
+            :type transred: bool
+
             :param vivify: apply clause vivification
             :type vivify: bool
 
@@ -304,11 +348,24 @@ class Processor(object):
         """
 
         if self.cadical:
-            self.status, result = self.cadical.process(rounds, block, cover,
-                                                       condition, decompose,
-                                                       elim, probe, probehbr,
-                                                       subsume, vivify,
-                                                       freeze)
+            # techniques unavailable in the older versions of CaDiCaL
+            extra = {}
+            if isinstance(self.cadical, Cadical300):
+                extra = dict(backbone=backbone, congruence=congruence,
+                             sweep=sweep)
+
+            self.status, result = self.cadical.process(rounds=rounds,
+                                                       block=block,
+                                                       condition=condition,
+                                                       cover=cover,
+                                                       decompose=decompose,
+                                                       elim=elim, probe=probe,
+                                                       probehbr=probehbr,
+                                                       subsume=subsume,
+                                                       ternary=ternary,
+                                                       transred=transred,
+                                                       vivify=vivify,
+                                                       freeze=freeze, **extra)
 
             # making the status Boolean
             self.status = False if self.status == 20 else True

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/pysat/solvers.py

@@ -1359,6 +1359,64 @@ class Solver(object):
         if self.solver:
             return self.solver.propagate(assumptions, phase_saving)
 
+    def flip_bits(self, assumptions=[], preferences=None, budget=100000):
+        """
+            Run a "bit flipper" a.k.a. local search (based on CaDiCaL's
+            ProbSAT-like walker) aiming at a model of the formula that
+            minimizes its *cost* with respect to a set of weighted literal
+            preferences, i.e. the sum of the weights of the preferred literals
+            falsified by the model. The method returns a pair of a model and
+            its cost, or ``(None, None)`` if no model is found.
+
+            Preferences are given as a dictionary mapping literals to their
+            non-negative integer weights (both polarities of a variable can
+            be preferred). The preferences are kept between the calls unless
+            new ones are provided. The search is limited by a ``budget``
+            given in CaDiCaL's local search *ticks* (a measure of memory
+            accesses).
+
+            **Note** that all the clauses removed by preprocessing (see
+            :meth:`Cadical300.process`) are restored by the method.
+
+            **Note** that only :class:`Cadical300` supports this
+            functionality, without external propagators (and so without
+            native cardinality constraints).
+
+            .. warning::
+
+                This prototype implementation has been written by an LLM. So
+                use at your own risk!
+
+            :param assumptions: a list of assumption literals.
+            :param preferences: weighted preferred literals.
+            :param budget: limit on the number of ticks.
+
+            :type assumptions: iterable(int)
+            :type preferences: dict(int, int)
+            :type budget: int
+
+            :rtype: tuple(list(int), int) or tuple(None, None).
+
+            Usage example:
+
+            .. code-block:: python
+
+                >>> from pysat.solvers import Solver
+                >>>
+                >>> with Solver(name='cd30', bootstrap_with=[[1, 2], [-1, -2]]) as s:
+                ...     print(s.solve())
+                ...     print(s.flip_bits(preferences={1: 5, 2: 3}))
+                ...
+                True
+                ([1, -2], 3)
+        """
+
+        if self.solver:
+            if isinstance(self.solver, Cadical300):
+                return self.solver.flip_bits(assumptions, preferences, budget)
+            else:
+                raise NotImplementedError('Local search is supported only by CaDiCaL 3.0.0')
+
     def apply_jw(self):
         """
             Recompute and apply JW scores to the current formula.
@@ -1416,9 +1474,7 @@ class Solver(object):
         """
 
         if self.solver:
-            if hard:
-                if not isinstance(self.solver, Ergo):
-                    raise NotImplementedError('Setting persistent phases is unsupported by this solver')
+            if hard and isinstance(self.solver, Ergo):
                 return self.solver.set_phases(literals, hard=True)
 
             return self.solver.set_phases(literals)
@@ -2365,9 +2421,10 @@ class Cadical153(object):
         if self.cadical:
             pysolvers.cadical153_dbudget(self.cadical, budget)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
+    def process(self, rounds=1, block=False, condition=False, cover=False,
                 decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+                subsume=True, ternary=True, transred=True, vivify=True,
+                freeze=[]):
         """
             Apply the preprocessor for the internal formula. See the
             documentation for the ``process`` module for details.
@@ -2379,7 +2436,8 @@ class Cadical153(object):
                                                 int(condition),
                                                 int(decompose), int(elim),
                                                 int(probe), int(probehbr),
-                                                int(subsume), int(vivify),
+                                                int(subsume), int(ternary),
+                                                int(transred), int(vivify),
                                                 freeze,
                                                 int(MainThread.check()))
 
@@ -2799,9 +2857,10 @@ class Cadical195(object):
         if self.cadical:
             pysolvers.cadical195_dbudget(self.cadical, budget)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
+    def process(self, rounds=1, block=False, condition=False, cover=False,
                 decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+                subsume=True, ternary=True, transred=True, vivify=True,
+                freeze=[]):
         """
             Apply the preprocessor for the internal formula. See the
             documentation for the ``process`` module for details.
@@ -2813,7 +2872,8 @@ class Cadical195(object):
                                                 int(condition),
                                                 int(decompose), int(elim),
                                                 int(probe), int(probehbr),
-                                                int(subsume), int(vivify),
+                                                int(subsume), int(ternary),
+                                                int(transred), int(vivify),
                                                 freeze,
                                                 int(MainThread.check()))
 
@@ -3373,6 +3433,31 @@ class Cadical300(object):
 
             return self.status
 
+    def flip_bits(self, assumptions=[], preferences=None, budget=100000):
+        """
+            Run local search guided by weighted literal preferences.
+        """
+
+        if self.cadical:
+            self.sync_vars()
+
+            if self.use_timer:
+                start_time = process_time()
+
+            res = pysolvers.cadical300_flipbits(self.cadical, assumptions,
+                    preferences, budget, int(MainThread.check()))
+
+            if self.use_timer:
+                self.call_time = process_time() - start_time
+                self.accu_time += self.call_time
+
+            # the solver is in the inconclusive state now
+            self.status = None
+            self.prev_assumps = assumptions
+            self.sync_vpool()
+
+            return res
+
     def conf_budget(self, budget):
         """
             Set limit on the number of conflicts.
@@ -3389,9 +3474,10 @@ class Cadical300(object):
         if self.cadical:
             pysolvers.cadical300_dbudget(self.cadical, budget)
 
-    def process(self, rounds=1, block=False, cover=False, condition=False,
-                decompose=True, elim=True, probe=True, probehbr=True,
-                subsume=True, vivify=True, freeze=[]):
+    def process(self, rounds=1, backbone=True, block=False, condition=False,
+                congruence=True, cover=False, decompose=True, elim=True,
+                probe=True, probehbr=True, subsume=True, sweep=True,
+                ternary=True, transred=True, vivify=True, freeze=[]):
         """
             Apply the preprocessor for the internal formula. See the
             documentation for the ``process`` module for details.
@@ -3401,12 +3487,14 @@ class Cadical300(object):
             self.sync_vars()
 
             result = pysolvers.cadical300_process(self.cadical, rounds,
-                                                  int(block), int(cover),
-                                                  int(condition),
+                                                  int(backbone), int(block),
+                                                  int(cover), int(condition),
+                                                  int(congruence),
                                                   int(decompose), int(elim),
                                                   int(probe), int(probehbr),
-                                                  int(subsume), int(vivify),
-                                                  freeze,
+                                                  int(subsume), int(sweep),
+                                                  int(ternary), int(transred),
+                                                  int(vivify), freeze,
                                                   int(MainThread.check()))
 
             self.sync_vpool()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev19
+Version: 1.9.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

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/python_sat.egg-info/SOURCES.txt

@@ -109,6 +109,7 @@ tests/test_empty_clause.py
 tests/test_empty_extclause.py
 tests/test_encode_pb_conditional.py
 tests/test_equals1.py
+tests/test_flip_bits.py
 tests/test_formula_parsing.py
 tests/test_formula_unique.py
 tests/test_hitman.py

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/solvers/patches/cadical153.patch

@@ -1873,20 +1873,20 @@ diff -Naur solvers/cadical153/solver.cpp solvers/cdc153/solver.cpp
 +
 +vector<bool> Solver::extend(vector<int>& solution)
 +{
-+  for (int i = 1; i <= solution.size(); i++) {
-+    if (internal->vals[i]) continue; //if already set
-+    int val = solution[i - 1];
-+    if (val > 0) {
-+      internal->vals[i] = 1;
-+      internal->vals[-i] = -1;
-+    }
-+    else {
-+      internal->vals[i] = -1;
-+      internal->vals[-i] = 1;
-+    }
++  vector<int> assigned; // values set here, to be undone after extension
++  for (int lit : solution) {
++    const int idx = abs(lit);
++    if (idx > external->max_var) continue; // unknown variable
++    const int ilit = external->e2i[idx];
++    if (!ilit || internal->vals[ilit]) continue; // unmapped or fixed
++    internal->vals[ilit] = lit > 0 ? 1 : -1;
++    internal->vals[-ilit] = -internal->vals[ilit];
++    assigned.push_back(ilit);
 +  }
 +  external->extend();
 +
++  for (int ilit : assigned)
++    internal->vals[ilit] = internal->vals[-ilit] = 0;
 +  return external->vals;
 +}
 +

{python_sat-1.9.dev19 → python_sat-1.9.dev21}/solvers/patches/cadical195.patch

@@ -2855,20 +2855,20 @@ diff -Naur solvers/cadical195/solver.cpp solvers/cdc195/solver.cpp
 +
 +vector<bool> Solver::extend(vector<int>& solution)
 +{
-+  for (int i = 1; i <= solution.size(); i++) {
-+    if (internal->vals[i]) continue; //if already set
-+    int val = solution[i - 1];
-+    if (val > 0) {
-+      internal->vals[i] = 1;
-+      internal->vals[-i] = -1;
-+    }
-+    else {
-+      internal->vals[i] = -1;
-+      internal->vals[-i] = 1;
-+    }
++  vector<int> assigned; // values set here, to be undone after extension
++  for (int lit : solution) {
++    const int idx = abs(lit);
++    if (idx > external->max_var) continue; // unknown variable
++    const int ilit = external->e2i[idx];
++    if (!ilit || internal->vals[ilit]) continue; // unmapped or fixed
++    internal->vals[ilit] = lit > 0 ? 1 : -1;
++    internal->vals[-ilit] = -internal->vals[ilit];
++    assigned.push_back(ilit);
 +  }
 +  external->extend();
 +
++  for (int ilit : assigned)
++    internal->vals[ilit] = internal->vals[-ilit] = 0;
 +  return external->vals;
 +}
 +