PySMT 0.9.7.dev446__tar.gz → 0.9.7.dev457__tar.gz

{pysmt-0.9.7.dev446/PySMT.egg-info → pysmt-0.9.7.dev457}/PKG-INFO

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

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457/PySMT.egg-info}/PKG-INFO

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

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/README.rst

@@ -232,25 +232,25 @@ Solvers Support
 The following table summarizes the features supported via pySMT for
 each of the available solvers.
 
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | Solver           | pySMT name|  Supported Theories            | Quantifiers | Quantifier Elimination | Unsat Core | Interpolation|
- +==================+===========+================================+=============+========================+============+==============+
- | MathSAT          |  msat     | UF, LIA, LRA, BV, AX           |  No         | msat-fm, msat-lw       | Yes        | Yes          |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | Z3               |  z3       | UF, LIA, LRA, BV, AX, NRA, NIA |  Yes        | z3                     | Yes        | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | cvc5             |  cvc5     | UF, LIA, LRA, BV, AX, S        |  Yes        | No                     | No         | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | Yices            |  yices    | UF, LIA, LRA, BV               |  No         | No                     | No         | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | Boolector        |  btor     | UF, BV, AX                     |  No         | No                     | No         | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | SMT-Lib Interface|  <custom> | UF, LIA, LRA, BV, AX           |  Yes        | No                     | No         | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | PicoSAT          |  picosat  | [None]                         |  No         | [No]                   | No         | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
- | BDD (CUDD)       |  bdd      | [None]                         |  Yes        | bdd                    | No         | No           |
- +------------------+-----------+--------------------------------+-------------+------------------------+------------+--------------+
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | Solver           | pySMT name|  Supported Theories               | Quantifiers | Quantifier Elimination | Unsat Core | Interpolation|
+ +==================+===========+===================================+=============+========================+============+==============+
+ | MathSAT          |  msat     | UF, LIA, LRA, BV, AX, NRA, NIA    |  No         | msat-fm, msat-lw       | Yes        | Yes          |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | Z3               |  z3       | UF, LIA, LRA, BV, AX, NRA, NIA    |  Yes        | z3                     | Yes        | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | cvc5             |  cvc5     | UF, LIA, LRA, BV, AX, S, NRA, NIA |  Yes        | No                     | No         | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | Yices            |  yices    | UF, LIA, LRA, BV                  |  No         | No                     | No         | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | Boolector        |  btor     | UF, BV, AX                        |  No         | No                     | No         | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | SMT-Lib Interface|  <custom> | UF, LIA, LRA, BV, AX              |  Yes        | No                     | No         | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | PicoSAT          |  picosat  | [None]                            |  No         | [No]                   | No         | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
+ | BDD (CUDD)       |  bdd      | [None]                            |  Yes        | bdd                    | No         | No           |
+ +------------------+-----------+-----------------------------------+-------------+------------------------+------------+--------------+
 
 
 

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

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/factory.py

@@ -190,13 +190,15 @@ class Factory(object):
 
         if logic is None:
             logic = default_logic
+        assert isinstance(logic, Logic)
 
         solvers = self._filter_solvers(solver_list, logic=logic)
 
         if solvers is not None and len(solvers) > 0:
             # Pick the first solver based on preference list
             preference_list = self.preferences[solver_type]
-            SolverClass = self._pick_favorite(preference_list, solver_list, solvers)
+            SolverClass = self._pick_favorite(preference_list, solver_list,
+                                              solvers, logic)
             closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
             return SolverClass, closer_logic
 
@@ -205,7 +207,16 @@ class Factory(object):
                                          (solver_type, logic))
 
 
-    def _pick_favorite(self, preference_list: List[str], solver_list: Dict[str, Any], solvers: Dict[str, Any]) -> Type[Solver]:
+    def _pick_favorite(self, preference_list: List[str], solver_list: Dict[str, Any],
+                       solvers: Dict[str, Any], logic: Logic) -> Type[Solver]:
+        if not logic.theory.linear:
+            # The MathSAT family solves nonlinear problems by incremental
+            # linearization, which may not terminate on satisfiable instances
+            # whose solutions are all irrational (see the note on
+            # MathSAT5Solver.LOGICS). Prefer any other capable solver, but keep
+            # them as a fallback when nothing else supports the logic.
+            preference_list = sorted(preference_list,
+                                     key=lambda n: n.startswith(("msat", "optimsat")))
         for candidate in preference_list:
             if candidate in solvers:
                 return solver_list[candidate]

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/solvers/msat.py

@@ -35,7 +35,7 @@ from pysmt.utils import assert_not_none
 from pysmt.walkers import DagWalker
 from pysmt.exceptions import (SolverReturnedUnknownResultError,
                               InternalSolverError,
-                              NonLinearError, PysmtValueError, PysmtTypeError,
+                              PysmtValueError, PysmtTypeError,
                               ConvertExpressionError)
 from pysmt.decorators import clear_pending_pop, catch_conversion_error
 from pysmt.solvers.qelim import QuantifierEliminator
@@ -180,9 +180,37 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
 
     __lib_name__ = "mathsat"
 
+    # NOTE on nonlinear arithmetic (QF_NRA/QF_NIA, and OptiMathSAT, which
+    # inherits this LOGICS set).
+    #
+    # MathSAT solves nonlinear problems by incremental linearization: the
+    # nonlinear terms are abstracted away as free symbols and then
+    # progressively constrained with linear lemmas, until either the
+    # abstraction is refuted (UNSAT) or a model of the abstraction happens to
+    # be a model of the original formula (SAT). Every model MathSAT can build
+    # therefore assigns *rational* values only; irrational (algebraic) values
+    # are not representable.
+    #
+    # This is fine for UNSAT instances and for SAT instances that admit a
+    # rational solution, but not for SAT instances whose solutions are all
+    # irrational: on e.g. `x * x = 2` no finite set of linear lemmas refutes
+    # the abstraction, and no model of the abstraction ever satisfies the
+    # original constraint, so the refinement loop does not terminate. MathSAT
+    # diverges rather than returning `unknown`, and there is currently no
+    # option to bound the number of refinement rounds. The only available
+    # mitigation is a soft timeout installed with `msat_set_termination_test`,
+    # which pySMT does not expose, and which could only be wall-clock based
+    # (hence non-reproducible), since the internal statistics that would give a
+    # deterministic budget cannot be retrieved through the API.
+    # See the discussion in https://github.com/pysmt/pysmt/pull/844.
+    #
+    # Practical consequences:
+    #  - formulas that need algebraic witnesses must be sent to a solver with a
+    #    complete NRA decision procedure (z3, cvc5);
+    #  - the nonlinear examples and tests run against MathSAT are kept
+    #    rational on purpose (e.g. `r * r = 4.0` instead of `r * r = 2.0`).
     LOGICS: Iterable[Logic] = PYSMT_QF_LOGICS -\
-             set(l for l in PYSMT_QF_LOGICS \
-                 if not l.theory.linear or l.theory.strings)
+             set(l for l in PYSMT_QF_LOGICS if l.theory.strings)
 
     OptionsClass = MathSATOptions
 
@@ -407,6 +435,7 @@ class MSatConverter(Converter, DagWalker):
             self._msat_lib.MSAT_TAG_LEQ: self._back_adapter(self.mgr.LE),
             self._msat_lib.MSAT_TAG_PLUS: self._back_adapter(self.mgr.Plus),
             self._msat_lib.MSAT_TAG_TIMES: self._back_adapter(self.mgr.Times),
+            self._msat_lib.MSAT_TAG_DIVIDE: self._back_adapter(self.mgr.Div),
             self._msat_lib.MSAT_TAG_BV_MUL: self._back_adapter(self.mgr.BVMul),
             self._msat_lib.MSAT_TAG_BV_ADD: self._back_adapter(self.mgr.BVAdd),
             self._msat_lib.MSAT_TAG_BV_UDIV: self._back_adapter(self.mgr.BVUDiv),
@@ -463,6 +492,7 @@ class MSatConverter(Converter, DagWalker):
             self._msat_lib.MSAT_TAG_LEQ: self._sig_most_generic_bool_binary,
             self._msat_lib.MSAT_TAG_PLUS:  self._sig_most_generic_bool_binary,
             self._msat_lib.MSAT_TAG_TIMES: self._sig_most_generic_bool_binary,
+            self._msat_lib.MSAT_TAG_DIVIDE: self._sig_most_generic_bool_binary,
             self._msat_lib.MSAT_TAG_FLOOR: lambda term, args:\
                 self.tm.FunctionType(types.INT, [types.REAL]),
             self._msat_lib.MSAT_TAG_BV_MUL: self._sig_binary,
@@ -987,16 +1017,33 @@ class MSatConverter(Converter, DagWalker):
 
     def walk_times(self, formula: FNode, args: List[Any], **kwargs) -> Any:
         res = args[0]
-        nl_count = 0 if self._msat_lib.msat_term_is_number(self.msat_env(), res) else 1
         for x in args[1:]:
-            if not self._msat_lib.msat_term_is_number(self.msat_env(), x):
-                nl_count += 1
-            if nl_count >= 2:
-                raise NonLinearError(formula)
-            else:
-                res = self._msat_lib.msat_make_times(self.msat_env(), res, x)
+            res = self._msat_lib.msat_make_times(self.msat_env(), res, x)
         return res
 
+    def walk_pow(self, formula: FNode, args: List[Any], **kwargs) -> Any:
+        # MathSAT rejects exponents it cannot handle by returning an error
+        # term, which convert() turns into an InternalSolverError.
+        return self._msat_lib.msat_make_pow(self.msat_env(), args[0], args[1])
+
+    def walk_div(self, formula: FNode, args: List[Any], **kwargs) -> Any:
+        num, den = args
+        if self.env.stc.get_type(formula).is_real_type():
+            return self._msat_lib.msat_make_divide(self.msat_env(), num, den)
+        # msat_make_divide is real division, while pySMT follows the SMT-LIB
+        # semantics for integers: den >= 0 ? floor(num/den) : ceil(num/den).
+        # ceil(a) is rewritten as -floor(-a).
+        zero = self._msat_lib.msat_make_number(self.msat_env(), "0")
+        neg = self._msat_lib.msat_make_number(self.msat_env(), "-1")
+        cond = self._msat_lib.msat_make_leq(self.msat_env(), zero, den)
+        div = self._msat_lib.msat_make_floor(self.msat_env(),
+                  self._msat_lib.msat_make_divide(self.msat_env(), num, den))
+        n_den = self._msat_lib.msat_make_times(self.msat_env(), neg, den)
+        n_div = self._msat_lib.msat_make_times(self.msat_env(), neg,
+                    self._msat_lib.msat_make_floor(self.msat_env(),
+                        self._msat_lib.msat_make_divide(self.msat_env(), num, n_den)))
+        return self._msat_lib.msat_make_term_ite(self.msat_env(), cond, div, n_div)
+
     def walk_function(self, formula: FNode, args: List[Any], **kwargs) -> Any:
         name = formula.function_name()
         if name not in self.symbol_to_decl:

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/solvers/portfolio.py

@@ -232,7 +232,13 @@ def _run_solver(idx, solver, logic, options, formula, signaling_queue, ctrl_pipe
     """
     from pysmt.environment import get_env
 
-    Solver = get_env().factory.Solver
+    env = get_env()
+    # The formula is pickled across the process boundary, so its FNodes
+    # belong to no FormulaManager here (this is always the case with the
+    # 'spawn'/'forkserver' start methods). Contextualize it in our own env.
+    formula = env.formula_manager.normalize(formula)
+
+    Solver = env.factory.Solver
     with Solver(name=solver, logic=logic, **options) as s:
         s.add_assertion(formula)
         try:
@@ -258,7 +264,7 @@ def _run_solver(idx, solver, logic, options, formula, signaling_queue, ctrl_pipe
                 model = list(s.get_model())
                 ctrl_pipe.send(model)
             elif cmd == "get_value":
-                args = get_env().formula_manager.normalize(args)
+                args = env.formula_manager.normalize(args)
                 ctrl_pipe.send(s.get_value(args))
             else:
                 raise ValueError("Unknown command '%s'" % cmd)

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/test/examples.py

@@ -925,8 +925,8 @@ def get_full_example_formulae(environment: Optional[Environment]=None) -> List[E
                     logic=pysmt.logics.QF_NRA
                 ),
 
-            Example(hr="(2.0 = (r * r))",
-                    expr=Equals(Real(2), Times(r,r)),
+            Example(hr="(4.0 = (r * r))",
+                    expr=Equals(Real(4), Times(r,r)),
                     is_valid=False,
                     is_sat=True,
                     logic=pysmt.logics.QF_NRA
@@ -946,8 +946,8 @@ def get_full_example_formulae(environment: Optional[Environment]=None) -> List[E
                     logic=pysmt.logics.QF_NRA
                 ),
 
-            Example(hr="((r * r * r) = 25.0)",
-                    expr=Equals(Times(r, r, r), Real(25)),
+            Example(hr="((r * r * r) = 27.0)",
+                    expr=Equals(Times(r, r, r), Real(27)),
                     is_valid=False,
                     is_sat=True,
                     logic=pysmt.logics.QF_NRA

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/test/test_env.py

@@ -203,5 +203,17 @@ class TestEnvironment(TestCase):
             factory.get_quantifier_eliminator()
 
 
+    def test_nonlinear_demotes_mathsat(self):
+        # The MathSAT family is the last resort on nonlinear logics, but still
+        # picked when it is the only capable solver.
+        pick = get_env().factory._pick_favorite
+        available = {'msat': 'MSAT', 'z3': 'Z3'}
+        prefs = ['msat', 'z3']
+        self.assertEqual(pick(prefs, available, available, logics.QF_NRA), 'Z3')
+        self.assertEqual(pick(prefs, available, available, logics.QF_LRA), 'MSAT')
+        only_msat = {'msat': 'MSAT'}
+        self.assertEqual(pick(prefs, only_msat, only_msat, logics.QF_NRA), 'MSAT')
+
+
 if __name__ == '__main__':
     main()

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/test/test_nlira.py

@@ -24,33 +24,33 @@ from pysmt.shortcuts import FreshSymbol, Times, Equals, Div, Real, Int, Pow
 from pysmt.shortcuts import Solver, Symbol, And, Not, is_sat
 from pysmt.typing import REAL, INT
 from pysmt.exceptions import (ConvertExpressionError,
-                              NonLinearError, InternalSolverError,
+                              NonLinearError,
                               SolverReturnedUnknownResultError)
-from pysmt.logics import QF_NRA
+from pysmt.logics import QF_NRA, QF_NIA
 from pysmt.constants import Fraction
 
 
 class TestNonLinear(TestCase):
 
-    @skipIfSolverNotAvailable("z3")
     def test_times(self):
         x = FreshSymbol(REAL)
         f = Equals(Times(x, x), x)
-        with Solver(name="z3") as s:
-            self.assertTrue(s.is_sat(f))
+        for sname in self.env.factory.all_solvers(logic=QF_NRA):
+            with Solver(name=sname, logic=QF_NRA) as s:
+                self.assertTrue(s.is_sat(f), sname)
 
-    @skipIfSolverNotAvailable("z3")
     def test_div(self):
         x = FreshSymbol(REAL)
         f = Equals(Div(x, x), x)
-        with Solver(name="z3") as s:
-            self.assertTrue(s.is_sat(f))
+        for sname in self.env.factory.all_solvers(logic=QF_NRA):
+            with Solver(name=sname, logic=QF_NRA) as s:
+                self.assertTrue(s.is_sat(f), sname)
 
     @skipIfSolverNotAvailable("z3")
     def test_irrational(self):
         x = FreshSymbol(REAL)
         f = Equals(Times(x, x), Real(2))
-        with Solver(name="z3") as s:
+        with Solver(name="z3", logic=QF_NRA) as s:
             self.assertTrue(s.is_sat(f))
             model = s.get_model()
             xval = model[x]
@@ -73,38 +73,34 @@ class TestNonLinear(TestCase):
 
     def test_unknownresult(self):
         x = FreshSymbol(REAL)
-        f = Equals(Times(x, x), Real(2))
+        # 4.0 rather than 2.0: the point here is which solvers reject
+        # nonlinear arithmetic, not who can represent an algebraic number.
+        f = Equals(Times(x, x), Real(4))
         for sname in self.env.factory.all_solvers():
-            with Solver(name=sname) as s:
-                if sname in ["bdd", "picosat", "btor"]:
+            if sname in ["bdd", "picosat", "btor"]:
+                with Solver(name=sname) as s:
                     with self.assertRaises(ConvertExpressionError):
                         s.is_sat(f)
-                elif sname in ["yices", "cvc4", "msat", "optimsat"]:
+            elif sname in ["yices", "cvc4"]:
+                with Solver(name=sname) as s:
                     with self.assertRaises(NonLinearError):
                         s.is_sat(f)
-                elif sname in ["cvc5"]:
-                    with self.assertRaises(InternalSolverError):
-                        s.is_sat(f)
-                else:
-                    res = s.is_sat(f)
-                    self.assertTrue(res, sname)
+            else:
+                with Solver(name=sname, logic=QF_NRA) as s:
+                    self.assertTrue(s.is_sat(f), sname)
                     self.assertIn(QF_NRA, s.LOGICS, sname)
 
-    @skipIfSolverNotAvailable("z3")
     def test_integer(self):
         x = FreshSymbol(INT)
-        f = Equals(Times(x, x), Int(2))
-        with Solver(name="z3") as s:
-            self.assertFalse(s.is_sat(f))
-
-        # f = Equals(Times(Int(4), Pow(x, Int(-1))), Int(2))
-        # self.assertTrue(is_sat(f, solver_name="z3"))
-
-        # f = Equals(Div(Int(4), x), Int(2))
-        # self.assertTrue(is_sat(f, solver_name="z3"))
-
-        f = Equals(Times(x, x), Int(16))
-        self.assertTrue(is_sat(f, solver_name="z3"))
+        f1 = Equals(Times(x, x), Int(2))
+        f2 = Equals(Times(x, x), Int(16))
+        for sname in self.env.factory.all_solvers(logic=QF_NIA):
+            for f, expected in ((f1, False), (f2, True)):
+                with Solver(name=sname, logic=QF_NIA) as s:
+                    try:
+                        self.assertEqual(expected, s.is_sat(f), (sname, f))
+                    except SolverReturnedUnknownResultError:
+                        pass
 
     @skipIfSolverNotAvailable("z3")
     def test_div_pow(self):

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/test/test_portfolio.py

@@ -25,11 +25,26 @@ from pysmt.solvers.portfolio import Portfolio
 from pysmt.smtlib.parser import get_formula_fname
 from pysmt.shortcuts import TRUE, Implies, Equals, Symbol, FALSE
 from pysmt.shortcuts import reset_env, is_sat
-from pysmt.typing import REAL
+from pysmt.typing import REAL, BOOL
 
 
 class PortfolioTestCase(TestCase):
 
+    @skipIfSolverNotAvailable("z3")
+    def test_basic_z3(self):
+        mgr = self.env.formula_manager
+        x = mgr.Symbol('x', BOOL)
+        y = mgr.Symbol('y', BOOL)
+        formula = mgr.And(x, y)
+        with Portfolio(["z3"],
+                       environment=self.env,
+                       logic=QF_LRA) as solver:
+            res = solver.is_sat(formula)
+            self.assertTrue(res)
+            model = solver.get_model()
+            formula_val_term = model.get_value(formula)
+            self.assertTrue(formula_val_term.is_true())
+
     @skipIfSolverNotAvailable("z3")
     @skipIfSolverNotAvailable("msat")
     @skipIfSolverNotAvailable("cvc5")

{pysmt-0.9.7.dev446 → pysmt-0.9.7.dev457}/pysmt/test/test_solving.py

@@ -198,7 +198,6 @@ class TestBasic(TestCase):
     def test_examples_msat(self):
         for (f, validity, satisfiability, logic) in get_example_formulae():
             if not logic.quantifier_free: continue
-            if not logic.theory.linear: continue
             if logic.theory.strings: continue
 
             v = is_valid(f, solver_name='msat', logic=logic)