def compose_updates(update1,axioms,update2):
updated1, clauses1, pre1 = update1
updated2, clauses2, pre2 = update2
clauses2 = rename_distinct(clauses2,clauses1)
pre2 = rename_distinct(pre2,clauses1)
# print "clauses2 = {}".format(clauses2)
us1 = set(updated1)
us2 = set(updated2)
mid = us1.intersection(us2)
mid_ax = clauses_using_symbols(mid,axioms)
used = used_symbols_clauses(and_clauses(clauses1,clauses2))
rn = UniqueRenamer('__m_',used)
map1 = dict()
map2 = dict()
for v in updated1:
map2[v] = new(v)
for mv in mid:
mvf = rename(mv,rn)
map1[new(mv)] = mvf
map2[mv] = mvf
clauses1 = rename_clauses(clauses1,map1)
new_clauses = and_clauses(clauses1, rename_clauses(and_clauses(clauses2,mid_ax),map2))
new_updated = list(us1.union(us2))
# print "pre1 before = {}".format(pre1)
pre1 = and_clauses(pre1,diff_frame(updated1,updated2,None,new)) # keep track of post-state of assertion failure
# print "pre1 = {}".format(pre1)
new_pre = or_clauses(pre1,and_clauses(clauses1,rename_clauses(and_clauses(pre2,mid_ax),map2)))
# print "new_pre = {}".format(new_pre)
return (new_updated,new_clauses,new_pre)
def compose_updates(update1, axioms, update2):
updated1, clauses1, pre1 = update1
updated2, clauses2, pre2 = update2
clauses2 = rename_distinct(clauses2, clauses1)
pre2 = rename_distinct(pre2, clauses1)
# print "clauses2 = {}".format(clauses2)
us1 = set(updated1)
us2 = set(updated2)
mid = us1.intersection(us2)
mid_ax = clauses_using_symbols(mid, axioms)
used = used_symbols_clauses(and_clauses(clauses1, clauses2))
rn = UniqueRenamer('__m_', used)
map1 = dict()
map2 = dict()
for v in updated1:
map2[v] = new(v)
for mv in mid:
mvf = rename(mv, rn)
map1[new(mv)] = mvf
map2[mv] = mvf
clauses1 = rename_clauses(clauses1, map1)
new_clauses = and_clauses(
clauses1, rename_clauses(and_clauses(clauses2, mid_ax), map2))
new_updated = list(us1.union(us2))
# print "pre1 before = {}".format(pre1)
pre1 = and_clauses(
pre1, diff_frame(updated1, updated2, None,
new)) # keep track of post-state of assertion failure
# print "pre1 = {}".format(pre1)
new_pre = or_clauses(
pre1,
and_clauses(clauses1, rename_clauses(and_clauses(pre2, mid_ax), map2)))
# print "new_pre = {}".format(new_pre)
return (new_updated, new_clauses, new_pre)
def reverse_image(post_state,axioms,update):
updated, clauses, _precond = update
post_ax = clauses_using_symbols(updated,axioms)
post_clauses = conjoin(post_state,post_ax)
post_clauses = rename_clauses(post_clauses, dict((x,new(x)) for x in updated))
post_updated = [new(s) for s in updated]
res = exist_quant(post_updated,conjoin(clauses,post_clauses))
# res = simplify_clauses(res)
return res
def forward_image_map(pre_state, axioms, update):
updated, clauses, _precond = update
# print "transition_relation: {}".format(clauses)
pre_ax = clauses_using_symbols(updated, axioms)
pre = conjoin(pre_state, pre_ax)
map1, res = exist_quant_map(updated, conjoin(pre, clauses))
res = rename_clauses(res, dict((new(x), x) for x in updated))
## print "before simp: %s" % res
# res = simplify_clauses(res)
return map1, res
def forward_image_map(pre_state,axioms,update):
updated, clauses, _precond = update
# print "transition_relation: {}".format(clauses)
pre_ax = clauses_using_symbols(updated,axioms)
pre = conjoin(pre_state,pre_ax)
map1,res = exist_quant_map(updated,conjoin(pre,clauses))
res = rename_clauses(res, dict((new(x),x) for x in updated))
## print "before simp: %s" % res
# res = simplify_clauses(res)
return map1,res
def reverse_image(post_state,update):
assert isinstance(post_state,Clauses) and isinstance(update,SemActionValue)
updated, clauses, _precond = update.comps
axioms = im.background_theory()
post_ax = clauses_using_symbols(updated,axioms)
post_clauses = conjoin(post_state,post_ax)
post_clauses = rename_clauses(post_clauses, dict((x,new(x)) for x in updated))
post_updated = [new(s) for s in updated]
res = exist_quant(post_updated,conjoin(clauses,post_clauses))
# res = simplify_clauses(res)
return res
def forward_image_map(pre_state,update):
assert isinstance(pre_state,Clauses) and isinstance(update,SemActionValue)
updated, clauses, _precond = update.comps
# print "transition_relation: {}".format(clauses)
axioms = im.background_theory()
pre_ax = clauses_using_symbols(updated,axioms)
pre = conjoin(pre_state,pre_ax)
map1,res = exist_quant_map(updated,conjoin(pre,clauses))
res = rename_clauses(res, dict((new(x),x) for x in updated))
## print "before simp: %s" % res
# res = simplify_clauses(res)
return map1,res
def reverse_image(post_state, update):
assert isinstance(post_state, Clauses) and isinstance(
update, SemActionValue)
updated, clauses, _precond = update.comps
axioms = im.background_theory()
post_ax = clauses_using_symbols(updated, axioms)
post_clauses = conjoin(post_state, post_ax)
post_clauses = rename_clauses(post_clauses,
dict((x, new(x)) for x in updated))
post_updated = [new(s) for s in updated]
res = exist_quant(post_updated, conjoin(clauses, post_clauses))
# res = simplify_clauses(res)
return res
def forward_image_map(pre_state, update):
assert isinstance(pre_state, Clauses) and isinstance(
update, SemActionValue)
updated, clauses, _precond = update.comps
# print "transition_relation: {}".format(clauses)
axioms = im.background_theory()
pre_ax = clauses_using_symbols(updated, axioms)
pre = conjoin(pre_state, pre_ax)
map1, res = exist_quant_map(updated, conjoin(pre, clauses))
res = rename_clauses(res, dict((new(x), x) for x in updated))
## print "before simp: %s" % res
# res = simplify_clauses(res)
return map1, res
def compose_updates(update1, axioms, update2):
updated1, clauses1, pre1 = update1
updated2, clauses2, pre2 = update2
clauses2 = rename_distinct(clauses2, clauses1)
pre2 = rename_distinct(pre2, clauses1)
# print "clauses2 = {}".format(clauses2)
us1 = set(updated1)
us2 = set(updated2)
mid = us1.intersection(us2)
mid_ax = clauses_using_symbols(mid, axioms)
used = used_symbols_clauses(and_clauses(clauses1, clauses2))
used.update(symbols_clauses(pre1))
used.update(symbols_clauses(pre2))
rn = UniqueRenamer('__m_', used)
map1 = dict()
map2 = dict()
for v in updated1:
map2[v] = new(v)
for mv in mid:
mvf = rename(mv, rn)
map1[new(mv)] = mvf
map2[mv] = mvf
# iu.dbg('clauses1')
# iu.dbg('clauses1.annot')
clauses1 = rename_clauses(clauses1, map1)
annot_op = lambda x, y: x.compose(
y) if x is not None and y is not None else None
new_clauses = and_clauses(clauses1,
rename_clauses(and_clauses(clauses2, mid_ax),
map2),
annot_op=annot_op)
new_updated = list(us1.union(us2))
# print "pre1 before = {}".format(pre1)
# iu.dbg('pre1.annot')
# iu.dbg('pre1')
pre1 = and_clauses(pre1, diff_frame(
updated1, updated2, new,
axioms)) # keep track of post-state of assertion failure
# print "pre1 = {}".format(pre1)
temp = and_clauses(clauses1,
rename_clauses(and_clauses(pre2, mid_ax), map2),
annot_op=my_annot_op)
# iu.dbg('temp.annot')
new_pre = or_clauses(pre1, temp)
# iu.dbg('new_pre.annot')
# print "new_pre = {}".format(new_pre)
# iu.dbg('new_clauses')
# iu.dbg('new_clauses.annot')
return (new_updated, new_clauses, new_pre)
def compose_updates(update1,axioms,update2):
updated1, clauses1, pre1 = update1
updated2, clauses2, pre2 = update2
clauses2 = rename_distinct(clauses2,clauses1)
pre2 = rename_distinct(pre2,clauses1)
# print "clauses2 = {}".format(clauses2)
us1 = set(updated1)
us2 = set(updated2)
mid = us1.intersection(us2)
mid_ax = clauses_using_symbols(mid,axioms)
used = used_symbols_clauses(and_clauses(clauses1,clauses2))
rn = UniqueRenamer('__m_',used)
map1 = dict()
map2 = dict()
for v in updated1:
map2[v] = new(v)
for mv in mid:
mvf = rename(mv,rn)
map1[new(mv)] = mvf
map2[mv] = mvf
# iu.dbg('clauses1')
# iu.dbg('clauses1.annot')
clauses1 = rename_clauses(clauses1,map1)
annot_op = lambda x,y: x.compose(y) if x is not None and y is not None else None
new_clauses = and_clauses(clauses1, rename_clauses(and_clauses(clauses2,mid_ax),map2),annot_op=annot_op)
new_updated = list(us1.union(us2))
# print "pre1 before = {}".format(pre1)
# iu.dbg('pre1.annot')
# iu.dbg('pre1')
pre1 = and_clauses(pre1,diff_frame(updated1,updated2,None,new)) # keep track of post-state of assertion failure
# print "pre1 = {}".format(pre1)
temp = and_clauses(clauses1,rename_clauses(and_clauses(pre2,mid_ax),map2),annot_op=my_annot_op)
# iu.dbg('temp.annot')
new_pre = or_clauses(pre1,temp)
# iu.dbg('new_pre.annot')
# print "new_pre = {}".format(new_pre)
# iu.dbg('new_clauses')
# iu.dbg('new_clauses.annot')
return (new_updated,new_clauses,new_pre)
def add_post_axioms(update, axioms):
map = dict((sym, new(sym)) for sym in update[0])
syms = set(update[0])
post_ax = clauses_using_symbols(syms, axioms)
return (update[0], and_clauses(update[1], rename_clauses(post_ax,
map)), update[2])
