本文整理汇总了Python中z3.is_quantifier函数的典型用法代码示例。如果您正苦于以下问题：Python is_quantifier函数的具体用法？Python is_quantifier怎么用？Python is_quantifier使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了is_quantifier函数的16个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的Python代码示例。
示例1: fp_get_preds
def fp_get_preds (fp):
seen = set ()
res = list ()
for rule in fp.get_rules ():
pred = rule
# A rule is of the form
# FORALL? (BODY IMPLIES)? PRED
if z3.is_quantifier (pred): pred = pred.body ()
if is_implies (pred): pred = pred.arg (1)
decl = pred.decl ()
assert is_uninterpreted (decl)
if z3key (decl) in seen: continue
seen.add (z3key (decl))
# if the rule contains a universal quantifier, replace
# variables by properly named constants
if z3.is_quantifier (rule):
sub = [ z3.Const (bound_var_name (rule, i),
bound_var_sort (rule, i))
for i in range (0, rule.num_vars ()) ]
pred = substitute_vars (pred, *sub)
res.append (pred)
return res
开发者ID:coco-team，项目名称:zustre，代码行数:25，代码来源:utils.py
示例2: num_univ_clauses
def num_univ_clauses(formula):
if z3.is_and(formula):
fs = formula.children()
n = 0
for f in fs:
if z3.is_quantifier(f) and f.is_forall():
n += 1
return n
elif z3.is_quantifier(formula) and formula.is_forall():
return 1
else:
return 0
开发者ID:jamella，项目名称:ivy，代码行数:12，代码来源:ivy_updr.py
示例3: infix_args_core
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
开发者ID:Moondee，项目名称:Artemis，代码行数:31，代码来源:z3printer.py
示例4: run
def run(self, query_index):
self.fp.set (engine='spacer')
if self.args.stat:
self.fp.set('print_statistics',True)
if self.args.z3_verbose:
z3.set_option (verbose=1)
if self.args.utvpi: self.fp.set('pdr.utvpi', False)
self.fp.set('use_heavy_mev',True)
self.fp.set('pdr.flexible_trace',True)
self.fp.set('reset_obligation_queue',False)
self.fp.set('spacer.elim_aux',False)
if not self.args.pp:
self.log.info("No pre-processing")
self.fp.set ('xform.slice', False)
self.fp.set ('xform.inline_linear',False)
self.fp.set ('xform.inline_eager',False)
queries = self.fp.parse_file (self.smt2_file)
self.preds = get_preds(self.fp)
out = ""
query = queries[query_index]
if z3.is_quantifier(query):
decl = query.body().decl()
self.function_name = str(decl).split("@")[0]
out = self.checkFeas(query)
return out
else:
function_name = str(query.decl()).split("@")[0]
out = out_message % (function_name, "FEASIBLE", "", "", "", "", "")
out = bcolors.OKGREEN + out + bcolors.ENDC
return out
开发者ID:edmcman，项目名称:seahorn，代码行数:30，代码来源:par_inc.py
示例5: stripQuantifierBlock
def stripQuantifierBlock (expr) :
""" strips the outermost quantifier block in a given expression and returns
the pair (<list of consts replacing free vars>,
<body with consts substituted for de-bruijn variables>)
Example:
assume expr.is_forall ()
vars, body = strip_quantifier (expr)
qexpr = z3.ForAll (vars, body)
assert qexpr.eq (expr)
"""
if not z3.is_quantifier (expr) : return ([], expr)
global qb_counter
z3ctx = expr.ctx
consts = list ()
# outside-in order of variables; z3 numbers variables inside-out but
# substitutes outside-in
for i in reversed (range (expr.num_vars ())) :
#v_name = expr.var_name (i) + "!" + str(qb_counter)
v_name = expr.var_name (i)
qb_counter+=1
v_sort = expr.var_sort (i)
consts.append (z3.Const (v_name, z3_translate (v_sort, z3ctx)))
matrix = z3.substitute_vars (expr.body (), *consts)
return (consts, matrix)
开发者ID:edmcman，项目名称:seahorn，代码行数:26，代码来源:z3_utils.py
示例6: translate
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)
开发者ID:leodemoura，项目名称:boole，代码行数:32，代码来源:z3_interface.py
示例7: __init__
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)
开发者ID:bspar1，项目名称:seahorn_cos597b，代码行数:57，代码来源:rule.py
示例8: pp_expr
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())
开发者ID:Moondee，项目名称:Artemis，代码行数:12，代码来源:z3printer.py
示例9: visitor
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
开发者ID:AndriyLin，项目名称:Utils，代码行数:14，代码来源:z3.py
示例10: pp_unary
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))
开发者ID:Moondee，项目名称:Artemis，代码行数:16，代码来源:z3printer.py
示例11: solve
def solve(self, smt2_file):
"""
Start solving
"""
self.fp.set (engine='spacer')
if self.args.stat:
self.fp.set('print_statistics',True)
if self.args.z3_verbose:
z3.set_option (verbose=1)
self.fp.set('use_heavy_mev',True)
self.fp.set('pdr.flexible_trace',True)
self.fp.set('reset_obligation_queue',False)
self.fp.set('spacer.elim_aux',False)
if self.args.utvpi: self.fp.set('pdr.utvpi', False)
if not self.args.pp:
self.fp.set ('xform.slice', False)
self.fp.set ('xform.inline_linear',False)
self.fp.set ('xform.inline_eager',False)
with stats.timer ('Parse'):
queries = self.fp.parse_file (smt2_file)
stats.stop('Parse')
self.preds = get_preds(self.fp)
n_function = len(queries)
stat("Function_Numbers", n_function)
# TODO: Put them in a multithreading function
all_results = ""
for q in queries:
if z3.is_quantifier(q):
decl = q.body().decl()
function_name = str(decl).split("@")[0]
try:
out = self.checkFeasibility(q, function_name)
all_results += out + "\n-----------------------\n"
except Exception as e:
print "Solving " + function_name
else:
function_name = str(q.decl()).split("@")[0]
out = out_message % (function_name, "CONSISTENT", "", "Trivial", "")
all_results += bcolors.OKGREEN + out + bcolors.ENDC
print "\n\t ========= SEAHORN INCONSISTENCY RESULTS ========"
print all_results
开发者ID:edmcman，项目名称:seahorn，代码行数:41，代码来源:inc.py
示例12: find_atomic_terms
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
开发者ID:edmcman，项目名称:seahorn，代码行数:21，代码来源:z3_utils.py
示例13: _back_single_term
def _back_single_term(self, expr, args, model=None):
assert z3.is_expr(expr)
if z3.is_quantifier(expr):
raise NotImplementedError(
"Quantified back conversion is currently not supported")
assert not len(args) > 2 or \
(z3.is_and(expr) or z3.is_or(expr) or
z3.is_add(expr) or z3.is_mul(expr) or
(len(args) == 3 and (z3.is_ite(expr) or z3.is_array_store(expr)))),\
"Unexpected n-ary term: %s" % expr
res = None
try:
decl = z3.Z3_get_app_decl(expr.ctx_ref(), expr.as_ast())
kind = z3.Z3_get_decl_kind(expr.ctx.ref(), decl)
# Try to get the back-conversion function for the given Kind
fun = self._back_fun[kind]
return fun(args, expr)
except KeyError as ex:
pass
if z3.is_const(expr):
# Const or Symbol
if z3.is_rational_value(expr):
n = expr.numerator_as_long()
d = expr.denominator_as_long()
f = Fraction(n, d)
return self.mgr.Real(f)
elif z3.is_int_value(expr):
n = expr.as_long()
return self.mgr.Int(n)
elif z3.is_bv_value(expr):
n = expr.as_long()
w = expr.size()
return self.mgr.BV(n, w)
elif z3.is_as_array(expr):
if model is None:
raise NotImplementedError("As-array expressions cannot be" \
" handled as they are not " \
"self-contained")
else:
interp_decl = z3.get_as_array_func(expr)
interp = model[interp_decl]
default = self.back(interp.else_value(), model=model)
assign = {}
for i in xrange(interp.num_entries()):
e = interp.entry(i)
assert e.num_args() == 1
idx = self.back(e.arg_value(0), model=model)
val = self.back(e.value(), model=model)
assign[idx] = val
arr_type = self._z3_to_type(expr.sort())
return self.mgr.Array(arr_type.index_type, default, assign)
elif z3.is_algebraic_value(expr):
# Algebraic value
return self.mgr._Algebraic(Numeral(expr))
else:
# it must be a symbol
try:
return self.mgr.get_symbol(str(expr))
except UndefinedSymbolError:
import warnings
symb_type = self._z3_to_type(expr.sort())
warnings.warn("Defining new symbol: %s" % str(expr))
return self.mgr.FreshSymbol(symb_type,
template="__z3_%d")
elif z3.is_function(expr):
# This needs to be after we try to convert regular Symbols
fsymbol = self.mgr.get_symbol(expr.decl().name())
return self.mgr.Function(fsymbol, args)
# If we reach this point, we did not manage to translate the expression
raise ConvertExpressionError(message=("Unsupported expression: %s" %
(str(expr))),
expression=expr)
开发者ID:mpreiner，项目名称:pysmt，代码行数:77，代码来源:z3.py
示例14: _back_single_term
def _back_single_term(self, expr, args):
assert z3.is_expr(expr)
if z3.is_quantifier(expr):
raise NotImplementedError(
"Quantified back conversion is currently not supported")
res = None
if z3.is_and(expr):
res = self.mgr.And(args)
elif z3.is_or(expr):
res = self.mgr.Or(args)
elif z3.is_add(expr):
res = self.mgr.Plus(args)
elif z3.is_div(expr):
res = self.mgr.Div(args[0], args[1])
elif z3.is_eq(expr):
if self._get_type(args[0]).is_bool_type():
res = self.mgr.Iff(args[0], args[1])
else:
res = self.mgr.Equals(args[0], args[1])
elif z3.is_iff(expr):
res = self.mgr.Iff(args[0], args[1])
elif z3.is_xor(expr):
res = self.mgr.Xor(args[0], args[1])
elif z3.is_false(expr):
res = self.mgr.FALSE()
elif z3.is_true(expr):
res = self.mgr.TRUE()
elif z3.is_gt(expr):
res = self.mgr.GT(args[0], args[1])
elif z3.is_ge(expr):
res = self.mgr.GE(args[0], args[1])
elif z3.is_lt(expr):
res = self.mgr.LT(args[0], args[1])
elif z3.is_le(expr):
res = self.mgr.LE(args[0], args[1])
elif z3.is_mul(expr):
res = self.mgr.Times(args[0], args[1])
elif z3.is_uminus(expr):
tp = self._get_type(args[0])
if tp.is_real_type():
minus_one = self.mgr.Real(-1)
else:
assert tp.is_int_type()
minus_one = self.mgr.Int(-1)
res = self.mgr.Times(args[0], minus_one)
elif z3.is_sub(expr):
res = self.mgr.Minus(args[0], args[1])
elif z3.is_not(expr):
res = self.mgr.Not(args[0])
elif z3.is_implies(expr):
res = self.mgr.Implies(args[0], args[1])
elif z3.is_quantifier(expr):
raise NotImplementedError
elif z3.is_const(expr):
if z3.is_rational_value(expr):
n = expr.numerator_as_long()
d = expr.denominator_as_long()
f = Fraction(n, d)
res = self.mgr.Real(f)
elif z3.is_int_value(expr):
n = expr.as_long()
res = self.mgr.Int(n)
elif z3.is_bv_value(expr):
n = expr.as_long()
w = expr.size()
res = self.mgr.BV(n, w)
else:
# it must be a symbol
res = self.mgr.get_symbol(str(expr))
elif z3.is_ite(expr):
res = self.mgr.Ite(args[0], args[1], args[2])
elif z3.is_function(expr):
res = self.mgr.Function(self.mgr.get_symbol(expr.decl().name()), args)
elif z3.is_to_real(expr):
res = self.mgr.ToReal(args[0])
elif z3.is_bv_and(expr):
res = self.mgr.BVAnd(args[0], args[1])
elif z3.is_bv_or(expr):
res = self.mgr.BVOr(args[0], args[1])
elif z3.is_bv_xor(expr):
res = self.mgr.BVXor(args[0], args[1])
elif z3.is_bv_not(expr):
res = self.mgr.BVNot(args[0])
elif z3.is_bv_neg(expr):
res = self.mgr.BVNeg(args[0])
elif z3.is_bv_concat(expr):
res = self.mgr.BVConcat(args[0], args[1])
elif z3.is_bv_ult(expr):
res = self.mgr.BVULT(args[0], args[1])
elif z3.is_bv_uleq(expr):
res = self.mgr.BVULE(args[0], args[1])
elif z3.is_bv_slt(expr):
res = self.mgr.BVSLT(args[0], args[1])
elif z3.is_bv_sleq(expr):
res = self.mgr.BVSLE(args[0], args[1])
elif z3.is_bv_ugt(expr):
res = self.mgr.BVUGT(args[0], args[1])
elif z3.is_bv_ugeq(expr):
#.........这里部分代码省略.........
开发者ID:bogiebro，项目名称:pysmt，代码行数:101，代码来源:z3.py
示例15: getFunctionName
def getFunctionName(self, query):
if z3.is_quantifier(query):
decl = query.body().decl()
return str(decl).split("@")[0]
else:
return str(query.decl()).split("@")[0]
开发者ID:edmcman，项目名称:seahorn，代码行数:6，代码来源:par_inc.py
示例16: _back_single_term
def _back_single_term(self, expr, args, model=None):
assert z3.is_expr(expr)
if z3.is_quantifier(expr):
raise NotImplementedError(
"Quantified back conversion is currently not supported")
res = None
if z3.is_and(expr):
res = self.mgr.And(args)
elif z3.is_or(expr):
res = self.mgr.Or(args)
elif z3.is_add(expr):
res = self.mgr.Plus(args)
elif z3.is_div(expr):
res = self.mgr.Div(args[0], args[1])
elif z3.is_eq(expr):
if self._get_type(args[0]).is_bool_type():
res = self.mgr.Iff(args[0], args[1])
else:
res = self.mgr.Equals(args[0], args[1])
elif z3.is_iff(expr):
res = self.mgr.Iff(args[0], args[1])
elif z3.is_xor(expr):
res = self.mgr.Xor(args[0], args[1])
elif z3.is_false(expr):
res = self.mgr.FALSE()
elif z3.is_true(expr):
res = self.mgr.TRUE()
elif z3.is_gt(expr):
res = self.mgr.GT(args[0], args[1])
elif z3.is_ge(expr):
res = self.mgr.GE(args[0], args[1])
elif z3.is_lt(expr):
res = self.mgr.LT(args[0], args[1])
elif z3.is_le(expr):
res = self.mgr.LE(args[0], args[1])
elif z3.is_mul(expr):
res = self.mgr.Times(args[0], args[1])
elif z3.is_uminus(expr):
tp = self._get_type(args[0])
if tp.is_real_type():
minus_one = self.mgr.Real(-1)
else:
assert tp.is_int_type()
minus_one = self.mgr.Int(-1)
res = self.mgr.Times(args[0], minus_one)
elif z3.is_sub(expr):
res = self.mgr.Minus(args[0], args[1])
elif z3.is_not(expr):
res = self.mgr.Not(args[0])
elif z3.is_implies(expr):
res = self.mgr.Implies(args[0], args[1])
elif z3.is_quantifier(expr):
raise NotImplementedError
elif z3.is_const(expr):
if z3.is_rational_value(expr):
n = expr.numerator_as_long()
d = expr.denominator_as_long()
f = Fraction(n, d)
res = self.mgr.Real(f)
elif z3.is_int_value(expr):
n = expr.as_long()
res = self.mgr.Int(n)
elif z3.is_bv_value(expr):
n = expr.as_long()
w = expr.size()
res = self.mgr.BV(n, w)
elif z3.is_as_array(expr):
if model is None:
raise NotImplementedError("As-array expressions cannot be" \
" handled as they are not " \
"self-contained")
else:
interp_decl = z3.get_as_array_func(expr)
interp = model[interp_decl]
default = self.back(interp.else_value(), model=model)
assign = {}
for i in xrange(interp.num_entries()):
e = interp.entry(i)
assert e.num_args() == 1
idx = self.back(e.arg_value(0), model=model)
val = self.back(e.value(), model=model)
assign[idx] = val
arr_type = self._z3_to_type(expr.sort())
res = self.mgr.Array(arr_type.index_type, default, assign)
elif z3.is_algebraic_value(expr):
# Algebraic value
return self.mgr._Algebraic(Numeral(expr))
else:
# it must be a symbol
res = self.mgr.get_symbol(str(expr))
elif z3.is_ite(expr):
res = self.mgr.Ite(args[0], args[1], args[2])
elif z3.is_function(expr):
res = self.mgr.Function(self.mgr.get_symbol(expr.decl().name()), args)
elif z3.is_to_real(expr):
res = self.mgr.ToReal(args[0])
elif z3.is_bv_and(expr):
res = self.mgr.BVAnd(args[0], args[1])
#.........这里部分代码省略.........
开发者ID:0Chuzz，项目名称:pysmt，代码行数:101，代码来源:z3.py
注：本文中的z3.is_quantifier函数示例由纯净天空整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。 |
客服电话
APP下载
官方微信
请发表评论