PySMT 0.9.7.dev474__tar.gz → 0.9.7.dev479__tar.gz

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

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

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

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

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

@@ -4,6 +4,13 @@ Change Log
 (unreleased)
 ------------
 
+* Fixed: MathSAT segfaulted in ``get_unsat_core()`` after solving under
+  a non-literal assumption, because reading the core popped the
+  assumption level and left MathSAT's core with dangling terms. Z3 did
+  not crash but reported an internal symbol in place of the assumption,
+  and raised on a second core request. Both now report the assumption
+  itself.
+
 * 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

{pysmt-0.9.7.dev474 → pysmt-0.9.7.dev479}/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", 474)
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 479)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{pysmt-0.9.7.dev474 → pysmt-0.9.7.dev479}/pysmt/smtlib/parser/parser.py

@@ -561,6 +561,10 @@ class SmtLibParser(object):
                 return res
             stack[-1].append(handler)
         else:
+            # pySMT binds one type per symbol name, but SMT-LIB model values
+            # reuse the same @name across sorts, so we qualify it with the sort
+            if what.startswith('@'):
+                what += "_" + str(ty)
             def handler():
                 return self.env.formula_manager.Symbol(what, ty)
             stack[-1].append(handler)

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

@@ -232,6 +232,7 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
         self.intType = self._msat_lib.msat_get_integer_type(self.msat_env())
         self.boolType = self._msat_lib.msat_get_bool_type(self.msat_env())
         self.mgr = environment.formula_manager
+        self._assumption_keys: Dict[FNode, FNode] = {}
 
     @clear_pending_pop
     def _reset_assertions(self):
@@ -269,7 +270,9 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
 
     def _named_assertions_map(self):
         if self.options.unsat_cores_mode == "named":
-            return dict((t[0], (t[1],t[2])) for t in self.assertions)
+            # not self.assertions: popping the assumptions level would
+            # invalidate the unsat core in MathSAT (dangling terms, segfault)
+            return dict((t[0], (t[1],t[2])) for t in self._assertion_stack)
         return None
 
     @clear_pending_pop
@@ -277,6 +280,8 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
         res = None
         bool_ass = []
         other_ass = []
+        # maps the fresh literal standing for each non-literal assumption to it
+        self._assumption_keys = {}
         for x in assumptions if assumptions is not None else []:
             if x.is_literal():
                 bool_ass.append(self.converter.convert(x))
@@ -284,8 +289,14 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
                 other_ass.append(x)
         if len(other_ass) > 0:
             self.push()
-            # this introduces new named assertions if named unsat cores.
-            self.add_assertion(self.mgr.And(other_ass))
+            for x in other_ass:
+                key = self.mgr.FreshSymbol(template="_assumption_%d")
+                self._assumption_keys[key] = x
+                term = self.converter.convert(self.mgr.Implies(key, x))
+                if self._msat_lib.msat_assert_formula(self.msat_env(), term) != 0:
+                    raise InternalSolverError(
+                        self._msat_lib.msat_last_error_message(self.msat_env()))
+                bool_ass.append(self.converter.convert(key))
 
         n_ass = self._named_assertions()
         if n_ass is not None and len(n_ass) > 0:
@@ -319,6 +330,9 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
                 raise InternalSolverError(
                     self._msat_lib.msat_last_error_message(self.msat_env()))
             res = set(self.converter.back(t) for t in terms)
+            # drop the Implies(key, x) encoding of non-literal assumptions
+            res = set(f for f in res
+                      if not f.get_free_variables() & self._assumption_keys.keys())
             return res | self._unsat_assumptions()
         else:
             return set(self.get_named_unsat_core().values()) | \
@@ -334,7 +348,7 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
         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
+        return set(self._assumption_keys.get(f, f) for f in res)
 
     def get_named_unsat_core(self):
         """After a call to solve() yielding UNSAT, returns the unsat core as a

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

@@ -177,6 +177,7 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
         self.mgr = environment.formula_manager
 
         self._name_cnt = 0
+        self._assumption_keys: Dict[FNode, FNode] = {}
         return
 
     @clear_pending_pop
@@ -218,9 +219,15 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
                 else:
                     other_ass.append(x)
 
+            # maps the fresh literal standing for each non-literal assumption to it
+            self._assumption_keys = {}
             if len(other_ass) > 0:
                 self.push()
-                self.add_assertion(self.mgr.And(other_ass))
+                for x in other_ass:
+                    key = self.mgr.FreshSymbol(template="_assumption_%d")
+                    self._assumption_keys[key] = x
+                    self.z3.add(self.converter.convert(self.mgr.Implies(key, x)))
+                    bool_ass.append(self.converter.convert(key))
                 self.pending_pop = True
             res = self.z3.check(*bool_ass)
         else:
@@ -240,7 +247,8 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
 
     def _named_assertions_map(self):
         if self.options.unsat_cores_mode is not None:
-            return dict((t[0], (t[1],t[2])) for t in self.assertions)
+            # not self.assertions: that would pop the assumptions level
+            return dict((t[0], (t[1],t[2])) for t in self._assertion_stack)
         return None
 
     def get_named_unsat_core(self):
@@ -279,7 +287,7 @@ class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolver):
                     cnt += 1
                 res[name] = formula
             else:
-                core_assumptions.add(key)
+                core_assumptions.add(self._assumption_keys.get(key, key))
         return res, core_assumptions
 
     @clear_pending_pop

{pysmt-0.9.7.dev474 → pysmt-0.9.7.dev479}/pysmt/test/smtlib/test_model_validation.py

@@ -97,6 +97,29 @@ class TestModelValidation(TestCase):
         simp = simplifier.simplify(formula.substitute(model, interpretations))
         self.assertEqual(simp, self.fm.TRUE())
 
+    def test_same_value_name_different_sorts(self):
+        # SMT-COMP/postprocessors#10: solvers reuse @0 across sorts
+        model_source ="""\
+(model
+  (define-fun a () U (as @0 U))
+  (define-fun c () U (as @1 U))
+  (define-fun b () V (as @0 V))
+  (define-fun d () V (as @0 V))
+)
+"""
+        U = self.tm.Type('U', 0)
+        V = self.tm.Type('V', 0)
+        a = self.fm.Symbol('a', U)
+        b = self.fm.Symbol('b', V)
+        c = self.fm.Symbol('c', U)
+        d = self.fm.Symbol('d', V)
+        formula = self.fm.And(self.fm.Not(self.fm.Equals(a, c)),
+                              self.fm.Equals(b, d))
+
+        model, interpretations = SmtLibParser().parse_model(StringIO(model_source))
+        simp = SmtLibModelValidationSimplifier(self.env).simplify(
+            formula.substitute(model, interpretations))
+        self.assertEqual(simp, self.fm.TRUE())
 
 
 if __name__ == '__main__':

{pysmt-0.9.7.dev474 → pysmt-0.9.7.dev479}/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, get_env)
+                             Solver, is_unsat, Int, GT, GE, LE, get_env)
 from pysmt.typing import INT
 from pysmt.logics import QF_BOOL, QF_BV, QF_LIA
 from pysmt.exceptions import (SolverStatusError, SolverReturnedUnknownResultError,
@@ -214,6 +214,25 @@ class TestUnsatCores(TestCase):
                                          {"n1": Or(x, y)}, name)
 
 
+    @skipIfNoUnsatCoreSolverForLogic(QF_LIA)
+    def test_non_literal_assumptions_in_unsat_core(self):
+        a = Symbol("a", INT)
+        pos, neg = GE(a, Int(1)), LE(a, Int(0))
+        for name in get_env().factory.all_unsat_core_solvers(logic=QF_LIA):
+            for mode in ["all", "named"]:
+                with UnsatCoreSolver(name=name, logic=QF_LIA,
+                                     unsat_cores_mode=mode) as s:
+                    s.add_assertion(pos, named="pos")
+                    self.assertFalse(s.solve([neg]))
+                    # twice: reading the core must not pop the assumptions level
+                    for _ in range(2):
+                        self.assertEqual(s.get_unsat_core(), {pos, neg},
+                                         (name, mode))
+                        if mode == "named":
+                            self.assertEqual(s.get_named_unsat_core(),
+                                             {"pos": pos}, (name, mode))
+
+
     @skipIfNoUnsatCoreSolverForLogic(QF_BOOL)
     def test_assumptions_as_iterator(self):
         x, y = Symbol("x"), Symbol("y")