PySMT 0.9.7.dev452__py2.py3-none-any.whl → 0.9.7.dev461__py2.py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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)

{pysmt-0.9.7.dev452.dist-info → pysmt-0.9.7.dev461.dist-info}/METADATA

@@ -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.dist-info → pysmt-0.9.7.dev461.dist-info}/RECORD

@@ -1,17 +1,17 @@
-pysmt/__init__.py,sha256=H1RSyIhE62I8bMHuJMFdulWPhnFnfJ5WhtMApT7Oz-8,1701
+pysmt/__init__.py,sha256=1SGEofFHRCjIIaHxwnnUVpx8VGc6I0LMZN90e5E-Pxs,1701
 pysmt/__main__.py,sha256=rR-MV1QtLYqtVoJyY3m5B5Iz-lua0-5o6YSB0W4lKy8,1085
 pysmt/configuration.py,sha256=Iq_46QZ9z_jpBMk76euJWTqGEwHad2qyiEDPix5sXsA,4538
 pysmt/constants.py,sha256=pulb6NvROY_X8BePeyyX8T9MJLB79HZ_1FUYSlZ7Jfg,5769
 pysmt/decorators.py,sha256=dZWnu0lwfVBq6WGoohH5EWVpi6xr-uAEtFBjDUJgnoo,4106
 pysmt/environment.py,sha256=UUcccuTIGRYdIxvso4aUvfwJiveoDdOwRgTcVHkuupc,7056
-pysmt/exceptions.py,sha256=l7JmvC9VML32HeZwIhgxf5L-NQjbbpX4aHCdO9d56nM,5637
-pysmt/factory.py,sha256=E0ykatmufugzsOUG5hBPVatuudQ1u5WXlLy8ziKAbdc,31899
+pysmt/exceptions.py,sha256=tnehun1YLztMNF91aQ49z4I1tGAkdRaUHDrPRl8g0DM,6080
+pysmt/factory.py,sha256=nBe8oMy04KPeoOFJexQ1YJS7GQcEIiyg373U-P5jmnk,32575
 pysmt/fnode.py,sha256=5K0z8Qy3jIbB4N-lyBESXyzDpBDPD92jryNNd50NdLk,36453
-pysmt/formula.py,sha256=gUqv0V91Tww9GVeOD2Z_gsZlthUe8NADd0ZbYmK2CEk,50770
+pysmt/formula.py,sha256=uaV9fenYpQBpg4RHJunJLghzx3rEDDyyQj3pQnwLfzE,50805
 pysmt/logics.py,sha256=HQaq2Odqw8oFNCAo1av0zaFOcPujTopO8frWSBsmNtg,29348
 pysmt/operators.py,sha256=XGPPoX5bdDsroAkr5rUAiBdi7BXkPaOyst7jEWqLTa0,8329
 pysmt/oracles.py,sha256=20IQ-YPo5dBMloZxKuS7tvrx4whFF3ZsRdds_iaegck,21769
-pysmt/parsing.py,sha256=De_KXONvh07EmxkiPxpY7Nx-jNuh-Uov6EL7IQeDTRo,21114
+pysmt/parsing.py,sha256=sZc-rj--F6oM6_gmIDXSrBWwwAt0rAeRV7zGAjCx57o,21345
 pysmt/printers.py,sha256=fB2aPwsV7qQxgtqgVndUA_1wWBp5vMPzqBxngmBJmk4,15099
 pysmt/rewritings.py,sha256=wv1E-YMC0az_pY8KLd2mpDifwLdp7Q_Zh-lE5I8RmEU,42413
 pysmt/shortcuts.py,sha256=Xiq5JnkjefgwuJAEbmMAjnkyqu35MoALnSp2NYtIeDg,44962
@@ -59,17 +59,17 @@ pysmt/solvers/cvcfour.py,sha256=W8Afm8J7co87Vwt4L80kIoNaPcA3eBLwEnwAw5CcoHg,2579
 pysmt/solvers/dynmsat.py,sha256=bJokwHoxKWmQGqw9nQerRDb33d5c66Sa91jUYiZXwY0,2124
 pysmt/solvers/eager.py,sha256=E2wWhRVWe6sVxW2YOwPDhZ8O53uKNuPKwLIvsRsWFPA,3681
 pysmt/solvers/interpolation.py,sha256=6AO1wMkEKSkptuC4aXlNEO8Be1K2oW3W_er2XGc_aEA,2066
-pysmt/solvers/msat.py,sha256=feT1NYkc6cSCvKVtKIk_fPmo_mOIpyKWCrJEMQS9G4s,60568
+pysmt/solvers/msat.py,sha256=YPAEGVf8lTr8fb9x9Ig6O6_wERcIIzpvGUjjVFjIjGw,63669
 pysmt/solvers/options.py,sha256=DRNUMb5Tlhai4keQkF7Kg34tf3AGbBUd45mqzjsS69c,4036
 pysmt/solvers/pico.py,sha256=y31QT7ZQVMeKjXc7g4DZrpc1LTzbhCLyE0zyOLd-BsE,10680
 pysmt/solvers/portfolio.py,sha256=GFKR2S8FoANzZJWUkYVqWEJG7sw04RYgSnwaKJNWuUs,10092
 pysmt/solvers/qelim.py,sha256=iEQ9PE9IPFA6dxqSMHFp3aIyDCTiZyIlSAduh0txrAg,5451
 pysmt/solvers/smtlib.py,sha256=daJkKBtTMHLIoQt77dhT8Qh8P6eFBO9mF4C6tialtBc,9924
-pysmt/solvers/solver.py,sha256=AqmWoDPKLpjpb0RlyUS-qYGCqPRetZKbiTIT-usczjA,19467
+pysmt/solvers/solver.py,sha256=M-0wQ3Cz0GsV_wzhcogjGE3ACtPDEm6qocUt599-6fM,20404
 pysmt/solvers/yices.py,sha256=uG08Q9iqctXk-2rDP6H5OO88FE_ml83K0k5j8irpbcg,25910
-pysmt/solvers/z3.py,sha256=IOy2jqpdvY9uGKl7W1ehN-ZEHPS4CfIVYYhNbSOBZqw,44642
+pysmt/solvers/z3.py,sha256=eXRSvwTE3LT0skoNTToFHEyvsUGdHvsJwLE4SLX-BEQ,45021
 pysmt/test/__init__.py,sha256=LEFbVYw4X45sgEI4_ax55g-6G5Y7kj6CLaJr1TQr4ks,5750
-pysmt/test/examples.py,sha256=6yWa-hHEMJuo5GEbjWmzg509-LQxVAyr26lxGhcK_jU,40756
+pysmt/test/examples.py,sha256=fogqgP2qEpvaOswVFYRr4Q8o6TKoCLPW9460SL9HVvo,40756
 pysmt/test/omt_examples.py,sha256=LdL43fLaHiR72Cng_2st4UaYf2ueoZgStcvhccy-RdI,10338
 pysmt/test/optimization_utils.py,sha256=zbj2bN-3uMaNexF7DSjuQAR0889IcMsCiE__tGtR6zM,15665
 pysmt/test/test_array.py,sha256=-7R_L0d0MMuemdv0AtqNR2y8rX_w4Xc0NiaDKD4H_lY,7163
@@ -83,7 +83,7 @@ pysmt/test/test_constants.py,sha256=vdjjtAOw5oQg57Bl5tllslnVWBHuRq3Zk33F1xDsBtA,
 pysmt/test/test_cvc_quantifiers.py,sha256=a40NDyPKNynVpqq9M5pDTR8qFL_EumR8whw8escxP4I,1850
 pysmt/test/test_dwf.py,sha256=nQubO2IYjW3NnRjNz3xkhpXgK_5coZp9uZ_U-ElmFRw,2850
 pysmt/test/test_eager_model.py,sha256=hF9V8wQYXVeyW2Bo4sACa98xeJtfOMYjMvjWMHQaGag,3662
-pysmt/test/test_env.py,sha256=EZ5DbAK7OXwuoiNMz4naaz5MFYUk-fK0_OKknO-YG70,8166
+pysmt/test/test_env.py,sha256=g98aqMU2dlPW2hQmWy8DxCLfm06upMic5mU91MGX_PQ,8758
 pysmt/test/test_euf.py,sha256=B0VRx1NwfKZZIG5Fc6gYPj7G6gNWMzYJvgbh-2q2E28,3455
 pysmt/test/test_formula.py,sha256=nd550r7dBRHvoNKedCCdKfmV0WD4oMfjZekfAtk7GSg,40493
 pysmt/test/test_hr_parsing.py,sha256=bi-iTu7y1C7diMcWsQ7EI40MipDbzTKbMGPnLWX85A8,3118
@@ -95,19 +95,19 @@ pysmt/test/test_logics.py,sha256=bWwE_7rq9SVcXglE-ugteGeCHXAYFiBdi-QgIL9-9KE,689
 pysmt/test/test_models.py,sha256=npqGoF-3DgAw0DTx6se32ZEZRFBJDcnkppzgyjLDbps,2748
 pysmt/test/test_native_qe.py,sha256=RGZgwbpAkPBTjIqcCbOkZ_nQXIDZ4Fznrr7Ldx6oA38,3439
 pysmt/test/test_nia.py,sha256=x51d0X5jnZnxTPvPLrlD0WilunZ5uNrDU4vWY78_xpU,6640
-pysmt/test/test_nlira.py,sha256=_E1HeOarw4TN8AI1X7EQv-utjhwy8hJX3vx-05eHJk0,4969
+pysmt/test/test_nlira.py,sha256=RNG90qzQ_XUI9bazoiBUhSt1N7QKcjlzHm3bqraMDj4,5129
 pysmt/test/test_optimization.py,sha256=xU0gJbD2SSn5_lA7wF7IKcR54KF6NU0g-2_dDEqXmqA,24358
 pysmt/test/test_optimizing.py,sha256=P-XnTPEPoEp5LvvZfZoiZziI4z3d_FfL7lFcEuI07bE,1512
 pysmt/test/test_oracles.py,sha256=cHBPTUoi9cPmIvR-DG4bbzohOaBdUJzpKLoQXImxS_c,5615
 pysmt/test/test_portfolio.py,sha256=MIlXPyvBHxXnV5V-4PQ1WTTwVIgrR_CUvq-PYUajaiM,7685
 pysmt/test/test_printing.py,sha256=MwxLcmpwN0DYLlqGNrOZM4U1RPdTM1k75_IMKWQFLts,9064
 pysmt/test/test_qe.py,sha256=k8zYX-lcij0ua9yuRXl7wErUklEgLSEh68QDpV8J9xs,7157
-pysmt/test/test_regressions.py,sha256=Wuah55f5rROEkhTho_zl-uwaMDzc4LPeP3lfQ6nzS8k,21977
+pysmt/test/test_regressions.py,sha256=Mmxf86E9L0MTXJYBYwEqYGuQMCLYKFl2ZK4XQJCJH0A,24810
 pysmt/test/test_rewritings.py,sha256=1eeseDwZyQD2VrOFBABXHTYJFJOXszP4olbCNeLcwfA,15607
 pysmt/test/test_shannon_expansion.py,sha256=yaiZuB24wj1Zi-KdzRTmWuzAVaF9bQ603uto7zi6XBs,3082
 pysmt/test/test_simplify.py,sha256=ckQn_DUxVvGspaRNZmSPHkudhpUlG5K2w6C0wDqhL1w,7620
 pysmt/test/test_size.py,sha256=p3aqCMHfBiGLxvF0P8hE-PRQTT8VMPIJCjblq8Txh1w,3261
-pysmt/test/test_solving.py,sha256=sB9Nz7pTg-MjInl3MKo4rCPDLwxti3Yp1QanwxLZ4As,25637
+pysmt/test/test_solving.py,sha256=pf5ZitNQrVAT2VSn-ZstHNromomL6OxPKBJMdyZzdLk,25588
 pysmt/test/test_sorts.py,sha256=erfInyPH91WVB8JBUYLteTo5X5skKKP3vEXdUUKC-YE,6033
 pysmt/test/test_string.py,sha256=Y6VBfkLNKuePo8-HIzcwBH3eaYj0i-k1Y8tpFyw03zw,8096
 pysmt/test/test_typechecker.py,sha256=S2O8HjN_bLN6sz86TnsWqpRtxHk2VcVsGDoRZCcQnzE,7309
@@ -143,10 +143,10 @@ pysmt/walkers/dag.py,sha256=4CWSgoXm6nONhM-1znKRU4SBCb791OTS-M9QlQFhbs8,5751
 pysmt/walkers/generic.py,sha256=dmp47kJGtO6rhC2t07Mf_FsYN-lcy64LX-dZggNnWm4,5179
 pysmt/walkers/identitydag.py,sha256=EAxSneEW91Z8GphlkbMPsPdlac7_FDcVj-_6_aunU2s,10902
 pysmt/walkers/tree.py,sha256=8oyDSXZtUsCdExcrwG3hKuEgARHgdW6fvz0LZJwjp-k,2983
-pysmt-0.9.7.dev452.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-pysmt-0.9.7.dev452.dist-info/licenses/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
-pysmt-0.9.7.dev452.dist-info/METADATA,sha256=7YalyJRjNuUsu3qa8tLhqU498-dd5f4EfE8o_bPpV7w,1774
-pysmt-0.9.7.dev452.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
-pysmt-0.9.7.dev452.dist-info/entry_points.txt,sha256=gDc1XM0xTJJMDGC_nXd0kfbX-Omjke9Dn9F3awMLYIU,57
-pysmt-0.9.7.dev452.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
-pysmt-0.9.7.dev452.dist-info/RECORD,,
+pysmt-0.9.7.dev461.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pysmt-0.9.7.dev461.dist-info/licenses/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
+pysmt-0.9.7.dev461.dist-info/METADATA,sha256=Ec5wIiEr0YFjWydmtI3-BiX-bmpqOH4lmloOZ28ci_k,1774
+pysmt-0.9.7.dev461.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
+pysmt-0.9.7.dev461.dist-info/entry_points.txt,sha256=gDc1XM0xTJJMDGC_nXd0kfbX-Omjke9Dn9F3awMLYIU,57
+pysmt-0.9.7.dev461.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
+pysmt-0.9.7.dev461.dist-info/RECORD,,