PySMT 0.9.7.dev426__tar.gz → 0.9.7.dev433__tar.gz

{pysmt-0.9.7.dev426/PySMT.egg-info → pysmt-0.9.7.dev433}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev426
+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.dev426 → pysmt-0.9.7.dev433/PySMT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev426
+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.dev426 → pysmt-0.9.7.dev433}/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", 426)
+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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/pysmt/solvers/msat.py

@@ -322,7 +322,7 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
     def all_sat(self, important, callback):
         self.push()
         self._msat_lib.msat_all_sat(self.msat_env(),
-                             [self._var2term(x) for x in important],
+                             [self.converter.convert(x) for x in important],
                              callback)
         self.pop()
 
@@ -336,11 +336,6 @@ class MathSAT5Solver(IncrementalTrackingSolver, UnsatCoreSolver, SmtLibBasicSolv
         for _ in range(levels):
             self._msat_lib.msat_pop_backtrack_point(self.msat_env())
 
-    def _var2term(self, var):
-        decl = self._msat_lib.msat_find_decl(self.msat_env(), var.symbol_name())
-        titem = self._msat_lib.msat_make_term(self.msat_env(), decl, [])
-        return titem
-
     def set_preferred_var(self, var, val=None):
         tvar = self.converter.convert(var)
         mval = self._msat_lib.MSAT_UNDEF
@@ -432,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),
@@ -466,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,
@@ -1009,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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev433/pysmt/test/test_lira.py

@@ -0,0 +1,141 @@
+#
+# This file is part of pySMT.
+#
+#   Copyright 2014 Andrea Micheli and Marco Gario
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   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_LIRA, QF_UFLIRA, UFLIRA
+
+class TestLIRA(TestCase):
+
+    def test_lira(self):
+        a = Symbol("a", REAL)
+        b = Symbol("b", INT)
+
+        check = And(Equals(a, Real(3)), Equals(a, ToReal(b)))
+        for sname in get_env().factory.all_solvers(logic=QF_UFLIRA):
+            with Solver(name=sname) as s:
+                s.add_assertion(check)
+                c = s.solve()
+                self.assertTrue(c)
+                self.assertEqual(s.get_value(b), Int(3))
+
+
+    def test_toreal(self):
+        a = Symbol("a", REAL)
+        b = Symbol("b", INT)
+
+        self.assertEqual(a, ToReal(a))
+        self.assertEqual(Plus(a, Real(1)), ToReal(Plus(a, Real(1))))
+
+        self.assertEqual(ToReal(b), ToReal(ToReal(b)))
+        self.assertEqual(ToReal(Plus(b, Int(1))),
+                          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)
+        h = Symbol("ih", FunctionType(REAL, [REAL, INT]))
+
+        # ( ToReal(b) = a /\ h(ToReal(b), b) >= 3) -> (h(a,b) >= 0)
+        check = Implies(And(Equals(ToReal(b), a),
+                            GE(Function(h, (ToReal(b), b)), Real(3))),
+                        GE(Function(h, (a, b)), Real(0)))
+
+        for sname in get_env().factory.all_solvers(logic=UFLIRA):
+            self.assertValid(check, solver_name=sname)
+
+
+if __name__ == '__main__':
+    main()

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

@@ -574,6 +574,40 @@ class TestRegressions(TestCase):
                 s.add_assertion(f)
                 self.assertFalse(s.solve())
 
+    @skipIfSolverNotAvailable("msat")
+    def test_msat_all_sat_theory_atoms(self):
+        # Regression test: MathSAT5Solver.all_sat must accept arbitrary
+        # SMT-atoms as "important" terms, not only Boolean symbols.
+        # Previously the "important" terms were converted with a helper
+        # (_var2term) that assumed each term was a declared symbol, so
+        # passing a theory atom raised an AssertionError.
+        x = Symbol("x", INT)
+        f = And(LE(Int(0), x), LE(x, Int(5)))
+        atom = LE(x, Int(2))  # a theory atom, not a Boolean symbol
+
+        result = []
+
+        def callback(model, converter, res):
+            res.append(And(converter.back(v) for v in model))
+            return 1  # continue enumeration
+
+        with Solver(name="msat",
+                    solver_options={
+                        "dpll.allsat_minimize_model": "false",
+                        "dpll.allsat_allow_duplicates": "false",
+                        "preprocessor.toplevel_propagation": "false",
+                        "preprocessor.simplification": "0",
+                    }) as msat:
+            msat.add_assertion(f)
+            # This call used to raise AssertionError on a theory atom.
+            msat.all_sat([atom], lambda m: callback(m, msat.converter, result))
+
+        # The atom can be both true (x in [0,2]) and false (x in [3,5]),
+        # so we expect exactly the two disjoint total assignments.
+        self.assertEqual(len(result), 2, result)
+        self.assertIn(atom, result)
+        self.assertIn(Not(atom), result)
+
 
 if __name__ == "__main__":
     main()

{pysmt-0.9.7.dev426 → pysmt-0.9.7.dev433}/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-0.9.7.dev426 → pysmt-0.9.7.dev433}/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())