Beispiel #1
0
 def __init__(self,rule):
     """ unpacks a rule of the kind
          (I) z3.Forall(variables, head)
         or
         (II) z3.Forall(variables, z3.Implies(z3.And([tail,children]),head))
     """
     self.rule = rule        # original rule
     self.variables = None   # quantified variables
     self.predicate = None   # predicate declaration: name(pc,...)
     self.tail = None        # body predicate 
     self.children = None    # other body elements
     self.head = None        # head predicate
     # the rule is a z3 quantifier
     if z3.is_quantifier(rule):
         # quantified variables
         self.variables = list()
         for i in range(rule.num_vars()):
             sort = self.var_sort(rule,i).kind()
             if sort == z3.Z3_INT_SORT:
                 self.variables.append(z3.Int(self.var_name(rule,i)))
             elif sort == z3.Z3_BOOL_SORT:
                 self.variables.append(z3.Bool(self.var_name(rule,i)))
             else:
                 raise ValueError('unsopported sort:',sort)
         # unpacks the rule body
         head = rule.body()
         if z3.is_app_of(head,z3.Z3_OP_IMPLIES):
             # the rule is of kind (II)
             body = head.arg(0)  # z3.Implies body
             if z3.is_app_of(body,z3.Z3_OP_AND):
                 # unpacks the other body elements
                 # (assumes single uninterpreted predicate in body)
                 self.children = list()
                 for c in body.children():
                     child = z3.substitute_vars(c,*self.variables)
                     # unpacks the body predicate 
                     if z3.is_app_of(child,z3.Z3_OP_UNINTERPRETED) \
                         and self.tail is None:  
                             self.tail = child   # body predicate
                     else:
                         self.children.append(child)
             else:
                 raise ValueError('unsupported implication body:',body)
             head = head.arg(1)  # z3.Implies head
         if z3.is_app_of(head,z3.Z3_OP_UNINTERPRETED):
             # the rule is of kind (I)
             name = head.decl().name()   # predicate name
             parameters = list()         # predicate parameters
             arguments = list()          # predicate arguments
             for i in range(head.num_args()):
                 arg = head.arg(i)
                 parameters.append(arg.sort())
                 arguments.append(z3.substitute_vars(arg,*self.variables))
             parameters.append(z3.BoolSort())
             self.predicate = z3.Function(name,*parameters)
             self.head = self.predicate(*arguments)  # head predicate
         else:
             raise ValueError('unsupported rule body:',body)
Beispiel #2
0
 def __init__(self, rule):
     """ unpacks a rule of the kind
          (I) z3.Forall(variables, head)
         or
         (II) z3.Forall(variables, z3.Implies(z3.And([tail,children]),head))
     """
     self.rule = rule  # original rule
     self.variables = None  # quantified variables
     self.predicate = None  # predicate declaration: name(pc,...)
     self.tail = None  # body predicate
     self.children = None  # other body elements
     self.head = None  # head predicate
     # the rule is a z3 quantifier
     if z3.is_quantifier(rule):
         # quantified variables
         self.variables = list()
         for i in range(rule.num_vars()):
             sort = self.var_sort(rule, i).kind()
             if sort == z3.Z3_INT_SORT:
                 self.variables.append(z3.Int(self.var_name(rule, i)))
             elif sort == z3.Z3_BOOL_SORT:
                 self.variables.append(z3.Bool(self.var_name(rule, i)))
             else:
                 raise ValueError("unsopported sort:", sort)
         # unpacks the rule body
         head = rule.body()
         if z3.is_app_of(head, z3.Z3_OP_IMPLIES):
             # the rule is of kind (II)
             body = head.arg(0)  # z3.Implies body
             if z3.is_app_of(body, z3.Z3_OP_AND):
                 # unpacks the other body elements
                 # (assumes single uninterpreted predicate in body)
                 self.children = list()
                 for c in body.children():
                     child = z3.substitute_vars(c, *self.variables)
                     # unpacks the body predicate
                     if z3.is_app_of(child, z3.Z3_OP_UNINTERPRETED) and self.tail is None:
                         self.tail = child  # body predicate
                     else:
                         self.children.append(child)
             else:
                 raise ValueError("unsupported implication body:", body)
             head = head.arg(1)  # z3.Implies head
         if z3.is_app_of(head, z3.Z3_OP_UNINTERPRETED):
             # the rule is of kind (I)
             name = head.decl().name()  # predicate name
             parameters = list()  # predicate parameters
             arguments = list()  # predicate arguments
             for i in range(head.num_args()):
                 arg = head.arg(i)
                 parameters.append(arg.sort())
                 arguments.append(z3.substitute_vars(arg, *self.variables))
             parameters.append(z3.BoolSort())
             self.predicate = z3.Function(name, *parameters)
             self.head = self.predicate(*arguments)  # head predicate
         else:
             raise ValueError("unsupported rule body:", body)
Beispiel #3
0
        def f(_cache, e, seen):
            def f_cache(e):
                return _cache(f, e, seen)

            if z3.is_app_of(e, z3.Z3_OP_UMINUS):
                return f_cache((-1) * (e.arg(0)))
            elif z3.is_sub(e):
                return f_cache(e.arg(0) + (-1) * e.arg(1))
            elif z3.is_app(e) and e.num_args() == 2:
                c1 = f_cache(e.arg(0))
                c2 = f_cache(e.arg(1))
                if z3.is_add(e):
                    return c1 + c2
                elif z3.is_mul(e):
                    if z3.is_add(c1):
                        c11 = c1.arg(0)
                        c12 = c1.arg(1)
                        return f_cache(c11 * c2 + c12 * c2)
                    elif z3.is_add(c2):
                        c21 = c2.arg(0)
                        c22 = c2.arg(1)
                        return f_cache(c1 * c21 + c1 * c22)
                    else:
                        return c1 * c2
                else:
                    return e
            else:
                return e
Beispiel #4
0
def predicates(expr):
    """Return a list of Z3 predicate names satisfied by expr.

    If expr is an application, the list will include the Z3_OP_* that
    expr is an application of.

    This is for debugging purposes.  Real code should use the
    appropriate predicate functions directly.
    """

    res = set()
    for pred_name in dir(z3):
        if not pred_name.startswith("is_"):
            continue
        if pred_name == "is_app_of":
            continue
        pred = getattr(z3, pred_name)
        if pred(expr):
            res.add(pred_name)

    if z3.is_app(expr):
        for op_name in dir(z3):
            if not op_name.startswith("Z3_OP_"):
                continue
            if z3.is_app_of(expr, getattr(z3, op_name)):
                res.add(op_name)

    return res
Beispiel #5
0
def collect_numerals(z3term):
    if z3.is_int_value(z3term) or z3.is_bv_value(z3term):
        yield z3term
    elif z3.is_app_of(z3term, z3.Z3_OP_ITE):
        for z in collect_numerals(z3term.arg(1)):
            yield z
        for z in collect_numerals(z3term.arg(2)):
            yield z
Beispiel #6
0
 def process_eq(e1, e2):
     if z3.eq(e1, const):
         ret_val = z3.simplify(e2)
     else:
         assert z3.is_app(e1)
         if not (z3.is_app_of(e1, z3.Z3_OP_ADD)
                 or z3.is_app_of(e1, z3.Z3_OP_SUB)):
             return None
         is_add = z3.is_app_of(e1, z3.Z3_OP_ADD)
         arg0 = e1.arg(0)
         arg1 = e1.arg(1)
         if z3.eq(arg1, const):
             if is_add: ret_val = z3.simplify(e2 - arg0)
             else: ret_val = z3.simplify(arg0 - e2)
         else:
             if is_add: ret_val = process_eq(arg0, e2 - arg1)
             else: ret_val = process_eq(arg0, e2 + arg1)
     return ret_val
Beispiel #7
0
def is_implies(a):
    """
    Check if the input formula has an implication form, e.g. Imply(a ,b)

    Examples:

    >>> from z3 import *
    >>> a,b = Bools('a b')
    >>> is_implies(Or(Not(a), b))
    False
    >>> is_implies(Implies(a, b))
    True
    """
    return is_app_of(a, Z3_OP_IMPLIES)
Beispiel #8
0
    def __init__ (self, rule_exp):
        self.rule_exp = rule_exp
        self.qvars, self.matrix = z3u.strip_qblock (rule_exp)
        if z3.is_app_of (self.matrix, z3.Z3_OP_IMPLIES):
            self.body = self.matrix.arg (0)
            self.head = self.matrix.arg (1)
        else:
            self.body = None
            self.head = self.matrix

        # body stuff
        self.body_inst = self._get_first_pred_inst (self.body)
        self.body_decl = self._get_inst_decl (self.body_inst)

        # obtain head_decl
        self.head_decl = self.head.decl ()

        # trans
        self.trans = self._get_trans (self.body)
Beispiel #9
0
def get_preds(fp):
    preds = dict()
    pred_keys = []
    for rule_exp in fp.get_rules():
        # rule_exp is a quantified formula representing the rule of the form:
        #     Forall vars. body => head where head is a QF predicate instance
        # obtain the head
        unused_, matrix = strip_qblock(rule_exp)
        if z3.is_app_of(matrix, z3.Z3_OP_IMPLIES): head = matrix.arg(1)
        else: head = matrix

        assert head is not None

        # obtain head_decl
        head_decl = head.decl()

        # ensure head_decl is in preds
        head_key = exp_key(head_decl)
        if head_key in pred_keys: continue
        pred_keys.append(head_key)
        preds[head_decl.name()] = head_decl

    return preds
Beispiel #10
0
from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin
from pysmt.solvers.qelim import QuantifierEliminator
from pysmt.solvers.interpolation import Interpolator

from pysmt.walkers import DagWalker
from pysmt.exceptions import (SolverReturnedUnknownResultError,
                              SolverNotConfiguredForUnsatCoresError,
                              SolverStatusError, ConvertExpressionError,
                              UndefinedSymbolError, PysmtValueError)
from pysmt.decorators import clear_pending_pop, catch_conversion_error
from pysmt.logics import LRA, LIA, QF_UFLIA, QF_UFLRA, PYSMT_LOGICS
from pysmt.oracles import get_logic
from pysmt.constants import Fraction, Numeral, is_pysmt_integer, to_python_integer

# patch z3api
z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE)
z3.is_function = lambda x: z3.is_app_of(x, z3.Z3_OP_UNINTERPRETED)
z3.is_array_store = lambda x: z3.is_app_of(x, z3.Z3_OP_STORE)
z3.get_payload = lambda node, i: z3.Z3_get_decl_int_parameter(
    node.ctx.ref(),
    node.decl().ast, i)


class AstRefKey:
    def __init__(self, n):
        self.n = n

    def __hash__(self):
        return self.n.hash()

    def __eq__(self, other):
Beispiel #11
0
from pysmt.solvers.interpolation import Interpolator

from pysmt.walkers import DagWalker
from pysmt.exceptions import (SolverReturnedUnknownResultError,
                              SolverNotConfiguredForUnsatCoresError,
                              SolverStatusError,
                              ConvertExpressionError,
                              UndefinedSymbolError, PysmtValueError)
from pysmt.decorators import clear_pending_pop, catch_conversion_error
from pysmt.logics import LRA, LIA, QF_UFLIA, QF_UFLRA, PYSMT_LOGICS
from pysmt.oracles import get_logic
from pysmt.constants import Fraction, Numeral, is_pysmt_integer, to_python_integer


# patch z3api
z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE)
z3.is_function = lambda x: z3.is_app_of(x, z3.Z3_OP_UNINTERPRETED)
z3.is_array_store = lambda x: z3.is_app_of(x, z3.Z3_OP_STORE)
z3.get_payload = lambda node,i : z3.Z3_get_decl_int_parameter(node.ctx.ref(),
                                                              node.decl().ast, i)

class AstRefKey:
    def __init__(self, n):
        self.n = n
    def __hash__(self):
        return self.n.hash()
    def __eq__(self, other):
        return self.n.eq(other.n)

def askey(n):
    assert isinstance(n, z3.AstRef)
Beispiel #12
0
def collect_numerals(z3term):
    if z3.is_int_value(z3term) or z3.is_bv_value(z3term):
        yield z3term
    elif z3.is_app_of(z3term, z3.Z3_OP_ITE):
        yield collect_numerals(z3term.arg(1))
        yield collect_numerals(z3term.arg(2))
Beispiel #13
0
def is_implies (expr):
  return z3.is_app_of (expr, z3.Z3_OP_IMPLIES)
Beispiel #14
0
from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin
from pysmt.solvers.qelim import QuantifierEliminator
from pysmt.solvers.interpolation import Interpolator

from pysmt.walkers import DagWalker
from pysmt.exceptions import (SolverReturnedUnknownResultError,
                              SolverNotConfiguredForUnsatCoresError,
                              SolverStatusError,
                              ConvertExpressionError)
from pysmt.decorators import clear_pending_pop, catch_conversion_error
from pysmt.logics import LRA, LIA, QF_UFLIA, QF_UFLRA, PYSMT_LOGICS
from pysmt.oracles import get_logic


# patch z3api
z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE)
z3.is_implies = lambda x: z3.is_app_of(x, z3.Z3_OP_IMPLIES)
z3.is_function = lambda x: z3.is_app_of(x, z3.Z3_OP_UNINTERPRETED)
z3.is_iff = lambda x: z3.is_app_of(x, z3.Z3_OP_IFF)
z3.is_uminus = lambda x: z3.is_app_of(x, z3.Z3_OP_UMINUS)
z3.is_xor = lambda x: z3.is_app_of(x, z3.Z3_OP_XOR)

z3.is_bv_and = lambda x: z3.is_app_of(x, z3.Z3_OP_BAND)
z3.is_bv_or = lambda x: z3.is_app_of(x, z3.Z3_OP_BOR)
z3.is_bv_xor = lambda x: z3.is_app_of(x, z3.Z3_OP_BXOR)
z3.is_bv_neg = lambda x: z3.is_app_of(x, z3.Z3_OP_BNEG)
z3.is_bv_not = lambda x: z3.is_app_of(x, z3.Z3_OP_BNOT)
z3.is_bv_concat = lambda x: z3.is_app_of(x, z3.Z3_OP_CONCAT)
z3.is_bv_slt = lambda x: z3.is_app_of(x, z3.Z3_OP_SLT)
z3.is_bv_sleq = lambda x: z3.is_app_of(x, z3.Z3_OP_SLEQ)
z3.is_bv_ult = lambda x: z3.is_app_of(x, z3.Z3_OP_ULT)
Beispiel #15
0
 def _is_pow_expr(cls, e):
     return z3.is_app_of(e, z3.Z3_OP_POWER)
Beispiel #16
0
def is_implies (expr):
  return z3.is_app_of (expr, z3.Z3_OP_IMPLIES)
Beispiel #17
0
from fractions import Fraction
from six.moves import xrange

from pysmt import typing as types
from pysmt.solvers.solver import Solver, Model, Converter
from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin
from pysmt.solvers.qelim import QuantifierEliminator

from pysmt.walkers import DagWalker
from pysmt.exceptions import SolverReturnedUnknownResultError
from pysmt.decorators import clear_pending_pop

import pysmt.logics

# patch z3api
z3.is_ite = lambda x: z3.is_app_of(x, z3.Z3_OP_ITE)


class AstRefKey:
    def __init__(self, n):
        self.n = n

    def __hash__(self):
        return self.n.hash()

    def __eq__(self, other):
        return self.n.eq(other.n)


def askey(n):
    assert isinstance(n, z3.AstRef)
Beispiel #18
0
def is_xor(exp):
    return z3.is_app_of(exp, z3.Z3_OP_XOR)
Beispiel #19
0
def is_ite(exp):
    return z3.is_app_of(exp, z3.Z3_OP_ITE)