PySMT 0.9.7.dev452__py2.py3-none-any.whl → 0.9.7.dev457__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", 457)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

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/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/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_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.dev457.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev452
+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.dev452.dist-info → pysmt-0.9.7.dev457.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pysmt/__init__.py,sha256=H1RSyIhE62I8bMHuJMFdulWPhnFnfJ5WhtMApT7Oz-8,1701
+pysmt/__init__.py,sha256=Z7If4KtAgb7FCsVxqvzdXiL1R6lGp3Z4clNET3RgY3c,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/factory.py,sha256=nBe8oMy04KPeoOFJexQ1YJS7GQcEIiyg373U-P5jmnk,32575
 pysmt/fnode.py,sha256=5K0z8Qy3jIbB4N-lyBESXyzDpBDPD92jryNNd50NdLk,36453
 pysmt/formula.py,sha256=gUqv0V91Tww9GVeOD2Z_gsZlthUe8NADd0ZbYmK2CEk,50770
 pysmt/logics.py,sha256=HQaq2Odqw8oFNCAo1av0zaFOcPujTopO8frWSBsmNtg,29348
@@ -59,7 +59,7 @@ 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=4awRHpIym8pgxoHlbb9y3zUeLuAsOxhE2HQ39B4OY34,63642
 pysmt/solvers/options.py,sha256=DRNUMb5Tlhai4keQkF7Kg34tf3AGbBUd45mqzjsS69c,4036
 pysmt/solvers/pico.py,sha256=y31QT7ZQVMeKjXc7g4DZrpc1LTzbhCLyE0zyOLd-BsE,10680
 pysmt/solvers/portfolio.py,sha256=GFKR2S8FoANzZJWUkYVqWEJG7sw04RYgSnwaKJNWuUs,10092
@@ -69,7 +69,7 @@ pysmt/solvers/solver.py,sha256=AqmWoDPKLpjpb0RlyUS-qYGCqPRetZKbiTIT-usczjA,19467
 pysmt/solvers/yices.py,sha256=uG08Q9iqctXk-2rDP6H5OO88FE_ml83K0k5j8irpbcg,25910
 pysmt/solvers/z3.py,sha256=IOy2jqpdvY9uGKl7W1ehN-ZEHPS4CfIVYYhNbSOBZqw,44642
 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,7 +95,7 @@ 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
@@ -107,7 +107,7 @@ pysmt/test/test_rewritings.py,sha256=1eeseDwZyQD2VrOFBABXHTYJFJOXszP4olbCNeLcwfA
 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.dev457.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pysmt-0.9.7.dev457.dist-info/licenses/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
+pysmt-0.9.7.dev457.dist-info/METADATA,sha256=pLdugCvQziKFZDtfMfIGU30l51IOnPuE3xrpLyx_ycM,1774
+pysmt-0.9.7.dev457.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
+pysmt-0.9.7.dev457.dist-info/entry_points.txt,sha256=gDc1XM0xTJJMDGC_nXd0kfbX-Omjke9Dn9F3awMLYIU,57
+pysmt-0.9.7.dev457.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
+pysmt-0.9.7.dev457.dist-info/RECORD,,