def prime_equillibrium(vocab, signature, aux=set()):
"""
Generates the formula:
x = x' & y = y' & n* = n*' & ...
for all the symbols in the vocabulary
@param vocab symbols to process
@param signature a (sorted) signature
@param aux symbols to skip
"""
res = []
vocab_prime = vocab.prime()
for v, vprime in vocab_prime.locals:
# HACK: Exclude non-deterministic variables
if v.literal.startswith('nondet') or v in aux: continue
if tuple(signature.sorts[v][0].from_) == ("V", "V"):
f = FolFormula(eqrel, [FolFormula(v), FolFormula(vprime)])
elif tuple(signature.sorts[v][0].from_) == ("V", ):
f = FolFormula(eqpred, [FolFormula(v), FolFormula(vprime)])
else:
f = FolFormula(FolWithEquality.eq,
[FolFormula(v), FolFormula(vprime)])
res.append(f)
return FolFormula.conjunction(res), vocab_prime
def transition_system(syn, loop, vocab, signature):
fin, vocab_prime = prime_equillibrium(vocab, signature)
L = syn.expansion.parser
rho = FolScheme(L * 'wp_ea([?loopBody],[?trans])')(loop.body, fin)
rho0 = FolFormula.conjunction(syn.first_pass([rho]))
# set back in time; x->x0, x'->x
rho0 = vocab.to_past(rho0)
rho0 = vocab_prime.to_past(rho0)
return rho0
def generate_p_properties(syn, consts, vocab):
"""
Extra properties: {n(u,v) | u,v program variables + null}
"""
ptot_template = FolFormula.conjunction(
map(FolScheme, syn.expansion("ptot_([?u],[?v])")))
extras = [('p%s%s' % (u, v), ptot_template(u, v)) for u in consts
for v in consts]
return AbstractionProperties.from_named_formulas(extras, vocab)
def formula(self, fol_formula):
if isinstance(fol_formula, (str, unicode)):
fol_formula = FolFormula.conjunction(self.expansion([fol_formula]))
f_aux = AuxTransformers.renumber_bound_vars(fol_formula)
return fol_formula_to_z3(f_aux, self.z3_decls)
def generate_gamma(syn, preds, decls):
dtca = Identifier('dtca', '?')
starred = [z for z in preds if '*' in z.literal]
gamma = FolFormula.conjunction(
[FolFormula(dtca, [FolFormula(z)]) for z in starred])
return generate_z3_condition(gamma, syn, decls)
def generate_z3_condition(folformula, syn, decls):
c = list(syn.first_pass([folformula]))
f = FolFormula.conjunction(c)
f_aux = AuxTransformers.renumber_bound_vars(f)
f_z3 = fol_formula_to_z3(f_aux, decls)
return hoist_forall(f_z3)
def __call__(self, program):
wps = WeakestPreSynthesis()
wps.configure(detptr_libraries())
wps.syn.libs += [self.VC] #TODO - change
formulas , decls = wps_formula_get(wps,program)
I_args = inv_args_get(wps, "I")
formula = FolFormula.conjunction(formulas)
prefix = wp_forall_prefix_get(formula)| set([Identifier('null', 'const')])
bounded_prefix = AuxTransformers.get_all_bound_vars(formula)
prefix-=bounded_prefix
pprint( formulas )
print prefix
z3_formulas_with_blasting = []
from shape2horn import hoist_forall
from shape2horn import blast_horn
from shape2horn import hoist_horn
formulas_with_implies = []
ackm_bools = {}
ackm_bools_to_vars = {}
#sanity = FormulaSanity()
watch = Stopwatch()
with watch:
for f in formulas:
if f.root == 'true':
continue
head = f.subtrees[1]
body = f.subtrees[0]
head_ls = FolFormula.split(head) #splits conjunctions in head
for i in head_ls:
#creates new formulas of form: body -> i
f_with_implies = create_f_with_implies(body,i)
formulas_with_implies.append( f_with_implies )
for s in formulas_with_implies:
print '-------- Input Clause ----------------'
print s
s_with_gamma = gamma_add( s )
#renumber_bound_vars() renames bounded vars to unique numbers
s_with_gamma = AuxTransformers.renumber_bound_vars( s_with_gamma )
print s_with_gamma
z3_f = transform_formula_to_z3(prefix, s_with_gamma, decls)
for f in hoist_horn(z3_f[0]):
z3_f_hoisted = hoist_forall(f)
print '-------- Hoisted Formula ------------------'
print z3_f_hoisted
blasted_f = blast_horn(z3_f_hoisted)
print '-------- Blasted Formula ---------------------'
#print blasted_f
if 0:
blasted_f_with_replaced_n = replace_nstar_with_bools( blasted_f, \
decls, ackm_bools, ackm_bools_to_vars )
f_with_ackm_reduction = ackerman_reduction_get( \
blasted_f_with_replaced_n , ackm_bools_to_vars )
#print ackm_bools_to_vars
z3_formulas_with_blasting.append( blasted_f )
#benchmark_print_to_file(h, z3_formulas_with_blasting)
formulas_solver ( self, z3_formulas_with_blasting, decls["I"], I_args )
print 'Total sovling time: ',watch.total_time,'sec'
def conjunct_formulas( fs ):
return FolFormula.conjunction( fs )
def conjunct_formulas( fs ):
return FolFormula.conjunction( fs )
