PySMT 0.9.7.dev431__py2.py3-none-any.whl → 0.9.7.dev433__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", 431)
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 433)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

pysmt/fnode.py

@@ -29,7 +29,7 @@ from pysmt.operators import (FORALL, EXISTS, AND, OR, NOT, IMPLIES, IFF,
                              PLUS, MINUS, TIMES, DIV,
                              LE, LT, EQUALS,
                              ITE,
-                             TOREAL,
+                             TOREAL, TOINT,
                              BV_CONSTANT, BV_NOT, BV_AND, BV_OR, BV_XOR,
                              BV_CONCAT, BV_EXTRACT,
                              BV_ULT, BV_ULE, BV_NEG, BV_ADD, BV_SUB,
@@ -256,6 +256,10 @@ class FNode(object):
         """Test whether the node is the ToReal operator."""
         return self.node_type() == TOREAL
 
+    def is_toint(self) -> bool:
+        """Test whether the node is the ToInt operator."""
+        return self.node_type() == TOINT
+
     def is_forall(self) -> bool:
         """Test whether the node is the ForAll operator."""
         return self.node_type() == FORALL

pysmt/formula.py

@@ -493,6 +493,44 @@ class FormulaManager(object):
             raise PysmtTypeError("Argument is of type %s, but INT was "
                                  "expected!\n" % t)
 
+    def ToInt(self, formula: FNode) -> FNode:
+        """ Cast a formula to integer type.
+
+        This is the SMT-LIB to_int function, i.e. the floor: it rounds
+        towards minus infinity, hence ToInt(-3/2) is -2 and not -1.
+        """
+        t = self.env.stc.get_type(formula)
+        if t == types.INT:
+            # Ignore casting of an Int
+            return formula
+        elif t == types.REAL:
+            if formula.is_real_constant():
+                value = cast(fractions.Fraction, formula.constant_value())
+                # Floor division on the numerator/denominator, so that this
+                # also works for the gmpy2 mpq backend (see pysmt.constants)
+                return self.Int(value.numerator // value.denominator)
+            return self.create_node(node_type=op.TOINT,
+                                    args=(formula,))
+        else:
+            raise PysmtTypeError("Argument is of type %s, but REAL was "
+                                 "expected!\n" % t)
+
+    def IsInt(self, formula: FNode) -> FNode:
+        """ Returns whether the given real formula has an integer value.
+
+        This is the SMT-LIB is_int predicate, expanded into its SMT-LIB
+        definition: (is_int t) is (= t (to_real (to_int t))).
+        """
+        t = self.env.stc.get_type(formula)
+        if t == types.INT:
+            # An Int is always an integer
+            return self.TRUE()
+        elif t == types.REAL:
+            return self.Equals(formula, self.ToReal(self.ToInt(formula)))
+        else:
+            raise PysmtTypeError("Argument is of type %s, but REAL was "
+                                 "expected!\n" % t)
+
     def AtMostOne(self, *args: Union[FNode, Iterable[FNode]]) -> FNode:
         """ At most one of the bool expressions can be true at anytime.
 

pysmt/operators.py

@@ -25,7 +25,7 @@ from itertools import chain
 from typing import List
 
 
-ALL_TYPES = list(range(0,66))
+ALL_TYPES = list(range(0,67))
 
 (
 FORALL, EXISTS, AND, OR, NOT, IMPLIES, IFF, # Boolean Logic (0-6)
@@ -79,6 +79,7 @@ DIV,                                        # Arithmetic Division (62)
 POW,                                        # Arithmetic Power (63)
 ALGEBRAIC_CONSTANT,                         # Algebraic Number (64)
 BV_TONATURAL,                               # BV to Natural Conversion (65)
+TOINT,                                      # LIRA to_int() function, i.e. floor (66)
 ) = ALL_TYPES
 
 QUANTIFIERS = frozenset([FORALL, EXISTS])
@@ -110,7 +111,8 @@ BV_OPERATORS = frozenset([BV_NOT, BV_AND, BV_OR, BV_XOR,
 STR_OPERATORS = frozenset([STR_LENGTH, STR_CONCAT, STR_INDEXOF, STR_REPLACE,
                            STR_SUBSTR, STR_CHARAT, STR_TO_INT, INT_TO_STR,])
 
-IRA_OPERATORS = frozenset([PLUS, MINUS, TIMES, TOREAL, DIV, POW, BV_TONATURAL])
+IRA_OPERATORS = frozenset([PLUS, MINUS, TIMES, TOREAL, TOINT, DIV, POW,
+                           BV_TONATURAL])
 
 ARRAY_OPERATORS = frozenset([ARRAY_SELECT, ARRAY_STORE, ARRAY_VALUE])
 
@@ -178,6 +180,7 @@ __OP_STR__ = {
     EQUALS : "EQUALS",
     ITE : "ITE",
     TOREAL : "TOREAL",
+    TOINT : "TOINT",
     BV_CONSTANT : "BV_CONSTANT",
     BV_NOT : "BV_NOT",
     BV_AND : "BV_AND",

pysmt/oracles.py

@@ -246,6 +246,12 @@ class TheoryOracle(walkers.DagWalker):
         """Extends the Theory with LIRA."""
         theory_out = args[0].set_lira() # This makes a copy of args[0]
         return theory_out
+
+    def walk_toint(self, formula: FNode, args: List[Theory], **kwargs) -> Theory:
+        #pylint: disable=unused-argument
+        """Extends the Theory with LIRA."""
+        theory_out = args[0].set_lira() # This makes a copy of args[0]
+        return theory_out
         rtype = formula.symbol_name()
 
     @walkers.handles([op.STR_LENGTH, op.STR_INDEXOF, op.STR_TO_INT])

pysmt/parsing.py

@@ -199,6 +199,8 @@ class HRLexer(Lexer):
             "ZEXT": InfixOpAdapter(self.BVHack(self.mgr.BVZExt), 90),# BVZext
             "SEXT": InfixOpAdapter(self.BVHack(self.mgr.BVSExt), 90),# BVSext
             "ToReal": UnaryOpAdapter(self.mgr.ToReal, 100),#
+            "ToInt": UnaryOpAdapter(self.mgr.ToInt, 100),#
+            "IsInt": UnaryOpAdapter(self.mgr.IsInt, 100),#
             "Int": IntTypeTok(),# Int Type
             "Real": RealTypeTok(),# Real Type
             "Bool": BoolTypeTok(),# Bool Type

pysmt/printers.py

@@ -177,6 +177,11 @@ class HRPrinter(TreeWalker):
         yield formula.arg(0)
         self.write(")")
 
+    def walk_toint(self, formula: FNode) -> Iterator[FNode]:
+        self.write("ToInt(")
+        yield formula.arg(0)
+        self.write(")")
+
     def walk_str_constant(self, formula: FNode):
         formula_value = formula.constant_value()
         assert isinstance(formula_value, str), \

pysmt/shortcuts.py

@@ -361,6 +361,19 @@ def ToReal(formula: FNode) -> FNode:
     return get_env().formula_manager.ToReal(formula)
 
 
+def ToInt(formula: FNode) -> FNode:
+    """Explicit cast of a term into an Int term.
+
+    This is the SMT-LIB to_int function, i.e. the floor.
+    """
+    return get_env().formula_manager.ToInt(formula)
+
+
+def IsInt(formula: FNode) -> FNode:
+    """Returns whether the given real term has an integer value."""
+    return get_env().formula_manager.IsInt(formula)
+
+
 def AtMostOne(*args: Union[FNode, Iterable[FNode]]) -> FNode:
     """At most one can be true at anytime.
 

pysmt/simplifier.py

@@ -463,6 +463,16 @@ class Simplifier(pysmt.walkers.DagWalker):
             return self.manager.Real(cast(int, args[0].constant_value()))
         return self.manager.ToReal(args[0])
 
+    def walk_toint(self, formula: FNode, args: List[FNode], **kwargs) -> FNode:
+        assert len(args) == 1
+        if args[0].is_toreal():
+            # to_int(to_real(x)) is x, since x is an integer.
+            # Note that the converse does not hold: to_real(to_int(y)) is
+            # y only when y happens to have an integer value.
+            return args[0].arg(0)
+        # Folding of real constants is done by the FormulaManager
+        return self.manager.ToInt(args[0])
+
     def walk_bv_and(self, formula: FNode, args: List[FNode], **kwargs) -> FNode:
         simplified = None
         width = formula.bv_width()

pysmt/smtlib/parser/parser.py

@@ -392,6 +392,8 @@ class SmtLibParser(object):
             'ite': self._operator_adapter(self.Ite),
             'distinct': self._operator_adapter(self.AllDifferent),
             'to_real': self._operator_adapter(mgr.ToReal),
+            'to_int': self._operator_adapter(mgr.ToInt),
+            'is_int': self._operator_adapter(mgr.IsInt),
             'concat': self._operator_adapter(mgr.BVConcat),
             'bvnot': self._operator_adapter(mgr.BVNot),
             'bvand': self._operator_adapter(mgr.BVAnd),

pysmt/smtlib/printers.py

@@ -94,6 +94,7 @@ class SmtPrinter(TreeWalker):
     def walk_lt(self, formula): return self.walk_nary(formula, "<")
     def walk_ite(self, formula): return self.walk_nary(formula, "ite")
     def walk_toreal(self, formula): return self.walk_nary(formula, "to_real")
+    def walk_toint(self, formula): return self.walk_nary(formula, "to_int")
     def walk_div(self, formula): return self.walk_nary(formula, "/")
     def walk_pow(self, formula): return self.walk_nary(formula, "pow")
     def walk_bv_and(self, formula): return self.walk_nary(formula, "bvand")
@@ -422,6 +423,9 @@ class SmtDagPrinter(DagWalker):
     def walk_toreal(self, formula: FNode, args: List[str]) -> str:
         return self.walk_nary(formula, args, "to_real")
 
+    def walk_toint(self, formula: FNode, args: List[str]) -> str:
+        return self.walk_nary(formula, args, "to_int")
+
     def walk_div(self, formula: FNode, args: List[str]) -> str:
         return self.walk_nary(formula, args, "/")
 

pysmt/solvers/cvcfive.py

@@ -394,6 +394,9 @@ class CVC5Converter(Converter, DagWalker):
     def walk_toreal(self, formula, args, **kwargs):
         return self.cvc5_solver.mkTerm(Kind.TO_REAL, args[0])
 
+    def walk_toint(self, formula, args, **kwargs):
+        return self.cvc5_solver.mkTerm(Kind.TO_INTEGER, args[0])
+
     def walk_function(self, formula, args, **kwargs):
         name = formula.function_name()
         if name not in self.declared_vars:

pysmt/solvers/cvcfour.py

@@ -351,6 +351,9 @@ class CVC4Converter(Converter, DagWalker):
     def walk_toreal(self, formula, args, **kwargs):
         return self.mkExpr(CVC4.TO_REAL, args[0])
 
+    def walk_toint(self, formula, args, **kwargs):
+        return self.mkExpr(CVC4.TO_INTEGER, args[0])
+
     def walk_function(self, formula, args, **kwargs):
         name = formula.function_name()
         if name not in self.declared_vars:

pysmt/solvers/msat.py

@@ -427,6 +427,7 @@ class MSatConverter(Converter, DagWalker):
             self._msat_lib.MSAT_TAG_BV_LSHR: self._back_adapter(self.mgr.BVLShr),
             self._msat_lib.MSAT_TAG_BV_ASHR: self._back_adapter(self.mgr.BVAShr),
             self._msat_lib.MSAT_TAG_BV_COMP: self._back_adapter(self.mgr.BVComp),
+            self._msat_lib.MSAT_TAG_FLOOR: self._back_adapter(self.mgr.ToInt),
             self._msat_lib.MSAT_TAG_INT_FROM_UBV: self._back_adapter(self.mgr.BVToNatural),
             self._msat_lib.MSAT_TAG_ARRAY_READ: self._back_adapter(self.mgr.Select),
             self._msat_lib.MSAT_TAG_ARRAY_WRITE: self._back_adapter(self.mgr.Store),
@@ -461,6 +462,8 @@ 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_FLOOR: lambda term, args:\
+                types.FunctionType(types.INT, [types.REAL]),
             self._msat_lib.MSAT_TAG_BV_MUL: self._sig_binary,
             self._msat_lib.MSAT_TAG_BV_ADD: self._sig_binary,
             self._msat_lib.MSAT_TAG_BV_UDIV:self._sig_binary,
@@ -1004,6 +1007,9 @@ class MSatConverter(Converter, DagWalker):
         # In mathsat toreal is implicit
         return args[0]
 
+    def walk_toint(self, formula: FNode, args: List[Any], **kwargs) -> Any:
+        return self._msat_lib.msat_make_floor(self.msat_env(), args[0])
+
     def walk_bv_tonatural(self, formula: FNode, args: List[Any], **kwargs) -> Any:
         return self._msat_lib.msat_make_int_from_ubv(self.msat_env(), args[0])
 

pysmt/solvers/yices.py

@@ -470,6 +470,11 @@ class YicesConverter(Converter, DagWalker):
     def walk_toreal(self, formula: FNode, args, **kwargs):
         return args[0]
 
+    def walk_toint(self, formula: FNode, args, **kwargs):
+        res = yices_api.yices_floor(args[0])
+        self._check_term_result(res)
+        return res
+
     def walk_function(self, formula: FNode, args, **kwargs):
         name = formula.function_name()
         if name not in self.symbol_to_decl:

pysmt/solvers/z3.py

@@ -340,6 +340,8 @@ class Z3Converter(Converter, DagWalker):
             z3.Z3_OP_IMPLIES: lambda args, expr: self.mgr.Implies(args[0], args[1]),
             z3.Z3_OP_ITE: lambda args, expr: self.mgr.Ite(args[0], args[1], args[2]),
             z3.Z3_OP_TO_REAL: lambda args, expr: self.mgr.ToReal(args[0]),
+            z3.Z3_OP_TO_INT: lambda args, expr: self.mgr.ToInt(args[0]),
+            z3.Z3_OP_IS_INT: lambda args, expr: self.mgr.IsInt(args[0]),
             z3.Z3_OP_BAND : lambda args, expr: self.mgr.BVAnd(args),
             z3.Z3_OP_BOR : lambda args, expr: self.mgr.BVOr(args),
             z3.Z3_OP_BXOR : lambda args, expr: self.mgr.BVXor(args[0], args[1]),
@@ -737,6 +739,11 @@ class Z3Converter(Converter, DagWalker):
         z3.Z3_inc_ref(self.ctx.ref(), z3term)
         return z3term
 
+    def walk_toint(self, formula, args, **kwargs):
+        z3term = z3.Z3_mk_real2int(self.ctx.ref(), args[0])
+        z3.Z3_inc_ref(self.ctx.ref(), z3term)
+        return z3term
+
     def _z3_func_decl(self, func_name):
         """Create a Z3 Function Declaration for the given function."""
         try:

pysmt/test/examples.py

@@ -23,7 +23,7 @@ from pysmt.shortcuts import (Symbol, Function,
                              Int, Real, FALSE, TRUE,
                              And, Iff, Or, Not, Implies, Ite,
                              LT, LE, GT, GE,
-                             Times, Pow, Equals, Plus, Minus, Div, ToReal,
+                             Times, Pow, Equals, Plus, Minus, Div, ToReal, ToInt,
                              ForAll, Exists,
                              BV, SBV, BVOne, BVZero,
                              BVNot, BVAnd, BVOr, BVXor,
@@ -698,6 +698,32 @@ def get_full_example_formulae(environment: Optional[Environment]=None) -> List[E
                     is_sat=False,
                     logic=pysmt.logics.QF_UFLIRA
                 ),
+
+            # ToInt is the floor, hence it rounds towards minus infinity
+            Example(hr="((r = -3/2) -> (ToInt(r) = -2))",
+                    expr=Implies(Equals(r, Real(Fraction(-3, 2))),
+                                 Equals(ToInt(r), Int(-2))),
+                    is_valid=True,
+                    is_sat=True,
+                    logic=pysmt.logics.QF_LIRA
+                ),
+
+            # ToInt must not truncate towards zero
+            Example(hr="((r = -3/2) & (ToInt(r) = -1))",
+                    expr=And(Equals(r, Real(Fraction(-3, 2))),
+                             Equals(ToInt(r), Int(-1))),
+                    is_valid=False,
+                    is_sat=False,
+                    logic=pysmt.logics.QF_LIRA
+                ),
+
+            Example(hr="((ToInt(r) = p) & (0.0 < r))",
+                    expr=And(Equals(ToInt(r), p),
+                             GT(r, Real(0))),
+                    is_valid=False,
+                    is_sat=True,
+                    logic=pysmt.logics.QF_LIRA
+                ),
             #
             # STR
             #

pysmt/test/smtlib/test_parser_examples.py

@@ -118,6 +118,7 @@ class TestSMTParseExamples(TestCase):
             logics.QF_BOOL: logics.QF_UF,
             logics.BOOL: logics.LRA,
             logics.QF_NIRA: logics.AUFNIRA,
+            logics.QF_LIRA: logics.QF_UFLIRA,
         }
         fs = get_example_formulae()
 

pysmt/test/test_lira.py

@@ -16,9 +16,11 @@
 #   limitations under the License.
 #
 from pysmt.shortcuts import *
+from pysmt.constants import Fraction
+from pysmt.exceptions import PysmtTypeError
 from pysmt.typing import INT, REAL, FunctionType
 from pysmt.test import TestCase, main
-from pysmt.logics import QF_UFLIRA, UFLIRA
+from pysmt.logics import QF_LIRA, QF_UFLIRA, UFLIRA
 
 class TestLIRA(TestCase):
 
@@ -47,6 +49,80 @@ class TestLIRA(TestCase):
                           ToReal(ToReal(Plus(b, Int(1)))))
 
 
+    def test_toint_is_floor(self):
+        # to_int rounds towards minus infinity, it does not truncate
+        self.assertEqual(ToInt(Real(Fraction(-3, 2))), Int(-2))
+        self.assertEqual(ToInt(Real(Fraction(3, 2))), Int(1))
+        self.assertEqual(ToInt(Real(Fraction(-1, 3))), Int(-1))
+        self.assertEqual(ToInt(Real(0)), Int(0))
+        self.assertEqual(ToInt(Real(-2)), Int(-2))
+
+
+    def test_toint(self):
+        a = Symbol("a", REAL)
+        b = Symbol("b", INT)
+
+        # Casting an Int is a no-op
+        self.assertEqual(b, ToInt(b))
+        self.assertEqual(Plus(b, Int(1)), ToInt(Plus(b, Int(1))))
+
+        self.assertTrue(ToInt(a).is_toint())
+        self.assertEqual(get_type(ToInt(a)), INT)
+
+        for bad in (TRUE(), Symbol("x"), BV(1, 8)):
+            with self.assertRaises(PysmtTypeError):
+                ToInt(bad)
+
+
+    def test_toint_simplify(self):
+        a = Symbol("a", REAL)
+        b = Symbol("b", INT)
+
+        # to_int(to_real(b)) is b, since b is an integer
+        self.assertEqual(b, ToInt(ToReal(b)).simplify())
+        self.assertEqual(Plus(b, Int(1)),
+                         ToInt(ToReal(Plus(b, Int(1)))).simplify())
+
+        # The converse does NOT hold: to_real(to_int(a)) is a only when a
+        # happens to have an integer value.
+        self.assertNotEqual(a, ToReal(ToInt(a)).simplify())
+
+
+    def test_isint(self):
+        a = Symbol("a", REAL)
+        b = Symbol("b", INT)
+
+        # is_int is expanded into its SMT-LIB definition
+        self.assertEqual(IsInt(a), Equals(a, ToReal(ToInt(a))))
+        # An Int is trivially an integer
+        self.assertEqual(IsInt(b), TRUE())
+
+        with self.assertRaises(PysmtTypeError):
+            IsInt(TRUE())
+
+
+    def test_toint_solving(self):
+        a = Symbol("a", REAL)
+
+        for sname in get_env().factory.all_solvers(logic=QF_LIRA):
+            # 7/2 floors to 3
+            self.assertSat(And(Equals(a, Real(Fraction(7, 2))),
+                               Equals(ToInt(a), Int(3))),
+                           solver_name=sname)
+            # -3/2 floors to -2, and in particular not to -1
+            self.assertSat(And(Equals(a, Real(Fraction(-3, 2))),
+                               Equals(ToInt(a), Int(-2))),
+                           solver_name=sname)
+            self.assertUnsat(And(Equals(a, Real(Fraction(-3, 2))),
+                                 Equals(ToInt(a), Int(-1))),
+                             solver_name=sname)
+            # 1/2 is not an integer
+            self.assertUnsat(And(IsInt(a), Equals(a, Real(Fraction(1, 2)))),
+                             solver_name=sname)
+            self.assertSat(And(IsInt(a), Equals(a, Real(Fraction(4, 2)))),
+                           solver_name=sname)
+
+
     def test_uflira(self):
         a = Symbol("a", REAL)
         b = Symbol("b", INT)

pysmt/test/test_printing.py

@@ -20,7 +20,7 @@ from io import StringIO
 from pysmt.shortcuts import Or, And, Not, Plus, Iff, Implies
 from pysmt.shortcuts import Exists, ForAll, Ite, ExactlyOne
 from pysmt.shortcuts import Bool, Real, Int, Symbol, Function
-from pysmt.shortcuts import Times, Minus, Equals, LE, LT, ToReal, FreshSymbol
+from pysmt.shortcuts import Times, Minus, Equals, LE, LT, ToReal, ToInt, FreshSymbol
 from pysmt.typing import REAL, INT, FunctionType
 from pysmt.smtlib.printers import SmtPrinter, SmtDagPrinter
 from pysmt.smtlib.annotations import Annotations
@@ -139,6 +139,14 @@ class TestPrinting(TestCase):
         self.assertEqual(rp.to_smtlib(daggify=False), "(to_real p)")
         self.assertEqual(rp.to_smtlib(daggify=True), "(let ((.def_0 (to_real p))) .def_0)")
 
+    def test_toint(self):
+        r = Symbol("r", REAL)
+        ir = ToInt(r)
+
+        self.assertEqual(ir.to_smtlib(daggify=False), "(to_int r)")
+        self.assertEqual(ir.to_smtlib(daggify=True), "(let ((.def_0 (to_int r))) .def_0)")
+        self.assertEqual(ir.serialize(), "ToInt(r)")
+
     def test_threshold_printing(self):
         x = Symbol("x")
         f = And(x,x)

pysmt/type_checker.py

@@ -79,6 +79,11 @@ class SimpleTypeChecker(walkers.DagWalker):
         #pylint: disable=unused-argument
         return self.walk_type_to_type(formula, args, INT, REAL)
 
+    @walkers.handles(op.TOINT)
+    def walk_real_to_int(self, formula: FNode, args: List[PySMTType], **kwargs) -> Optional[PySMTType]:
+        #pylint: disable=unused-argument
+        return self.walk_type_to_type(formula, args, REAL, INT)
+
     def walk_real_to_real(self, formula: FNode, args: List[PySMTType], **kwargs) -> Optional[PySMTType]:
         #pylint: disable=unused-argument
         return self.walk_type_to_type(formula, args, REAL, REAL)

pysmt/walkers/identitydag.py

@@ -114,6 +114,9 @@ class IdentityDagWalker(DagWalker):
     def walk_toreal(self, formula: FNode, args: List[FNode], **kwargs) -> FNode:
         return self.mgr.ToReal(args[0])
 
+    def walk_toint(self, formula: FNode, args: List[FNode], **kwargs) -> FNode:
+        return self.mgr.ToInt(args[0])
+
     def walk_bv_constant(self, formula: FNode, **kwargs) -> FNode:
         return self.mgr.BV(cast(int, formula.constant_value()), formula.bv_width())
 

{pysmt-0.9.7.dev431.dist-info → pysmt-0.9.7.dev433.dist-info}/METADATA

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

{pysmt-0.9.7.dev431.dist-info → pysmt-0.9.7.dev433.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pysmt/__init__.py,sha256=i5sG2soSbeXz4N7EIPPiKx_K1yNeoxD603-viPBU7Hk,1701
+pysmt/__init__.py,sha256=3fqAzPQlXGHf1Ffs6yhccGmhry4ISQoFXyzAIHRNA6w,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
@@ -6,18 +6,18 @@ pysmt/decorators.py,sha256=dZWnu0lwfVBq6WGoohH5EWVpi6xr-uAEtFBjDUJgnoo,4106
 pysmt/environment.py,sha256=UUcccuTIGRYdIxvso4aUvfwJiveoDdOwRgTcVHkuupc,7056
 pysmt/exceptions.py,sha256=l7JmvC9VML32HeZwIhgxf5L-NQjbbpX4aHCdO9d56nM,5637
 pysmt/factory.py,sha256=wxqu-SkHFk_iPOkQwDj8L-bhIfCLN37x5GdfhlCha_o,31879
-pysmt/fnode.py,sha256=SJ35GNwjYOwxMrexttCmVj5ZddFQ52GFATTSyArUuX0,36313
-pysmt/formula.py,sha256=c-2gZmumCzpSzNPpbVGs6_H-lZtgMjQwDmyi04FmleM,49119
+pysmt/fnode.py,sha256=5K0z8Qy3jIbB4N-lyBESXyzDpBDPD92jryNNd50NdLk,36453
+pysmt/formula.py,sha256=gUqv0V91Tww9GVeOD2Z_gsZlthUe8NADd0ZbYmK2CEk,50770
 pysmt/logics.py,sha256=HQaq2Odqw8oFNCAo1av0zaFOcPujTopO8frWSBsmNtg,29348
-pysmt/operators.py,sha256=h4paq_sIatt49--6Ch2cQPfMPFs0mb4ZztM5N1r31kM,8188
-pysmt/oracles.py,sha256=Q8m2ju9hZUrKYd36JPxabAPc6jjgIrVUu9NgFq1JIsU,21433
-pysmt/parsing.py,sha256=ndADbJ1hCz2JcAGN7MMvVPpHKtR4WhPinB_2EEEtS7o,20960
-pysmt/printers.py,sha256=nx8N4uQ6Hp591JyE98hdjKlO6x0lqL9dr2AGf07a644,14955
+pysmt/operators.py,sha256=XGPPoX5bdDsroAkr5rUAiBdi7BXkPaOyst7jEWqLTa0,8329
+pysmt/oracles.py,sha256=fg1ORZGCTsVXMCZDKRKFHtW7uV79qF_XRxxSFv2R4Vs,21698
+pysmt/parsing.py,sha256=dj1lBgry0KEKSz16RNY_h_nQ2KaSX_trfLJu-rDnYeA,21078
+pysmt/printers.py,sha256=fB2aPwsV7qQxgtqgVndUA_1wWBp5vMPzqBxngmBJmk4,15099
 pysmt/rewritings.py,sha256=-oGrrwGt2Rl8_CkT2wy8dTRTHAk4Dxsn43aPpv-NCN0,42207
-pysmt/shortcuts.py,sha256=EzwH0wXDXDWeQs46GKMQf3W-x1AGkwisaQJt6xodqso,44599
-pysmt/simplifier.py,sha256=s5jUxql86MjZ77_deoFbOVvnDe-5Tj_xpyK3VQtpj6c,44900
+pysmt/shortcuts.py,sha256=Xiq5JnkjefgwuJAEbmMAjnkyqu35MoALnSp2NYtIeDg,44962
+pysmt/simplifier.py,sha256=RcIj0xofu8TstlGH26h1xzX9zw4cJ--O9t9hSFxfbeQ,45384
 pysmt/substituter.py,sha256=sTW-Phkq6Ae8xft_eLrXR06wJZ6C3EgpkZoqj_HLLMc,14446
-pysmt/type_checker.py,sha256=0XfiYad4swJeKRXy1W4eGbidrU371s4qqHcy8AfXZ7g,15793
+pysmt/type_checker.py,sha256=kJvj7qOTG68QgsQpUMnnxTbJl2S0GLbgRj_dG_E5jxM,16034
 pysmt/typing.py,sha256=aI8ZKEin4J2XLAHsY5fW1Pt4hZvlBlArxM4nrrmBas4,19550
 pysmt/utils.py,sha256=_dSgl45k-u9cMXSyR672GBJcKMKdtl6xSTjqXKTSfcs,2906
 pysmt/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,31 +45,31 @@ pysmt/optimization/z3.py,sha256=qhSQ0wR487555yYW9vSvLaIMutKN05cczPPITK_O_u4,7270
 pysmt/smtlib/__init__.py,sha256=JXBHtcb4Lv-Sb8whc9JuGbRH2EBLWwtLUh3PL9HhNE8,650
 pysmt/smtlib/annotations.py,sha256=UTl_nnBikMGKzdpW5N17yIpvx-_8HZmo8hxXIKsm7Wo,4596
 pysmt/smtlib/commands.py,sha256=hwWnXrzZxJmKtkIitHRtuin01WDUErT0VERR9h45t2A,2277
-pysmt/smtlib/printers.py,sha256=ZZMx1d0aS5kGDqJj1c7PYCEXqgXnk_CugcVAVinrtzk,25940
+pysmt/smtlib/printers.py,sha256=072iwQcAWzaREXh5nYinUjH1xOuYuU2HfDmSYHItw6M,26138
 pysmt/smtlib/script.py,sha256=RWJT9KA_LH23YNqhtosc10LaH8Z_6Hj1YNDuf_qqLIc,24099
 pysmt/smtlib/solver.py,sha256=NUtBsghqgTAPEH2am4_Aq6BYz2ugGPRWGzpdzMQpAr4,8062
 pysmt/smtlib/utils.py,sha256=C-P8RPgR8RDRQnrB8xfLGc5aFso11u0sEtFw04NMbKQ,2126
 pysmt/smtlib/parser/__init__.py,sha256=Pfdm6pv9hwOv8D9NbAaHEokDZXkRg3CwYLN5Ny7UNyY,5055
-pysmt/smtlib/parser/parser.py,sha256=yXNm3VJDgtSFDA41-iKkgeZVhlUXqKskj9Xsgbja7iE,67454
+pysmt/smtlib/parser/parser.py,sha256=a4BWhJqGIuz3csH1A_a_sPPc-191WoxmzLRzar9D-WQ,67568
 pysmt/solvers/__init__.py,sha256=JXBHtcb4Lv-Sb8whc9JuGbRH2EBLWwtLUh3PL9HhNE8,650
 pysmt/solvers/bdd.py,sha256=NG0BHE5-nqfn6vdUZjJIxiBH1ZwdkTgJKSeQGORaCFc,15961
 pysmt/solvers/btor.py,sha256=V9pAVMhvjmejyrMiQNrpxQFQ8VzmebhRcvuSSwTcAvQ,26033
-pysmt/solvers/cvcfive.py,sha256=fxt2lMUjMC2g4vRQkZQY3xLnKPa5X7SIbGs7fHWJGdY,25205
-pysmt/solvers/cvcfour.py,sha256=iMMpFRxr7EoNjZnO64q7R1rIodQqw71Cv1JiIdj6kzE,24471
+pysmt/solvers/cvcfive.py,sha256=Kvf-M8xOwuaQz4aZ8et_OP4tVrjW7wOY2uRbkTkwTUU,25322
+pysmt/solvers/cvcfour.py,sha256=410vzWLtXNRJKCNfKpo39vYyVZflrUNA0X_SswI-UmI,24576
 pysmt/solvers/dynmsat.py,sha256=bJokwHoxKWmQGqw9nQerRDb33d5c66Sa91jUYiZXwY0,2124
 pysmt/solvers/eager.py,sha256=ZvtXsD-4QAhjd8gRNb_CrosjSLEJn07YEwVEMKTnHAg,3634
 pysmt/solvers/interpolation.py,sha256=6AO1wMkEKSkptuC4aXlNEO8Be1K2oW3W_er2XGc_aEA,2066
-pysmt/solvers/msat.py,sha256=FNsufZycnGjbjIdMRnupSSQKo3J4KtlhSRKmSIHWzRU,60115
+pysmt/solvers/msat.py,sha256=-sDEc87PBXubBw3Csnm18C9e354ZjRdmKvumTyHD6Vo,60467
 pysmt/solvers/options.py,sha256=DRNUMb5Tlhai4keQkF7Kg34tf3AGbBUd45mqzjsS69c,4036
 pysmt/solvers/pico.py,sha256=1fN9hy22ym0FYbLYhSoADx1StQBxwd60Kx_RqcUtXdA,10653
 pysmt/solvers/portfolio.py,sha256=v2OvmQdh84YlXKZQgc_cx3UQ7MPL8l5heOV6WHEyXnU,9809
 pysmt/solvers/qelim.py,sha256=x3XIhdDdqxlCj4ZNa5WxORiepWjAAM3IWNLn4rfl5zM,5342
 pysmt/solvers/smtlib.py,sha256=uUG4ux175AJYLoejgvWoTY5qGwcXmUMTD574EMks5gE,9714
 pysmt/solvers/solver.py,sha256=zZRlGzrerPlZtIAiKGU9q3b4zTphSPdWl-xeCsnAgxA,19315
-pysmt/solvers/yices.py,sha256=jGWCic29--1VYWW_JXIp5RmlJY9xj2Pdv61n3ElKZII,25750
-pysmt/solvers/z3.py,sha256=_lk-Ifo31D9nS7NNjdyQk2--Wm9gVlKmHoYbQfJRJlA,44259
+pysmt/solvers/yices.py,sha256=uG08Q9iqctXk-2rDP6H5OO88FE_ml83K0k5j8irpbcg,25910
+pysmt/solvers/z3.py,sha256=W-MAj83Kaqz8OCA2QX8-IXnj2ud0SXy17Wxf98o7L3c,44585
 pysmt/test/__init__.py,sha256=LEFbVYw4X45sgEI4_ax55g-6G5Y7kj6CLaJr1TQr4ks,5750
-pysmt/test/examples.py,sha256=uMc4MzgFAPpu3eZF3ZdmHdyumt9SFWUy2GWTSzN8EN4,39703
+pysmt/test/examples.py,sha256=6yWa-hHEMJuo5GEbjWmzg509-LQxVAyr26lxGhcK_jU,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=OypmqKf_ciigxK1X_W2b9sm0EWOA3wqH376QXt7oGCM,6237
@@ -90,7 +90,7 @@ pysmt/test/test_hr_parsing.py,sha256=bi-iTu7y1C7diMcWsQ7EI40MipDbzTKbMGPnLWX85A8
 pysmt/test/test_imports.py,sha256=f41EUBrlDItgQ_6SPhWW8-tuwMrdMFXHJzaxrHHB43Q,1583
 pysmt/test/test_int.py,sha256=dk72Q6viqRUs9XiPB40n6RrwiqsV6GbbKuSlYaQMU9k,1980
 pysmt/test/test_interpolation.py,sha256=WTodZtnxH5slIvUWbHbjjnI2o0naXgZwZawTGhh3E0o,3941
-pysmt/test/test_lira.py,sha256=1B4y1y2U-5CttF6h22tniJkAedUDIwjp1Ad0_Ha_s-8,2175
+pysmt/test/test_lira.py,sha256=o8z7Bcb9zH2ptC7oYTueAJB05a-SINh2a__UNUUP610,5006
 pysmt/test/test_logics.py,sha256=bWwE_7rq9SVcXglE-ugteGeCHXAYFiBdi-QgIL9-9KE,6893
 pysmt/test/test_models.py,sha256=npqGoF-3DgAw0DTx6se32ZEZRFBJDcnkppzgyjLDbps,2748
 pysmt/test/test_native_qe.py,sha256=RGZgwbpAkPBTjIqcCbOkZ_nQXIDZ4Fznrr7Ldx6oA38,3439
@@ -100,7 +100,7 @@ pysmt/test/test_optimization.py,sha256=xU0gJbD2SSn5_lA7wF7IKcR54KF6NU0g-2_dDEqXm
 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=k0Jdrdr-EX-BVCxqYNUS3YjC77aCpzzdhezjB8U3OCM,7125
-pysmt/test/test_printing.py,sha256=glsnaMRungLc31JIJTmHlT69JnTPsC5pnYn1rZriV2s,8765
+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_rewritings.py,sha256=1eeseDwZyQD2VrOFBABXHTYJFJOXszP4olbCNeLcwfA,15607
@@ -124,7 +124,7 @@ pysmt/test/smtlib/test_generic_wrapper.py,sha256=UOVNZ8dWqUJNfNkFsXp0fz4CNMFvybl
 pysmt/test/smtlib/test_griggio.py,sha256=W8C5SWABwUeAQdnslQoU_6pxFokaz2cT5sAfJLo1cKw,2959
 pysmt/test/smtlib/test_model_validation.py,sha256=xHHBkbANSNnxuc8HFUVcEANde0zsZZdTWPtIWVazw7c,3076
 pysmt/test/smtlib/test_omt_lib_solver.py,sha256=xZZWDSB0eDBsmzu7R8AqRN0fSCvFRW6x4Cq9MmTAfos,8177
-pysmt/test/smtlib/test_parser_examples.py,sha256=5e0pNN5rjgi5cLAJl4ZZuUiifCUgVaD__JfBlVJgMR4,10100
+pysmt/test/smtlib/test_parser_examples.py,sha256=Rghq3y-ecce-FYlKURIZAIHeMAd3H-k7JTcWH-kpNvg,10146
 pysmt/test/smtlib/test_parser_extensibility.py,sha256=MgEVUU-icDEryKh54sW9VC59e8CuC6Q_5Sw65FtxBgo,3933
 pysmt/test/smtlib/test_parser_lra.py,sha256=N6HD1BqSb88FpOeaHsKME5IOok3Eu3YdpM55XgDFs3s,997
 pysmt/test/smtlib/test_parser_omt.py,sha256=XhS6Fmy5c1xRya45QlyJuzuV7jdnFfrkig-zZkQrJO0,9564
@@ -141,12 +141,12 @@ pysmt/test/smtlib/test_smtlibscript.py,sha256=oyiilRk7PARXA4NDHfYoqpGP5BUrsBGt7x
 pysmt/walkers/__init__.py,sha256=xJWAK99BWnVSo_vcpBDaH06SxpF64HWd36A4BE_t05g,1658
 pysmt/walkers/dag.py,sha256=4CWSgoXm6nONhM-1znKRU4SBCb791OTS-M9QlQFhbs8,5751
 pysmt/walkers/generic.py,sha256=dmp47kJGtO6rhC2t07Mf_FsYN-lcy64LX-dZggNnWm4,5179
-pysmt/walkers/identitydag.py,sha256=DBPaDuIgvZZz1ohKyoWcDeQVa3RgMQDnqn4Jo7gwtNs,10782
+pysmt/walkers/identitydag.py,sha256=EAxSneEW91Z8GphlkbMPsPdlac7_FDcVj-_6_aunU2s,10902
 pysmt/walkers/tree.py,sha256=8oyDSXZtUsCdExcrwG3hKuEgARHgdW6fvz0LZJwjp-k,2983
-pysmt-0.9.7.dev431.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-pysmt-0.9.7.dev431.dist-info/licenses/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
-pysmt-0.9.7.dev431.dist-info/METADATA,sha256=QcXLPhcitd6QBScf86ZsMC2LPFvJ5M5qgagPBxj-bkk,1774
-pysmt-0.9.7.dev431.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
-pysmt-0.9.7.dev431.dist-info/entry_points.txt,sha256=gDc1XM0xTJJMDGC_nXd0kfbX-Omjke9Dn9F3awMLYIU,57
-pysmt-0.9.7.dev431.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
-pysmt-0.9.7.dev431.dist-info/RECORD,,
+pysmt-0.9.7.dev433.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pysmt-0.9.7.dev433.dist-info/licenses/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
+pysmt-0.9.7.dev433.dist-info/METADATA,sha256=0Tm9O6Fmy0LH94YlyULyAyMc--yExxXER6l-AZ_94ow,1774
+pysmt-0.9.7.dev433.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
+pysmt-0.9.7.dev433.dist-info/entry_points.txt,sha256=gDc1XM0xTJJMDGC_nXd0kfbX-Omjke9Dn9F3awMLYIU,57
+pysmt-0.9.7.dev433.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
+pysmt-0.9.7.dev433.dist-info/RECORD,,

{pysmt-0.9.7.dev431.dist-info → pysmt-0.9.7.dev433.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any