def get_assumes_and_asserts(preconds_only):
assumes = []
asserts = []
macros = []
# for name,action in im.module.actions.iteritems():
# for sa in action.iter_subactions():
# if isinstance(sa,ia.AssumeAction):
# assumes.append((sa.args[0],sa))
# if isinstance(sa,ia.AssertAction):
# asserts.append((sa.args[0],sa))
# if isinstance(sa,ia.IfAction):
# asserts.append((sa.get_cond(),sa))
if preconds_only:
for name in im.module.before_export:
action = im.module.before_export[name]
triple = action.update(im.module, [])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[1]))
assumes.append((foo, action))
else:
for name in im.module.public_actions:
action = im.module.actions[name]
triple = action.update(im.module, [])
# print 'ivy_theory.py: triple[1]: {}'.format(triple[1])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[1]))
# print 'ivy_theory.py: foo (1): {}'.format(foo)
assumes.append((foo, action))
# print 'ivy_theory.py: triple[2]: {}'.format(triple[2])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[2]))
# print 'ivy_theory.py: foo (2): {}'.format(foo)
assumes.append((foo, action))
for ldf in im.module.definitions:
if ldf.formula.defines() not in ilu.symbols_ast(ldf.formula.rhs()):
macros.append((ldf.formula.to_constraint(), ldf))
else: # can't treat recursive definition as macro
assumes.append((ldf.formula.to_constraint(), ldf))
for ldf in im.module.labeled_axioms:
if not ldf.temporal:
assumes.append((ldf.formula, ldf))
for ldf in im.module.labeled_props:
if not ldf.temporal:
asserts.append((ldf.formula, ldf))
for ldf in im.module.labeled_conjs:
asserts.append((ldf.formula, ldf))
assumes.append((ldf.formula, ldf))
# TODO: check axioms, inits, conjectures
return assumes, asserts, macros
def get_assumes_and_asserts(preconds_only):
assumes = []
asserts = []
macros = []
# for name,action in im.module.actions.iteritems():
# for sa in action.iter_subactions():
# if isinstance(sa,ia.AssumeAction):
# assumes.append((sa.args[0],sa))
# if isinstance(sa,ia.AssertAction):
# asserts.append((sa.args[0],sa))
# if isinstance(sa,ia.IfAction):
# asserts.append((sa.get_cond(),sa))
if preconds_only:
for name in im.module.before_export:
action = im.module.before_export[name]
triple = action.update(im.module,[])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[1]))
assumes.append((foo,action))
else:
for name in im.module.public_actions:
action = im.module.actions[name]
triple = action.update(im.module,[])
# print 'ivy_theory.py: triple[1]: {}'.format(triple[1])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[1]))
# print 'ivy_theory.py: foo (1): {}'.format(foo)
assumes.append((foo,action))
# print 'ivy_theory.py: triple[2]: {}'.format(triple[2])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[2]))
# print 'ivy_theory.py: foo (2): {}'.format(foo)
assumes.append((foo,action))
for ldf in im.module.definitions:
if ldf.formula.defines() not in ilu.symbols_ast(ldf.formula.rhs()):
macros.append((ldf.formula.to_constraint(),ldf))
else: # can't treat recursive definition as macro
assumes.append((ldf.formula.to_constraint(),ldf))
for ldf in im.module.labeled_axioms:
if not ldf.temporal:
assumes.append((ldf.formula,ldf))
for ldf in im.module.labeled_props:
if not ldf.temporal:
asserts.append((ldf.formula,ldf))
for ldf in im.module.labeled_conjs:
asserts.append((ldf.formula,ldf))
assumes.append((ldf.formula,ldf))
# TODO: check axioms, inits, conjectures
return assumes,asserts,macros
def process_actions(self):
for name, action in self.mod.actions.iteritems():
# print(type(action))
# print ("action2: ", ia.action_def_to_str(name, action))
ag = ivy_art.AnalysisGraph()
pre = itp.State()
pre.clauses = lut.true_clauses()
# print(pre.to_formula())
post = ag.execute(action, pre)
history = ag.get_history(post)
clauses = lut.and_clauses(history.post)
f = self.get_formula(clauses)
conjuncts = clauses.fmlas
defn = lut.close_epr(lg.And(*conjuncts))
# print(defn)
# assert(0)
update = action.update(pre.domain, pre.in_scope)
sf = self.standardize_action(f, update[0], name)
self.add_new_constants(sf)
actname = "action_" + name
self.actions.add(actname)
res = (sf, actname, "action", name)
self.vmt[actname] = res
def process_actions(self):
if ivy_compiler.isolate.get():
st = ivy_compiler.isolate.get().split('.')[0]
else:
st = ''
st = [st, 'timeout', 'handle', 'recv']
for name in self.mod.public_actions:
print >> sys.stderr, "action:\t", name
if not (ivy_compiler.isolate.get() == None or any(s in name
for s in st)):
continue
action = ia.env_action(name)
# print ("action2: ", ia.action_def_to_str(name, action))
ag = ivy_art.AnalysisGraph()
pre = itp.State()
pre.clauses = lut.true_clauses()
# print(pre.to_formula())
with itp.EvalContext(check=False):
post = ag.execute(action, pre)
history = ag.get_history(post)
clauses = lut.and_clauses(history.post)
f = self.get_formula(clauses)
conjuncts = clauses.fmlas
defn = lut.close_epr(lg.And(*conjuncts))
# print(defn)
# assert(0)
update = action.update(pre.domain, pre.in_scope)
sf = self.standardize_action(f, update[0], name)
self.add_new_constants(sf, 'action')
actname = "action_" + name
self.actions.add(actname)
res = (sf, actname, "action", name)
self.vmt[actname] = res
def arg_remove_facts(node):
"""
Let the user choose facts to remove from an ARG node
"""
user_selection = yield UserSelectMultiple(
title='Remove Facts',
prompt='Select facts to remove from ARG node {}:'.format(node.id),
options=OrderedDict([(str(close_epr(x)), x)
for x in node.clauses.fmlas]),
)
if user_selection is None:
return
code = dedent('''
remove_facts(arg_node({!r}), *{!r})
''').strip().format(
node.id,
list(user_selection),
)
yield ExecuteNewCell(code)
def arg_remove_facts(node):
"""
Let the user choose facts to remove from an ARG node
"""
user_selection = yield UserSelectMultiple(
title='Remove Facts',
prompt='Select facts to remove from ARG node {}:'.format(node.id),
options=OrderedDict([
(str(close_epr(x)), x) for x in node.clauses.fmlas
]),
)
if user_selection is None:
return
code = dedent('''
remove_facts(arg_node({!r}), *{!r})
''').strip().format(
node.id,
list(user_selection),
)
yield ExecuteNewCell(code)
def get_assumes_and_asserts(preconds_only):
assumes = []
asserts = []
macros = []
# for name,action in im.module.actions.iteritems():
# for sa in action.iter_subactions():
# if isinstance(sa,ia.AssumeAction):
# assumes.append((sa.args[0],sa))
# if isinstance(sa,ia.AssertAction):
# asserts.append((sa.args[0],sa))
# if isinstance(sa,ia.IfAction):
# asserts.append((sa.get_cond(),sa))
if preconds_only:
for name in im.module.before_export:
action = im.module.before_export[name]
triple = action.update(im.module, [])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[1]))
assumes.append((foo, action))
else:
for name in im.module.public_actions:
action = im.module.actions[name]
triple = action.update(im.module, [])
# print 'ivy_theory.py: triple[1]: {}'.format(triple[1])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[1]))
# print 'ivy_theory.py: foo (1): {}'.format(foo)
assumes.append((foo, action))
# print 'ivy_theory.py: triple[2]: {}'.format(triple[2])
foo = ilu.close_epr(ilu.clauses_to_formula(triple[2]))
# print 'ivy_theory.py: foo (2): {}'.format(foo)
assumes.append((foo, action))
for ldf in im.module.definitions:
if not isinstance(ldf.formula, il.DefinitionSchema):
if (ldf.formula.defines() not in ilu.symbols_ast(ldf.formula.rhs())
and not isinstance(ldf.formula.rhs(), il.Some)):
# print 'macro : {}'.format(ldf.formula)
macros.append((ldf.formula, ldf))
else: # can't treat recursive definition as macro
# print 'axiom : {}'.format(ldf.formula)
assumes.append((ldf.formula.to_constraint(), ldf))
for ldf in im.module.labeled_axioms:
if not ldf.temporal:
# print 'axiom : {}'.format(ldf.formula)
assumes.append((ldf.formula, ldf))
pfs = set(lf.id for lf, p in im.module.proofs)
sgs = set(x.id for x, y in im.module.subgoals)
for ldf in im.module.labeled_props:
if not ldf.temporal:
# print 'prop : {}{} {}'.format(ldf.lineno,ldf.label,ldf.formula)
if ldf.id not in pfs:
asserts.append((ldf.formula, ldf))
elif ldf.id in sgs and not ldf.explicit:
assumes.append((ldf.formula, ldf))
for ldf in im.module.labeled_conjs:
asserts.append((ldf.formula, ldf))
assumes.append((ldf.formula, ldf))
for ldf in im.module.assumed_invariants:
if not ldf.explicit:
assumes.append((ldf.formula, ldf))
# TODO: check axioms, inits, conjectures
# for x in assumes:
# print 'assume: {}'.format(x[0])
# for x in asserts:
# print 'assert: {}'.format(x[0])
# for x in macros:
# print 'macro: {}'.format(x[0])
return assumes, asserts, macros
