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