PySMT 0.9.7.dev452__tar.gz → 0.9.7.dev461__tar.gz

{pysmt-0.9.7.dev452/PySMT.egg-info → pysmt-0.9.7.dev461}/PKG-INFO

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

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461/PySMT.egg-info}/PKG-INFO

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

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

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/pysmt/exceptions.py

@@ -131,6 +131,16 @@ class PysmtImportError(PysmtException, ImportError):
 class PysmtValueError(PysmtException, ValueError):
     pass
 
+class PysmtEmptySymbolNameError(PysmtValueError):
+    """A symbol with the empty name was built, but they are not enabled."""
+
+    def __init__(self):
+        PysmtValueError.__init__(
+            self,
+            "The empty string is not a valid symbol name. SMT-LIB allows it "
+            "(as `||`), but not every solver does, so pySMT requires it to be "
+            "enabled explicitly by setting `env.allow_empty_var_names = True`.")
+
 class PysmtTypeError(PysmtException, TypeError):
     pass
 

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/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.dev452 → pysmt-0.9.7.dev461}/pysmt/formula.py

@@ -45,7 +45,8 @@ import pysmt.operators as op
 from pysmt.fnode import FNode
 from pysmt.typing import PySMTType
 from pysmt.fnode import FNode, FNodeContent
-from pysmt.exceptions import UndefinedSymbolError, PysmtValueError,PysmtTypeError
+from pysmt.exceptions import (UndefinedSymbolError, PysmtValueError,
+                             PysmtTypeError, PysmtEmptySymbolNameError)
 from pysmt.walkers.identitydag import IdentityDagWalker
 from pysmt.constants import Fraction, Numeral
 from pysmt.constants import (is_pysmt_fraction,
@@ -107,7 +108,7 @@ class FormulaManager(object):
 
     def _create_symbol(self, name: str, typename: PySMTType=types.BOOL) -> FNode:
         if len(name) == 0 and not self.env.allow_empty_var_names:
-            raise PysmtValueError("Empty string is not a valid name")
+            raise PysmtEmptySymbolNameError()
         if not isinstance(typename, types.PySMTType):
             raise PysmtValueError("typename must be a PySMTType.")
         n = self.create_node(node_type=op.SYMBOL,

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/pysmt/parsing.py

@@ -22,7 +22,8 @@ from typing import List, Optional
 import pysmt
 import pysmt.typing as types
 from pysmt.environment import get_env
-from pysmt.exceptions import PysmtSyntaxError, UndefinedSymbolError
+from pysmt.exceptions import (PysmtSyntaxError, UndefinedSymbolError,
+                             PysmtEmptySymbolNameError)
 from pysmt.constants import Fraction
 
 
@@ -332,6 +333,9 @@ class Constant(GrammarSymbol):
 class Identifier(GrammarSymbol):
     def __init__(self, name, env):
         GrammarSymbol.__init__(self)
+        if name == "" and not env.allow_empty_var_names:
+            # Otherwise this would be reported as an undefined symbol
+            raise PysmtEmptySymbolNameError()
         self.value = env.formula_manager.get_symbol(name)
         if self.value is None:
             raise UndefinedSymbolError(name)

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/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,
@@ -700,7 +730,7 @@ class MSatConverter(Converter, DagWalker):
                 val, width = map(int, str(term).split("_"))
                 res = self.mgr.BV(val, width)
         elif self._msat_lib.msat_term_is_constant(self.msat_env(), term):
-            rep = self._msat_lib.msat_term_repr(term)
+            rep = self._restore_empty(self._msat_lib.msat_term_repr(term))
             ty = self._msat_lib.msat_term_get_type(term)
             if self._msat_lib.msat_term_is_boolean_constant(self.msat_env(), term):
                 res = self.mgr.Symbol(rep, types.BOOL)
@@ -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:
@@ -1094,10 +1141,10 @@ class MSatConverter(Converter, DagWalker):
         if not var.is_symbol():
             raise PysmtTypeError("Trying to declare as a variable something "
                                  "that is not a symbol: %s" % var)
-        if var.symbol_name() not in self.symbol_to_decl:
+        if var not in self.symbol_to_decl:
             tp = self._type_to_msat(var.symbol_type())
             decl = self._msat_lib.msat_declare_function(self.msat_env(),
-                                                 var.symbol_name(),
+                                                 self._rename_empty(var.symbol_name()),
                                                  tp)
             if self._msat_lib.MSAT_ERROR_DECL(decl):
                 msat_msg = self._msat_lib.msat_last_error_message(self.msat_env())

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/pysmt/solvers/solver.py

@@ -16,6 +16,7 @@
 #   limitations under the License.
 #
 from fractions import Fraction
+import pysmt.formula
 from pysmt.typing import BOOL
 from pysmt.solvers.options import SolverOptions
 from pysmt.decorators import clear_pending_pop
@@ -566,3 +567,25 @@ class Converter(object):
     def back(self, expr: Any, *args: Any, **kwargs: Any) -> FNode:
         """Convert an expression of the Solver into a PySMT term."""
         raise NotImplementedError
+
+    # SMT-LIB allows a symbol with the empty name (`||`), but some
+    # solvers refuse to declare it (MathSAT) or cannot print it back
+    # (Z3). Those converters rename it to a fresh, unused name on the
+    # way in and undo the renaming on the way out.
+    _empty_name_subst: Optional[str] = None
+    mgr: 'pysmt.formula.FormulaManager'
+
+    def _rename_empty(self, name: str) -> str:
+        """Map a pySMT symbol name to the name used by the solver."""
+        if name != "":
+            return name
+        if self._empty_name_subst is None:
+            i = 0
+            while ("__pysmt_empty_name_%d" % i) in self.mgr.symbols:
+                i += 1
+            self._empty_name_subst = "__pysmt_empty_name_%d" % i
+        return self._empty_name_subst
+
+    def _restore_empty(self, name: str) -> str:
+        """Inverse of _rename_empty()."""
+        return "" if name == self._empty_name_subst else name

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/pysmt/solvers/z3.py

@@ -573,7 +573,7 @@ class Z3Converter(Converter, DagWalker):
             else:
                 # it must be a symbol
                 try:
-                    return self.mgr.get_symbol(str(expr))
+                    return self.mgr.get_symbol(self._restore_empty(str(expr)))
                 except UndefinedSymbolError:
                     import warnings
                     symb_type = self._z3_to_type(expr.sort())
@@ -582,7 +582,7 @@ class Z3Converter(Converter, DagWalker):
                                                 template="__z3_%d")
         elif z3.is_function(expr):
             # This needs to be after we try to convert regular Symbols
-            fsymbol = self.mgr.get_symbol(expr.decl().name())
+            fsymbol = self.mgr.get_symbol(self._restore_empty(expr.decl().name()))
             return self.mgr.Function(fsymbol, args)
 
         # If we reach this point, we did not manage to translate the expression
@@ -622,6 +622,11 @@ class Z3Converter(Converter, DagWalker):
                                              expr.ast)
         stream_in = StringIO(s)
         r = parser.get_script(stream_in).get_last_formula(self.mgr)
+        if self._empty_name_subst is not None:
+            # Undo the renaming of the empty symbol name (see Converter)
+            src = self.mgr.get_symbol(self._empty_name_subst)
+            r = self.env.substituter.substitute(
+                r, {src: self.mgr.Symbol("", src.symbol_type())})
         key = (askey(expr), None)
         self._back_memoization[key] = r
         return r
@@ -642,7 +647,7 @@ class Z3Converter(Converter, DagWalker):
 
     def walk_symbol(self, formula: FNode, **kwargs) -> z3.Ast:
         symbol_type = formula.symbol_type()
-        sname = formula.symbol_name()
+        sname = self._rename_empty(formula.symbol_name())
         z3_sname = z3.Z3_mk_string_symbol(self.ctx.ref(), sname)
         if symbol_type.is_bool_type():
             sort_ast = self.z3BoolSort.ast
@@ -756,7 +761,7 @@ class Z3Converter(Converter, DagWalker):
                 z3dom[i] = self._type_to_z3(t).ast
             z3ret = self._type_to_z3(tp.return_type).ast
             z3name = z3.Z3_mk_string_symbol(self.ctx.ref(),
-                                            func_name.symbol_name())
+                                            self._rename_empty(func_name.symbol_name()))
             z3func = z3.Z3_mk_func_decl(self.ctx.ref(), z3name,
                                         arity, z3dom, z3ret)
             self._z3_func_decl_cache[func_name] = z3func

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/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.dev452 → pysmt-0.9.7.dev461}/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.dev452 → pysmt-0.9.7.dev461}/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.dev452 → pysmt-0.9.7.dev461}/pysmt/test/test_regressions.py

@@ -29,11 +29,13 @@ from pysmt.test import (TestCase, skipIfSolverNotAvailable, skipIfNoSolverForLog
                         skipIfNoQEForLogic)
 from pysmt.test import main
 from pysmt.exceptions import (ConvertExpressionError, PysmtValueError,
-                              PysmtTypeError, InternalSolverError)
+                              PysmtTypeError, InternalSolverError,
+                              PysmtEmptySymbolNameError, UndefinedSymbolError)
 from pysmt.test.examples import get_example_formulae
 from pysmt.environment import Environment
 from pysmt.rewritings import cnf_as_set
 from pysmt.smtlib.parser import SmtLibParser
+from pysmt.parsing import parse as hr_parse
 from pysmt.smtlib.commands import DECLARE_FUN
 from pysmt.smtlib.script import SmtLibCommand
 from pysmt.logics import get_closer_smtlib_logic
@@ -270,6 +272,64 @@ class TestRegressions(TestCase):
     def test_empty_string_symbol(self):
         with self.assertRaises(PysmtValueError):
             Symbol("")
+        # SMT-LIB allows `||` as a symbol name (see #587), but pySMT
+        # requires the user to opt-in explicitly.
+        self.env.allow_empty_var_names = True
+        self.assertNotEqual(Symbol(""), Symbol(" "))
+
+    def test_empty_string_symbol_error_message(self):
+        # Parsing a symbol with the empty name must point at the option
+        # to enable, not fail with an unrelated message.
+        smtlib = """(set-logic QF_BV)
+        (declare-fun || () (_ BitVec 4))
+        (assert (= || || ))
+        (check-sat)"""
+        with self.assertRaises(PysmtEmptySymbolNameError) as ctx:
+            SmtLibParser().get_script(StringIO(smtlib))
+        self.assertIn("allow_empty_var_names", str(ctx.exception))
+        with self.assertRaises(PysmtEmptySymbolNameError):
+            hr_parse("'' & x")
+        # Once enabled, the empty name is just an undeclared symbol
+        self.env.allow_empty_var_names = True
+        with self.assertRaises(UndefinedSymbolError):
+            hr_parse("'' & x")
+        Symbol("")
+        self.assertEqual(hr_parse("''"), Symbol(""))
+
+    @skipIfNoSolverForLogic(logics.QF_BV)
+    def test_empty_string_symbol_in_solvers(self):
+        self.env.allow_empty_var_names = True
+        empty = Symbol("", BVType(8))
+        other = Symbol("other", BVType(8))
+        f = Not(Equals(empty, other))
+        for sname in self.env.factory.all_solvers(logic=logics.QF_BV):
+            with Solver(name=sname, logic=logics.QF_BV) as s:
+                s.add_assertion(f)
+                self.assertTrue(s.solve(), sname)
+                self.assertTrue(s.get_value(empty).is_bv_constant(), sname)
+                # Round-trip, but only for converters that can back-convert
+                # a regular symbol in the first place.
+                try:
+                    can_back = s.converter.back(s.converter.convert(other)) == other
+                except Exception:
+                    can_back = False
+                if can_back:
+                    self.assertEqual(s.converter.back(s.converter.convert(empty)),
+                                     empty, sname)
+
+    @skipIfNoSolverForLogic(logics.QF_BV)
+    def test_empty_string_symbol_smtlib(self):
+        # The benchmark reported in #587 declares `||` and `| |`.
+        self.env.allow_empty_var_names = True
+        txt = """(set-logic QF_BV)
+        (declare-fun || () (_ BitVec 4))
+        (declare-fun | | () (_ BitVec 4))
+        (assert (not (= || | |)))
+        (check-sat)"""
+        script = SmtLibParser().get_script(StringIO(txt))
+        self.assertEqual({s.symbol_name() for s in script.get_declared_symbols()},
+                         {"", " "})
+        self.assertSat(script.get_last_formula())
 
     def test_smtlib_info_quoting(self):
         cmd = SmtLibCommand(smtcmd.SET_INFO, [":source", "This\nis\nmultiline!"])

{pysmt-0.9.7.dev452 → pysmt-0.9.7.dev461}/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)