PySMT 0.9.7.dev431__tar.gz → 0.9.7.dev436__tar.gz

{pysmt-0.9.7.dev431/PySMT.egg-info → pysmt-0.9.7.dev436}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev431
+Version: 0.9.7.dev436
 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 → pysmt-0.9.7.dev436}/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", 436)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{pysmt-0.9.7.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/pysmt/smtlib/parser/parser.py

@@ -304,6 +304,40 @@ class Tokenizer(object):
 # EOC Tokenizer
 
 
+#
+# Helpers to expand the SMT-LIB n-ary applications of operators that pySMT
+# only exposes as binary ones. The SMT-LIB standard attaches one of the
+# attributes :left-assoc, :right-assoc, :chainable or :pairwise to every such
+# operator; the three functions below implement the first three (:pairwise is
+# already covered by mgr.AllDifferent).
+#
+# In all cases a single argument is accepted and behaves as the identity (or
+# as `true` for the chainable operators, where the conjunction is empty).
+# The standard requires at least two arguments, but pySMT has always been
+# lenient about this for `and`, `or`, `+` and `*`, and we keep it uniform.
+#
+
+def _left_assoc(operator: Callable) -> Callable:
+    """(op a b c) is expanded to (op (op a b) c)"""
+    def res(*args):
+        return functools.reduce(operator, args)
+    return res
+
+
+def _right_assoc(operator: Callable) -> Callable:
+    """(op a b c) is expanded to (op a (op b c))"""
+    def res(*args):
+        return functools.reduce(lambda acc, x: operator(x, acc), reversed(args))
+    return res
+
+
+def _chainable(mgr: FormulaManager, operator: Callable) -> Callable:
+    """(op a b c) is expanded to (and (op a b) (op b c))"""
+    def res(*args):
+        return mgr.And([operator(l, r) for l, r in zip(args, args[1:])])
+    return res
+
+
 class SmtLibParser(object):
     """Parse an SmtLib file and builds an SmtLibScript object.
     The main function is get_script (and its wrapper
@@ -373,25 +407,32 @@ class SmtLibParser(object):
             "!": self._enter_annotation,
             "exists": self._enter_quantifier,
             "forall": self._enter_quantifier,
+            # '+' and '*' are :left-assoc, but pySMT builds them n-ary
+            # natively; the other n-ary operators are folded, see the
+            # _left_assoc/_right_assoc/_chainable helpers above.
             '+': self._operator_adapter(self.Plus),
             '-': self._operator_adapter(self._minus_or_uminus),
             '*': self._operator_adapter(self.Times),
-            '/': self._operator_adapter(self._division),
+            '/': self._operator_adapter(_left_assoc(self._division)),
+            'div': self._operator_adapter(_left_assoc(mgr.Div)),
             'pow': self._operator_adapter(mgr.Pow),
-            '>': self._operator_adapter(self.GT),
-            '<': self._operator_adapter(self.LT),
-            '>=': self._operator_adapter(self.GE),
-            '<=': self._operator_adapter(self.LE),
-            '=': self._operator_adapter(self._equals_or_iff),
+            '>': self._operator_adapter(_chainable(mgr, self.GT)),
+            '<': self._operator_adapter(_chainable(mgr, self.LT)),
+            '>=': self._operator_adapter(_chainable(mgr, self.GE)),
+            '<=': self._operator_adapter(_chainable(mgr, self.LE)),
+            '=': self._operator_adapter(_chainable(mgr, self._equals_or_iff)),
             'not': self._operator_adapter(mgr.Not),
             'and': self._operator_adapter(mgr.And),
             'or': self._operator_adapter(mgr.Or),
-            'xor': self._operator_adapter(mgr.Xor),
-            '=>': self._operator_adapter(mgr.Implies),
-            '<->': self._operator_adapter(mgr.Iff),
+            'xor': self._operator_adapter(_left_assoc(mgr.Xor)),
+            '=>': self._operator_adapter(_right_assoc(mgr.Implies)),
+            # '<->' is a pySMT extension: treated as :left-assoc, like 'xor'
+            '<->': self._operator_adapter(_left_assoc(mgr.Iff)),
             '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),
@@ -405,12 +446,12 @@ class SmtLibParser(object):
             'bvlshr': self._operator_adapter(mgr.BVLShr),
             'bvsub': self._operator_adapter(mgr.BVSub),
             'bvult': self._operator_adapter(mgr.BVULT),
-            'bvxor': self._operator_adapter(mgr.BVXor),
+            'bvxor': self._operator_adapter(_left_assoc(mgr.BVXor)),
             '_': self._smtlib_underscore,
             # Extended Functions
             'bvnand': self._operator_adapter(mgr.BVNand),
             'bvnor': self._operator_adapter(mgr.BVNor),
-            'bvxnor': self._operator_adapter(mgr.BVXnor),
+            'bvxnor': self._operator_adapter(_left_assoc(mgr.BVXnor)),
             'bvcomp': self._operator_adapter(mgr.BVComp),
             'bvsdiv': self._operator_adapter(mgr.BVSDiv),
             'bvsrem': self._operator_adapter(mgr.BVSRem),
@@ -490,7 +531,7 @@ class SmtLibParser(object):
         self.cache.update({'false': mgr.FALSE(), 'true': mgr.TRUE()})
 
     def _minus_or_uminus(self, *args) -> FNode:
-        """Utility function that handles both unary and binary minus"""
+        """Utility function that handles unary and n-ary minus"""
         mgr = self.env.formula_manager
         if len(args) == 1:
             lty = self.get_type(args[0])
@@ -504,9 +545,8 @@ class SmtLibParser(object):
                     return mgr.Real(-1 * args[0].constant_value())
                 mult = mgr.Real(-1)
             return mgr.Times(mult, args[0])
-        else:
-            assert len(args) == 2
-            return self.Minus(args[0], args[1])
+        # '-' is :left-assoc: (- a b c) is (- (- a b) c)
+        return functools.reduce(self.Minus, args)
 
     def _enter_smtlib_as(self, stack: List[List[Union[Callable, FNode, Any]]], tokens: Tokenizer, key: str):
         """Utility function that handles 'as' that is a special function in SMTLIB"""

{pysmt-0.9.7.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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-0.9.7.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/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.dev431 → pysmt-0.9.7.dev436}/pysmt/test/smtlib/test_parser_examples.py

@@ -25,9 +25,12 @@ from pysmt.test import TestCase, skipIfNoSolverForLogic, main
 from pysmt.test.examples import get_example_formulae
 from pysmt.smtlib.parser import SmtLibParser, Tokenizer
 from pysmt.smtlib.script import smtlibscript_from_formula
-from pysmt.shortcuts import Iff
+from pysmt.shortcuts import Iff, Symbol, And, Implies, Xor, LT, GE, Equals, \
+    Plus, Minus, Times, Div, AllDifferent, BVXor, BVConcat
 from pysmt.shortcuts import read_smtlib, write_smtlib, get_env
 from pysmt.exceptions import PysmtSyntaxError
+from pysmt.smtlib.commands import ASSERT
+from pysmt.typing import INT, REAL, BV8
 
 
 class TestSMTParseExamples(TestCase):
@@ -118,6 +121,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()
 
@@ -215,6 +219,130 @@ class TestSMTParseExamples(TestCase):
         for cmd in s:
             self.assertEqual(cmd.args[2], get_type(cmd.args[3]))
 
+    def test_nary_operators(self):
+        """All the SMT-LIB n-ary operators are expanded as the standard
+        prescribes: see https://github.com/pysmt/pysmt/issues/638"""
+        INT_DECLS = "(declare-fun a () Int)(declare-fun b () Int)" \
+                    "(declare-fun c () Int)(declare-fun d () Int)"
+        BOOL_DECLS = "(declare-fun p () Bool)(declare-fun q () Bool)" \
+                     "(declare-fun r () Bool)"
+        BV_DECLS = "(declare-fun x () (_ BitVec 8))(declare-fun y () (_ BitVec 8))" \
+                   "(declare-fun z () (_ BitVec 8))"
+
+        # (declarations, n-ary application, expected expansion)
+        cases = [
+            # :right-assoc
+            (BOOL_DECLS, "(=> p q r)", "(=> p (=> q r))"),
+            (BOOL_DECLS, "(=> p q r p)", "(=> p (=> q (=> r p)))"),
+            # :left-assoc
+            (BOOL_DECLS, "(xor p q r)", "(xor (xor p q) r)"),
+            (BOOL_DECLS, "(<-> p q r)", "(<-> (<-> p q) r)"),
+            (INT_DECLS, "(- a b c)", "(- (- a b) c)"),
+            (INT_DECLS, "(- a b c d)", "(- (- (- a b) c) d)"),
+            (INT_DECLS, "(/ a b c)", "(/ (/ a b) c)"),
+            (INT_DECLS, "(div a b c)", "(div (div a b) c)"),
+            (BV_DECLS, "(bvxor x y z)", "(bvxor (bvxor x y) z)"),
+            (BV_DECLS, "(bvxnor x y z)", "(bvxnor (bvxnor x y) z)"),
+            # :chainable
+            (INT_DECLS, "(> a b c)", "(and (> a b) (> b c))"),
+            (INT_DECLS, "(>= a b c d)", "(and (>= a b) (>= b c) (>= c d))"),
+            (INT_DECLS, "(< a b c)", "(and (< a b) (< b c))"),
+            (INT_DECLS, "(<= a b c)", "(and (<= a b) (<= b c))"),
+            (INT_DECLS, "(= a b c)", "(and (= a b) (= b c))"),
+            (BOOL_DECLS, "(= p q r)", "(and (<-> p q) (<-> q r))"),
+            # unary applications: identity for the associative operators,
+            # vacuously true for the chainable ones
+            (BOOL_DECLS, "(=> p)", "p"),
+            (BOOL_DECLS, "(xor p)", "p"),
+            (INT_DECLS, "(/ a)", "a"),
+            (INT_DECLS, "(= a)", "true"),
+            (INT_DECLS, "(< a)", "true"),
+        ]
+        for decls, nary, expected in cases:
+            self.assertEqual(self._parse_assertion(decls, nary),
+                             self._parse_assertion(decls, expected),
+                             "wrong expansion of %s" % nary)
+
+    def test_nary_operators_end_to_end(self):
+        """Parse a whole SMT-LIB2 script using the n-ary operators and check
+        the resulting formulae against the ones built with the pySMT API"""
+        script = """
+        ; no set-logic: no pySMT logic covers BV + non-linear Int/Real at once
+        (declare-fun a () Int)
+        (declare-fun b () Int)
+        (declare-fun c () Int)
+        (declare-fun r () Real)
+        (declare-fun s () Real)
+        (declare-fun t () Real)
+        (declare-fun p () Bool)
+        (declare-fun q () Bool)
+        (declare-fun u () Bool)
+        (declare-fun x () (_ BitVec 8))
+        (declare-fun y () (_ BitVec 8))
+        (declare-fun z () (_ BitVec 8))
+        (assert (< a b c))
+        (assert (>= a b c))
+        (assert (= a b c))
+        (assert (= p q u))
+        (assert (= (- a b c) (+ a b c)))
+        (assert (= (div a b c) (* a b c)))
+        (assert (= (/ r s t) r))
+        (assert (=> p q u))
+        (assert (xor p q u))
+        (assert (distinct a b c))
+        (assert (= (bvxor x y z) x))
+        (assert (= (concat x y z) (concat z y x)))
+        (check-sat)
+        """
+        a, b, c = (Symbol(name, INT) for name in "abc")
+        r, s, t = (Symbol(name, REAL) for name in "rst")
+        p, q, u = (Symbol(name) for name in "pqu")
+        x, y, z = (Symbol(name, BV8) for name in "xyz")
+
+        expected = [
+            # :chainable
+            And(LT(a, b), LT(b, c)),
+            And(GE(a, b), GE(b, c)),
+            And(Equals(a, b), Equals(b, c)),
+            And(Iff(p, q), Iff(q, u)),
+            # :left-assoc ('+' and '*' stay flat n-ary)
+            Equals(Minus(Minus(a, b), c), Plus(a, b, c)),
+            Equals(Div(Div(a, b), c), Times(a, b, c)),
+            Equals(Div(Div(r, s), t), r),
+            # :right-assoc
+            Implies(p, Implies(q, u)),
+            # :left-assoc
+            Xor(Xor(p, q), u),
+            # :pairwise
+            AllDifferent(a, b, c),
+            # bit-vectors
+            Equals(BVXor(BVXor(x, y), z), x),
+            Equals(BVConcat(BVConcat(x, y), z), BVConcat(BVConcat(z, y), x)),
+        ]
+
+        parser = SmtLibParser()
+        parsed = [cmd.args[0] for cmd in
+                  parser.get_script(StringIO(script)).filter_by_command_name(ASSERT)]
+
+        self.assertEqual(len(parsed), len(expected))
+        for got, exp in zip(parsed, expected):
+            self.assertEqual(got, exp)
+        # ...and the conjunction of all of them is what the script means
+        self.assertEqual(
+            SmtLibParser().get_script(StringIO(script)).get_last_formula(),
+            And(expected))
+
+    def test_nary_div_is_integer_division(self):
+        """'div' is the Ints division, so it must not be promoted to Real"""
+        f = self._parse_assertion("(declare-fun a () Int)", "(div a 2 3)")
+        self.assertEqual(get_env().stc.get_type(f), INT)
+
+    @staticmethod
+    def _parse_assertion(declarations, expression):
+        script = "%s (assert %s)" % (declarations, expression)
+        parser = SmtLibParser()
+        return parser.get_script(StringIO(script)).get_last_formula()
+
     def test_typing_define_fun(self):
         script = """
         (define-fun x () Int 8.2)