PySMT 0.9.7.dev433__tar.gz → 0.9.7.dev436__tar.gz

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev433
+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.dev433 → 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", 433)
+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.dev433 → 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,22 +407,27 @@ 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),
@@ -407,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),
@@ -492,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])
@@ -506,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.dev433 → 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):
@@ -216,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)