PySMT 0.9.7.dev468__tar.gz → 0.9.7.dev474__tar.gz

{pysmt-0.9.7.dev468/PySMT.egg-info → pysmt-0.9.7.dev474}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev468
+Version: 0.9.7.dev474
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474/PySMT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev468
+Version: 0.9.7.dev474
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/README.rst

@@ -243,7 +243,7 @@ each of the available solvers.
  +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
  | Yices            |  yices    | UF, LIA, LRA, BV                  |  No         | No                     | No         | No           |
  +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
- | Boolector        |  btor     | UF, BV, AX                        |  No         | No                     | No         | No           |
+ | Boolector        |  btor     | UF, BV, AX                        |  No         | No                     | Yes        | No           |
  +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
  | SMT-Lib Interface|  <custom> | UF, LIA, LRA, BV, AX              |  Yes        | No                     | No         | No           |
  +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/docs/CHANGES.rst

@@ -1,6 +1,29 @@
 Change Log
 ==========
 
+(unreleased)
+------------
+
+* Fixed: The assumptions passed to ``solve()`` were missing from the
+  unsat core. ``get_unsat_core()`` now reports them alongside the
+  assertions, in both the "all" and the "named" unsat cores mode
+  (PR #680).
+
+  Assumptions carry no name, so they are *not* reported by
+  ``get_named_unsat_core()``, which keeps returning only the
+  assertions added via ``add_assertion(..., named=...)``.
+
+* Fixed: Boolector's ``get_unsat_core`` and ``get_named_unsat_core``
+  raised ``BoolectorException: 'exp' must be an assumption`` when
+  solving under assumptions, and ``get_named_unsat_core`` could pair a
+  name with the wrong assertion (PR #680).
+
+* Fixed: Boolector dropped the assumptions passed to ``solve()`` when
+  they were given as an iterator rather than as a list (PR #680).
+
+* Docs: README listed Boolector as not supporting unsat cores; it does.
+
+
 0.9.6: 2022-06-24 -- CVC5 and upgraded solvers
 ----------------------------------------------
 

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/__init__.py

@@ -19,7 +19,7 @@
 from typing import Tuple, Union
 
 
-VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 468)
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 474)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/shortcuts.py

@@ -1113,6 +1113,11 @@ def get_unsat_core(clauses: Iterable[FNode], solver_name: Optional[str]=None, lo
     """Similar to :py:func:`get_model` but returns the unsat core of the
     conjunction of the input clauses
 
+    Every clause is asserted separately, so the returned core is a
+    subset of ``clauses``. This function takes no assumptions; to get a
+    core under assumptions, call :py:func:`Solver.solve` with them and
+    then :py:func:`UnsatCoreSolver.get_unsat_core`.
+
     :param clauses: Specify the list of input clauses
     :param solver_name: Specify the name of the solver_name
     :param logic: Specify the logic that is going to be used

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/solvers/btor.py

@@ -209,6 +209,9 @@ class BoolectorSolver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSol
         self.mgr = environment.formula_manager
         self.declarations = {}
         self._named_assertions = {}
+        self._assumptions = []
+        self._core = []
+        self._core_assumptions = []
         return
 
 # EOC BoolectorOptions
@@ -246,17 +249,34 @@ class BoolectorSolver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSol
             assignment[s] = self.get_value(s)
         return EagerModel(assignment=assignment, environment=self.environment)
 
+    def _failed(self, formulae):
+        """Returns the formulae of the given list that are in the unsat core.
+
+        Only valid immediately after an UNSAT Sat() call: Boolector
+        drops this information as soon as new assumptions are made.
+        """
+        if len(formulae) == 0:
+            return []
+        terms = [self.converter.convert(f) for f in formulae]
+        return [f for f, failed in zip(formulae, self.btor.Failed(*terms)) if failed]
+
     @clear_pending_pop
     def _solve(self, assumptions=None):
-        if assumptions is not None:
-            btor_assumptions = [self.converter.convert(a) for a in assumptions]
-            self.btor.Assume(*btor_assumptions)
+        # materialized because assumptions can be a one-shot iterator
+        self._assumptions = [] if assumptions is None else list(assumptions)
+        if len(self._assumptions) > 0:
+            self.btor.Assume(*(self.converter.convert(a)
+                               for a in self._assumptions))
 
         res = self.btor.Sat()
 
-        # need to re-add assumptions if in unsat-core mode
-        # which uses Assume instead of Assert
         if self.options.unsat_cores_mode is not None:
+            if res == self.btor.UNSAT:
+                # must be extracted before the re-assertion below invalidates it
+                self._core = self._failed(self._assertion_stack)
+                self._core_assumptions = self._failed(self._assumptions)
+            # need to re-add assumptions if in unsat-core mode
+            # which uses Assume instead of Assert
             for a in self._assertion_stack:
                 self._add_assertion(a)
 
@@ -273,18 +293,10 @@ class BoolectorSolver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSol
         self._check_unsat_core_config()
 
         if self.options.unsat_cores_mode == 'all':
-            unsat_core = set()
-            # relies on this assertion stack being ordered
-            assert isinstance(self._assertion_stack, list)
-            btor_assertions = [self.converter.convert(
-                a) for a in self._assertion_stack]
-            in_unsat_core = self.btor.Failed(*btor_assertions)
-            for a, in_core in zip(self._assertion_stack, in_unsat_core):
-                if in_core:
-                    unsat_core.add(a)
-            return unsat_core
+            return set(self._core) | set(self._core_assumptions)
         else:
-            return set(self.get_named_unsat_core().values())
+            return set(self.get_named_unsat_core().values()) | \
+                set(self._core_assumptions)
 
     def get_named_unsat_core(self) -> Dict[str, FNode]:
         """After a call to solve() yielding UNSAT, returns the unsat core as a
@@ -292,17 +304,10 @@ class BoolectorSolver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSol
         self._check_unsat_core_config()
 
         if self.options.unsat_cores_mode == "named":
-            unsat_core = {}
-            # relies on this assertion stack being ordered
-            assert isinstance(self._assertion_stack, list)
-            btor_named_assertions = [self.converter.convert(
-                a) for a in self._named_assertions.keys()]
-            in_unsat_core = self.btor.Failed(*btor_named_assertions)
-            for a, in_core in zip(self._assertion_stack, in_unsat_core):
-                if in_core:
-                    name = self._named_assertions[a]
-                    unsat_core[name] = a
-            return unsat_core
+            # solve-time assumptions have no name, they are reported by
+            # get_unsat_core() only
+            return dict((self._named_assertions[a], a) for a in self._core
+                        if a in self._named_assertions)
         else:
             return dict(("_a%d" % i, f)
                         for i, f in enumerate(self.get_unsat_core()))

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/solvers/msat.py

@@ -314,14 +314,27 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
         set of formulae"""
         self._check_unsat_core_config()
         if self.options.unsat_cores_mode == "all":
-
             terms = self._msat_lib.msat_get_unsat_core(self.msat_env())
             if terms is None:
                 raise InternalSolverError(
                     self._msat_lib.msat_last_error_message(self.msat_env()))
-            return set(self.converter.back(t) for t in terms)
+            res = set(self.converter.back(t) for t in terms)
+            return res | self._unsat_assumptions()
         else:
-            return set(self.get_named_unsat_core().values())
+            return set(self.get_named_unsat_core().values()) | \
+                self._unsat_assumptions()
+
+    def _unsat_assumptions(self):
+        """Returns the solve-time assumptions occurring in the last unsat core."""
+        terms = self._msat_lib.msat_get_unsat_assumptions(self.msat_env())
+        if not terms:
+            return set()
+        res = set(self.converter.back(t) for t in terms)
+        n_ass_map = self._named_assertions_map()
+        if n_ass_map is not None:
+            # in named mode the named assertions are passed as assumptions too
+            res -= set(n_ass_map)
+        return res
 
     def get_named_unsat_core(self):
         """After a call to solve() yielding UNSAT, returns the unsat core as a
@@ -341,6 +354,8 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
                         name = "_a_%d" % cnt
                         cnt += 1
                     res[name] = formula
+                # solve-time assumptions have no name, they are reported by
+                # get_unsat_core() only
             return res
 
         else:

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/solvers/options.py

@@ -48,7 +48,15 @@ class SolverOptions(object):
       Enable incremental interface (push, pop)
 
     * unsat_cores_mode: None, "named", "all"
-      Enable UNSAT core extraction using "named" or "all" strategy.
+      Enable UNSAT core extraction. With "all", every assertion is a
+      candidate for the core; get_named_unsat_core() still works, but
+      the names it returns are generated ones with no meaning to the
+      caller. With "named", the core is restricted to the assertions
+      added with a name (see Solver.add_assertion), and
+      get_named_unsat_core() reports them under those names. In both
+      modes the assumptions passed to solve() are reported by
+      get_unsat_core(). None (the default) disables core extraction
+      altogether.
 
     * random_seed: None, integer
       Sets the random seed for the solver

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/solvers/solver.py

@@ -68,6 +68,13 @@ class Solver(object):
 
         but is in general more efficient.
 
+        The two differ in how they report unsat cores: assumptions are
+        reported individually by
+        :py:func:`UnsatCoreSolver.get_unsat_core`, whereas the encoding
+        above contributes the single conjunction ``And(a1, ..., an)``.
+        Assumptions carry no name and therefore never appear in
+        :py:func:`UnsatCoreSolver.get_named_unsat_core`.
+
         Other convenience methods (is_sat, is_unsat, is_valid) are
         wrappers around this function.
 
@@ -203,7 +210,18 @@ class Solver(object):
         raise NotImplementedError
 
     def add_assertion(self, formula: FNode, named: Optional[str]=None):
-        """Add assertion to the solver."""
+        """Add assertion to the solver.
+
+        The optional ``named`` argument labels the assertion, so that
+        :py:func:`UnsatCoreSolver.get_named_unsat_core` reports it under
+        that name. The label is honored only if the solver was created
+        with the ``unsat_cores_mode="named"`` option; with the other
+        modes some solvers keep it and others replace it with a
+        generated name, so do not rely on it.
+
+        :param formula: The Boolean formula to assert
+        :param named: The name to label this assertion with, if any
+        """
         raise NotImplementedError
 
     def add_assertions(self, formulae: Iterable[FNode]):
@@ -415,7 +433,16 @@ class UnsatCoreSolver(Solver):
         """Returns the unsat core as a set of formulae.
 
         After a call to solve() yielding UNSAT, returns the unsat core
-        as a set of formulae
+        as a set of formulae.
+
+        The core contains the assertions that caused the
+        unsatisfiability, together with the assumptions passed to the
+        failing :py:func:`Solver.solve` call, if any. Both are reported
+        in either unsat cores mode. In ``"named"`` mode only named
+        assertions are considered, so the core is made of the named
+        assertions and of the assumptions.
+
+        :returns: The unsat core, as a set of formulae
         """
         raise NotImplementedError
 
@@ -423,7 +450,14 @@ class UnsatCoreSolver(Solver):
         """Returns the unsat core as a dict of names to formulae.
 
         After a call to solve() yielding UNSAT, returns the unsat core as a
-        dict of names to formulae
+        dict of names to formulae.
+
+        Only assertions added with a ``named`` argument can be reported
+        here. Assumptions passed to :py:func:`Solver.solve` carry no
+        name and are therefore omitted: use
+        :py:func:`get_unsat_core` to obtain them.
+
+        :returns: The unsat core, as a map from assertion name to formula
         """
         raise NotImplementedError
 

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/solvers/z3.py

@@ -235,7 +235,8 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
     def get_unsat_core(self):
         """After a call to solve() yielding UNSAT, returns the unsat core as a
         set of formulae"""
-        return set(self.get_named_unsat_core().values())
+        named, assumptions = self._unsat_core()
+        return set(named.values()) | assumptions
 
     def _named_assertions_map(self):
         if self.options.unsat_cores_mode is not None:
@@ -245,6 +246,12 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
     def get_named_unsat_core(self):
         """After a call to solve() yielding UNSAT, returns the unsat core as a
         dict of names to formulae"""
+        # solve-time assumptions have no name, they are reported by
+        # get_unsat_core() only
+        return self._unsat_core()[0]
+
+    def _unsat_core(self):
+        """Splits the last unsat core into named assertions and assumptions."""
         if self.options.unsat_cores_mode is None:
             raise SolverNotConfiguredForUnsatCoresError
 
@@ -261,6 +268,7 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
         pysmt_assumptions = set(self.converter.back(t) for t in assumptions)
 
         res = {}
+        core_assumptions = set()
         n_ass_map = self._named_assertions_map()
         cnt = 0
         for key in pysmt_assumptions:
@@ -270,7 +278,9 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
                     name = "_a_%d" % cnt
                     cnt += 1
                 res[name] = formula
-        return res
+            else:
+                core_assumptions.add(key)
+        return res, core_assumptions
 
     @clear_pending_pop
     def all_sat(self, important, callback):

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/test/test_rewritings.py

@@ -166,7 +166,7 @@ class TestRewritings(TestCase):
         for (f, _, _, logic) in get_example_formulae():
             if not logic.is_quantified() and logic.theory.uninterpreted:
                 if self.env.factory.has_solvers(logic=logic):
-                    self._verify_ackermannization(f)
+                    self._verify_ackermannization(f, logic)
 
     def test_ackermannization_dictionaries(self):
         self.env.enable_infix_notation = True
@@ -192,7 +192,7 @@ class TestRewritings(TestCase):
             if atom.is_function_application():
                 self.assertIsNotNone(terms_to_consts[atom])
 
-    def _verify_ackermannization(self, formula):
+    def _verify_ackermannization(self, formula, logic=None):
         ackermannization = Ackermannizer()
         ack = ackermannization.do_ackermannization(formula)
         #verify that there are no functions in ack
@@ -201,8 +201,8 @@ class TestRewritings(TestCase):
             for arg in atom.args():
                 self.assertFalse(arg.is_function_application())
         #verify that ack and formula are equisat
-        formula_sat = is_sat(formula)
-        ack_sat = is_sat(ack)
+        formula_sat = is_sat(formula, logic=logic)
+        ack_sat = is_sat(ack, logic=logic)
         self.assertTrue(formula_sat == ack_sat)
 
     def test_nnf_examples(self):

{pysmt-0.9.7.dev468 → pysmt-0.9.7.dev474}/pysmt/test/test_unsat_cores.py

@@ -18,7 +18,7 @@
 from pysmt.test import (TestCase, skipIfSolverNotAvailable,
                         skipIfNoUnsatCoreSolverForLogic, main)
 from pysmt.shortcuts import (get_unsat_core, And, Or, Not, Symbol, UnsatCoreSolver,
-                             Solver, is_unsat, Int, GT)
+                             Solver, is_unsat, Int, GT, get_env)
 from pysmt.typing import INT
 from pysmt.logics import QF_BOOL, QF_BV, QF_LIA
 from pysmt.exceptions import (SolverStatusError, SolverReturnedUnknownResultError,
@@ -185,5 +185,44 @@ class TestUnsatCores(TestCase):
                 s.get_unsat_core()
 
 
+    @skipIfNoUnsatCoreSolverForLogic(QF_BOOL)
+    def test_assumptions(self):
+        x = Symbol("x")
+        with UnsatCoreSolver(logic=QF_BOOL) as s:
+            check = s.solve([x, Not(x)])
+            self.assertFalse(check)
+            core = s.get_unsat_core()
+            self.assertEqual(len(core), 2)
+
+
+    @skipIfNoUnsatCoreSolverForLogic(QF_BOOL)
+    def test_assumptions_in_unsat_core(self):
+        x, y = Symbol("x"), Symbol("y")
+        for name in get_env().factory.all_unsat_core_solvers(logic=QF_BOOL):
+            for mode in ["all", "named"]:
+                with UnsatCoreSolver(name=name, logic=QF_BOOL,
+                                     unsat_cores_mode=mode) as s:
+                    s.add_assertion(Or(x, y), named="n1")
+                    self.assertFalse(s.solve([Not(x), Not(y)]))
+                    core = s.get_unsat_core()
+                    self.assertEqual(len(core), 3, (name, mode))
+                    self.assertIn(Not(x), core, (name, mode))
+                    self.assertIn(Not(y), core, (name, mode))
+                    if mode == "named":
+                        # assumptions carry no name: they stay out of this core
+                        self.assertEqual(s.get_named_unsat_core(),
+                                         {"n1": Or(x, y)}, name)
+
+
+    @skipIfNoUnsatCoreSolverForLogic(QF_BOOL)
+    def test_assumptions_as_iterator(self):
+        x, y = Symbol("x"), Symbol("y")
+        for name in get_env().factory.all_unsat_core_solvers(logic=QF_BOOL):
+            with UnsatCoreSolver(name=name, logic=QF_BOOL) as s:
+                s.add_assertion(Or(x, y))
+                self.assertFalse(s.solve(a for a in [Not(x), Not(y)]))
+                self.assertEqual(len(s.get_unsat_core()), 3, name)
+
+
 if __name__ == '__main__':
     main()