PySMT 0.9.7.dev408__tar.gz → 0.9.7.dev423__tar.gz

{pysmt-0.9.7.dev408/PySMT.egg-info → pysmt-0.9.7.dev423}/PKG-INFO

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

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423/PySMT.egg-info}/PKG-INFO

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

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423}/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", 408)
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 423)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423}/pysmt/rewritings.py

@@ -53,10 +53,12 @@ class CNFizer(DagWalker):
     def convert(self, formula):
         """Convert formula into an Equisatisfiable CNF.
 
-        Returns a set of clauses: a set of set of literals.
+        Returns a set of clauses: a set of sets of literals.
         """
         tl, _cnf = self.walk(formula)
-        res = [frozenset([tl])]
+        if len(_cnf) == 0:
+            return frozenset([frozenset([tl])])
+        res = []
         for clause in _cnf:
             if len(clause) == 0:
                 return CNFizer.FALSE_CNF
@@ -66,6 +68,14 @@ class CNFizer(DagWalker):
                     # Prune clauses that are trivially TRUE
                     simp = None
                     break
+                elif lit == tl:
+                    # Prune clauses as ~tl -> l1 v ... v lk
+                    simp = None
+                    break
+                elif lit == self.mgr.Not(tl).simplify():
+                    # Simplify tl -> l1 v ... v lk
+                    # into l1 v ... v lk
+                    continue
                 elif not lit.is_false():
                     # Prune FALSE literals
                     simp.append(lit)
@@ -126,10 +136,7 @@ class CNFizer(DagWalker):
         elif a.is_false():
             return self.mgr.TRUE(), CNFizer.TRUE_CNF
         else:
-            k = self._key_var(formula)
-            return k, _cnf | frozenset([frozenset([self.mgr.Not(k),
-                                                  self.mgr.Not(a).simplify()]),
-                                       frozenset([k, a])])
+            return self.mgr.Not(a).simplify(), _cnf
 
     def walk_implies(self, formula,  args, **kwargs):
         a, cnf_a = args[0]
@@ -214,6 +221,161 @@ class CNFizer(DagWalker):
 # EOC CNFizer
 
 
+class PolarityCNFizer(CNFizer):
+    """
+    Convert formula into an Equisatisfiable CNF using the polarity-based transformation.
+    """
+
+    def _get_children(self, formula, pol=None):
+        if formula.is_not():
+            return [(formula.arg(0), not pol)]
+
+        elif formula.is_implies():
+            return [(formula.arg(0), not pol), (formula.arg(1), pol)]
+
+        elif formula.is_iff():
+            return [(formula.arg(0), pol), (formula.arg(1), pol),
+                    (formula.arg(0), not pol), (formula.arg(1), not pol)]
+
+        elif formula.is_and() or formula.is_or() or formula.is_quantifier():
+            return [(a, pol) for a in formula.args()]
+
+        elif formula.is_ite():
+            # This must be a boolean ITE as we do not recur within
+            # theory atoms
+            assert self.env.stc.get_type(formula).is_bool_type()
+            i, t, e = formula.args()
+            return [(i, pol), (i, not pol), (t, pol), (e, pol)]
+
+        else:
+            assert formula.is_str_op() or \
+                   formula.is_symbol() or \
+                   formula.is_function_application() or \
+                   formula.is_bool_constant() or \
+                   formula.is_theory_relation(), str(formula)
+            return []
+
+    def _push_with_children_to_stack(self, formula, pol=None, **kwargs):
+        self.stack.append((True, formula, pol))
+
+        for s, p in self._get_children(formula, pol):
+            # Add only if not memoized already
+            key = self._get_key(s, p, **kwargs)
+            if key not in self.memoization:
+                self.stack.append((False, s, p))
+
+    def _compute_node_result(self, formula, pol=None, **kwargs):
+        key = self._get_key(formula, pol, **kwargs)
+        if key not in self.memoization:
+            try:
+                f = self.functions[formula.node_type()]
+            except KeyError:
+                f = self.walk_error
+
+            args = [self.memoization[self._get_key(s, p, **kwargs)] \
+                    for s, p in self._get_children(formula, pol)]
+
+            self.memoization[key] = f(formula, args=args, pol=pol, **kwargs)
+        else:
+            pass
+
+    def _process_stack(self, **kwargs):
+        while self.stack:
+            (was_expanded, formula, pol) = self.stack.pop()
+            if was_expanded:
+                self._compute_node_result(formula, pol, **kwargs)
+            else:
+                self._push_with_children_to_stack(formula, pol, **kwargs)
+
+    def iter_walk(self, formula, **kwargs):
+        self.stack.append((False, formula, True))
+        self._process_stack(**kwargs)
+        res_key = self._get_key(formula, pol=True, **kwargs)
+        return self.memoization[res_key]
+
+    def _get_key(self, formula, pol=None, **kwargs):
+        return formula, pol
+
+    def walk_and(self, formula, args, pol=None, **kwargs):
+        if len(args) == 1:
+            return args[0]
+
+        k = self._key_var(formula)
+        _cnf = [clause for a, c in args for clause in c]
+        if pol:
+            _cnf.extend(frozenset([a, self.mgr.Not(k)]) for a, _ in args)
+        else:
+            _cnf.extend([frozenset([k] + [self.mgr.Not(a).simplify() for a, _ in args])])
+
+        return k, frozenset(_cnf)
+
+    def walk_or(self, formula, args, pol=None, **kwargs):
+        if len(args) == 1:
+            return args[0]
+
+        k = self._key_var(formula)
+        _cnf = [clause for a, c in args for clause in c]
+        if pol:
+            _cnf.extend([frozenset([self.mgr.Not(k)] + [a for a, _ in args])])
+        else:
+            _cnf.extend(frozenset([k, self.mgr.Not(a).simplify()]) for a, c in args)
+
+        return k, frozenset(_cnf)
+
+    def walk_implies(self, formula, args, pol=None, **kwargs):
+        a, cnf_a = args[0]
+        b, cnf_b = args[1]
+
+        k = self._key_var(formula)
+        not_a = self.mgr.Not(a).simplify()
+        not_b = self.mgr.Not(b).simplify()
+        not_k = self.mgr.Not(k)
+        _cnf = []
+        if pol:
+            _cnf.extend([frozenset([not_a, b, not_k])])
+        else:
+            _cnf.extend([frozenset([a, k]), frozenset([not_b, k])])
+
+        return k, (cnf_a | cnf_b | frozenset(_cnf))
+
+    def walk_iff(self, formula, args, pol=None, **kwargs):
+        a, cnf_ap = args[0]
+        b, cnf_bp = args[1]
+        _, cnf_an = args[2]
+        _, cnf_bn = args[3]
+
+        k = self._key_var(formula)
+        not_a = self.mgr.Not(a).simplify()
+        not_b = self.mgr.Not(b).simplify()
+        not_k = self.mgr.Not(k)
+
+        return k, (cnf_ap | cnf_an | cnf_bp | cnf_bn
+                   | frozenset([frozenset([not_a, not_b, k]),
+                                frozenset([not_a, b, not_k]),
+                                frozenset([a, not_b, not_k]),
+                                frozenset([a, b, k])]))
+
+    def walk_ite(self, formula, args, pol=None, **kwargs):
+        if any(a == CNFizer.THEORY_PLACEHOLDER for a in args):
+            return CNFizer.THEORY_PLACEHOLDER
+        (i, cnf_ip), (_, cnf_in), (t, cnf_t), (e, cnf_e) = args
+        k = self._key_var(formula)
+        not_i = self.mgr.Not(i).simplify()
+        not_t = self.mgr.Not(t).simplify()
+        not_e = self.mgr.Not(e).simplify()
+        not_k = self.mgr.Not(k)
+
+        _cnf = []
+        if pol:
+            _cnf.extend([frozenset([not_i, t, not_k]), frozenset([i, e, not_k])])
+        else:
+            _cnf.extend([frozenset([not_i, not_t, k]), frozenset([i, not_e, k])])
+
+        return k, (cnf_ip | cnf_in | cnf_t | cnf_e | frozenset(_cnf))
+
+# EOC PolarityCNFizer
+
+
 class NNFizer(DagWalker):
     """Converts a formula into Negation Normal Form.
 

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423}/pysmt/substituter.py

@@ -151,7 +151,8 @@ class Substituter(pysmt.walkers.IdentityDagWalker):
             # 2. We apply the substitution on the quantifier body with
             #    the new 'reduced' map
             sub = self.__class__(self.env)
-            res_formula = sub.substitute(formula.arg(0), new_subs)
+            res_formula = sub.substitute(formula.arg(0), subs=new_subs,
+                                         interpretations=kwargs.get('interpretations', None))
 
             # 3. We invoke the relevant function (walk_exists or
             #    walk_forall) to compute the substitution
@@ -304,8 +305,9 @@ class MSSubstituter(Substituter):
     def __init__(self, env):
         Substituter.__init__(self, env=env)
 
-    def substitute(self, formula, subs):
-        return Substituter.substitute(self, formula, subs)
+    def substitute(self, formula, subs=None, interpretations=None):
+        return Substituter.substitute(self, formula, subs,
+                                      interpretations=interpretations)
 
     def _substitute(self, formula, substitutions):
         """Returns the substitution for formula, if one is defined, otherwise

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423}/pysmt/test/test_cnf.py

@@ -19,7 +19,7 @@ import os
 import pytest
 
 from pysmt.shortcuts import Implies, is_sat, is_valid, reset_env, Symbol, Iff, Select, ArrayType, INT, BOOL, And, get_env
-from pysmt.rewritings import CNFizer
+from pysmt.rewritings import CNFizer, PolarityCNFizer
 from pysmt.logics import QF_BOOL, QF_LRA, QF_LIA, QF_UFLIRA, QF_UFLRA, QF_ALIA
 from pysmt.test import TestCase, skipIfNoSolverForLogic, main
 from pysmt.test.examples import get_example_formulae
@@ -29,16 +29,16 @@ from pysmt.smtlib.parser import get_formula_fname
 class TestCnf(TestCase):
 
     def do_examples(self, logic):
-        conv = CNFizer()
-        for example in get_example_formulae():
-            if example.logic != logic:
-                continue
-            cnf = conv.convert_as_formula(example.expr)
+        for conv in (CNFizer(), PolarityCNFizer()):
+            for example in get_example_formulae():
+                if example.logic != logic:
+                    continue
+                cnf = conv.convert_as_formula(example.expr)
 
-            self.assertValid(Implies(cnf, example.expr), logic=logic)
+                self.assertValid(Implies(cnf, example.expr), logic=logic)
 
-            res = is_sat(cnf, logic=logic)
-            self.assertEqual(res, example.is_sat)
+                res = is_sat(cnf, logic=logic)
+                self.assertEqual(res, example.is_sat)
 
 
     @skipIfNoSolverForLogic(QF_BOOL)
@@ -80,31 +80,30 @@ class TestCnf(TestCase):
 
     def _smtlib_cnf(self, filename, logic, res_is_sat):
         reset_env()
-        conv = CNFizer()
         smtfile = os.path.join(SMTLIB_DIR, filename)
         assert os.path.exists(smtfile)
 
         expr = get_formula_fname(smtfile)
-        if not logic.quantifier_free:
-            with self.assertRaises(NotImplementedError):
-                conv.convert_as_formula(expr)
-            return
+        for conv in (CNFizer(), PolarityCNFizer()):
+            if not logic.quantifier_free:
+                with self.assertRaises(NotImplementedError):
+                    conv.convert_as_formula(expr)
+                return
+            cnf = conv.convert_as_formula(expr)
+            self.assertTrue(is_valid(Implies(cnf, expr), logic=logic))
 
-        cnf = conv.convert_as_formula(expr)
-        self.assertTrue(is_valid(Implies(cnf, expr), logic=logic))
-
-        res = is_sat(cnf, logic=logic)
-        self.assertEqual(res, res_is_sat)
+            res = is_sat(cnf, logic=logic)
+            self.assertEqual(res, res_is_sat)
 
     @skipIfNoSolverForLogic(QF_BOOL)
     def test_implies(self):
         a,b,c,d = (Symbol(x) for x in "abcd")
         f = Implies(Iff(a, b), Iff(c, d))
 
-        conv = CNFizer()
-        cnf = conv.convert_as_formula(f)
+        for conv in [CNFizer(), PolarityCNFizer()]:
+            cnf = conv.convert_as_formula(f)
 
-        self.assertValid(Implies(cnf, f), logic=QF_BOOL)
+            self.assertValid(Implies(cnf, f), logic=QF_BOOL)
 
     @skipIfNoSolverForLogic(QF_ALIA)
     def test_CNFizer_bool_theory(self):

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423}/pysmt/test/test_regressions.py

@@ -258,7 +258,7 @@ class TestRegressions(TestCase):
 
     def test_cnf_as_set(self):
         r = cnf_as_set(Symbol("x"))
-        self.assertTrue(type(r) == frozenset)
+        self.assertEqual(type(r), frozenset)
 
     def test_substitute_to_real(self):
         p = Symbol("p", INT)

{pysmt-0.9.7.dev408 → pysmt-0.9.7.dev423}/pysmt/test/test_walkers.py

@@ -26,7 +26,7 @@ from pysmt.test import TestCase, main
 from pysmt.formula import FormulaManager
 from pysmt.test.examples import get_example_formulae
 from pysmt.exceptions import UnsupportedOperatorError, PysmtTypeError
-from pysmt.substituter import MSSubstituter, MGSubstituter
+from pysmt.substituter import FunctionInterpretation, MSSubstituter, MGSubstituter
 
 
 class TestWalkers(TestCase):
@@ -78,6 +78,21 @@ class TestWalkers(TestCase):
         with self.assertRaisesRegex(PysmtTypeError, "substitute()"):
             substitute(f, {x:x})
 
+    def test_substituter_interpretations_in_quantifiers(self):
+        x = Symbol("x", INT)
+        UF_XOR = Symbol('uf_xor', FunctionType(INT, [INT, INT]))
+        f = ForAll([x], Equals(Function(UF_XOR, [x, x]), Int(0)))
+
+        class XORInterpreter(FunctionInterpretation):
+            def __init__(self): pass
+            def interpret(self, env, args):
+                if args[0] == args[1]: return Int(0)
+                return Function(UF_XOR, args)
+        
+        subs = f.substitute({}, interpretations={UF_XOR: XORInterpreter()})
+
+        self.assertEqual(subs, ForAll([x], Equals(Int(0), Int(0))))
+
     def test_undefined_node(self):
         varA = Symbol("At", INT)