Python z3.is_app函数代码示例

 def infix_args_core(self, a, d, xs, r):
     sz = len(r)
     k  = a.decl().kind()
     p  = self.get_precedence(k)
     first = True
     for child in a.children():
         child_pp = self.pp_expr(child, d+1, xs)
         child_k = None
         if z3.is_app(child):
             child_k = child.decl().kind()
         if k == child_k and (self.is_assoc(k) or (first and self.is_left_assoc(k))):
             self.infix_args_core(child, d, xs, r)
             sz = len(r)
             if sz > self.max_args:
                 return
         elif self.is_infix_unary(child_k):
             child_p = self.get_precedence(child_k)
             if p > child_p or (_is_add(k) and _is_sub(child_k)) or (_is_sub(k) and first and _is_add(child_k)):
                 r.append(child_pp)
             else: 
                 r.append(self.add_paren(child_pp))
             sz = sz + 1
         elif z3.is_quantifier(child):
             r.append(self.add_paren(child_pp))
         else:
             r.append(child_pp)
             sz = sz + 1
         if sz > self.max_args:
             r.append(self.pp_ellipses())
             return
         first = False

    def translate(self, expr, bound_variables=[]):
        if z3.is_const(expr):
            return self.mk_const(expr)
#                raise Z3_Unexpected_Expression('Unrecognized constant')
        elif z3.is_var(expr):    # a de Bruijn indexed bound variable
            bv_length = len(bound_variables)
            return bound_variables[bv_length - z3.get_var_index(expr) - 1]
        elif z3.is_app(expr):
            args = [self.translate(expr.arg(i), bound_variables)
                for i in range(expr.num_args())]
            return self.mk_fun(expr.decl())(*args)

#            else:
#                raise Z3_Unexpected_Expression(expr)
        elif z3.is_quantifier(expr):
            num_vars = expr.num_vars()
#            vars = [language.const_dict[expr.var_name(i)]
#                for i in range(num_vars)]
            vars = [const(expr.var_name(i), self.mk_sort(expr.var_sort(i))) \
                for i in range(num_vars)]
            new_bound_variables = bound_variables + vars
            body = self.translate(expr.body(), new_bound_variables)
            if expr.is_forall():
                return forall(vars, body)
            else:
                return exists(vars, body)

        elif z3.is_func_decl(expr):
            return self.mk_fun(expr)
        else:
            print expr.kind
            raise Z3_Unexpected_Expression(expr)

def visitor_app(e):
    if z3.is_app(e) and e.decl().kind() == z3.Z3_OP_UNINTERPRETED:
        if e.num_args() > 0:
            yield e
            for ch in e.children():
                for e0 in visitor_app(ch):
                    yield e0

 def pp_power_arg(self, arg, d, xs):
     r = self.pp_expr(arg, d+1, xs)
     k = None
     if z3.is_app(arg):
         k = arg.decl().kind()
     if self.is_infix_unary(k) or (z3.is_rational_value(arg) and arg.denominator_as_long() != 1):
         return self.add_paren(r)
     else:
         return r

 def pp_expr(self, a, d, xs):
     self.visited = self.visited + 1
     if d > self.max_depth or self.visited > self.max_visited:
         return self.pp_ellipses()
     if z3.is_app(a):
         return self.pp_app(a, d, xs)
     elif z3.is_quantifier(a):
         return self.pp_quantifier(a, d, xs)
     elif z3.is_var(a):
         return self.pp_var(a, d, xs)
     else:
         return to_format(self.pp_unknown())

 def existVars(self, v1, v2):
     """
     create a list of variables to be bound
     """
     v1_str = [str(v) for v in v1]
     v2_filtered = list()
     for v in v2:
         if z3.is_not(v):
             v2_filtered.append(v.children()[0])
         elif z3.is_app(v) and not z3.is_not(v):
             v2_filtered.append(v)
     for v in v2_filtered:
         if str(v) not in v1_str : v1.append(v)
     return v1

 def visitor(e, seen):
     if e in seen:
         return
     seen[e] = True
     yield e
     if is_app(e):
         for ch in e.children():
             for e in visitor(ch, seen):
                 yield e
         return
     if is_quantifier(e):
         for e in visitor(e.body(), seen):
             yield e
         return

def fp_add_cover (fp, pred, lemma, level=-1):
    # no trivial lemmas
    if z3.is_true (lemma): return

    assert (z3.is_app (pred))
    sub = []
    for i in range (0, pred.num_args ()):
        arg = pred.arg (i)
        sub.append ((arg,
                     z3.Var (i, arg.decl ().range ())))

    tlemma = z3.substitute (lemma, sub)
    if verbose:
        print "Lemma for ", pred.decl (), ": ", tlemma
    fp.add_cover (level, pred.decl (), tlemma)

 def pp_unary(self, a, d, xs):
     k  = a.decl().kind()
     p  = self.get_precedence(k)
     child    = a.children()[0]
     child_k  = None
     if z3.is_app(child):
         child_k = child.decl().kind()
     child_pp = self.pp_expr(child, d+1, xs)        
     if k != child_k and self.is_infix_unary(child_k):
         child_p = self.get_precedence(child_k)
         if p <= child_p:
             child_pp = self.add_paren(child_pp)
     if z3.is_quantifier(child):
         child_pp = self.add_paren(child_pp)
     name = self.pp_name(a)
     return compose(to_format(name), indent(_len(name), child_pp))

  def __init__ (self, vs):
    if z3.is_app (vs):
      vs = [vs]

    self._saved_vs = vs
    self._num_vars = len (vs)

    num_vars = self._num_vars

    self._vs = (z3.Ast * num_vars) ()
    for i in range (num_vars):
      self._vs [i] = vs[i].as_ast ()

    self._pats = (z3.Pattern * 0) ()
    self._num_pats = 0

    self._num_no_pats = 0
    self._no_pats = (z3.Ast * 0) ()

def find_atomic_terms (exp, terms = list (), seen = set ()):
  """ Finds all declarations in an expression """

  if (z3.is_quantifier (exp)):
    return find_atomic_terms (exp.body (), terms, seen)

  if not (z3.is_app (exp)) : return terms

  if z3AstRefKey (exp) in seen: return terms

  seen.add (z3AstRefKey (exp))
  decl = exp.decl ()

  # atomic term
  if decl.kind () == z3.Z3_OP_UNINTERPRETED:
    if z3AstRefKey (decl) not in seen:
      seen.add (z3AstRefKey (decl))
      terms.append (decl)
  # uninterpreted can also have kids
  for k in exp.children (): find_atomic_terms (k, terms, seen)
  return terms

def z3ExpChildGenerator (exp) :
  if z3.is_app (exp) :
    for i in range (exp.num_args ()) :
      yield exp.arg (i)

def getFirstConjunct (exp) :
  assert z3.is_app (exp)
  if z3.is_and (exp) : return exp.arg (0)
  else : return exp