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 implies(s1, s2): assert isinstance(s1, SemValue) and type(s1) is type(s2) op = s1.op axioms = im.background_theory() u1, c1, p1 = s1.comps u2, c2, p2 = s2.comps if u1 == None and u2 != None: return False # print "c1: {}".format(c1) # print "axioms: {}".format(axioms) # print "df: {}".format(diff_frame(u1,u2,relations,op)) c1 = and_clauses(c1, axioms, diff_frame(u1, u2, op)) if isinstance(c2, Clauses): if not c2.is_universal_first_order( ) or not p2.is_universal_first_order(): return False c2 = and_clauses(c2, diff_frame(u2, u1, op)) return clauses_imply(p1, p2) and clauses_imply(c1, c2) else: if not is_prenex_universal(c2) or not is_prenex_universal(p2): return False c2 = And(c2, clauses_to_formula(diff_frame(u2, u1, op))) return clauses_imply_formula_cex(p1, p2) and clauses_imply_formula_cex( c1, c2)
def set_state(self,clauses,recomp=True,clear_constraints=False,reset=False): self.state = clauses if clear_constraints: self.concept_session.suppose_constraints = [] if reset: self.reset() self.concept_session.state = ilu.clauses_to_formula(clauses) self.state_changed(recomp)
def set_state(self, clauses, recomp=True, clear_constraints=False, reset=False): self.state = clauses if clear_constraints: self.concept_session.suppose_constraints = [] if reset: self.reset() self.concept_session.state = ilu.clauses_to_formula(clauses) self.state_changed(recomp)
def implies(s1,s2,axioms,relations,op): u1,c1,p1 = s1 u2,c2,p2 = s2 if u1 == None and u2 != None: return False # print "c1: {}".format(c1) # print "axioms: {}".format(axioms) # print "df: {}".format(diff_frame(u1,u2,relations,op)) c1 = and_clauses(c1,axioms,diff_frame(u1,u2,relations,op)) if isinstance(c2,Clauses): if not c2.is_universal_first_order() or not p2.is_universal_first_order(): return False c2 = and_clauses(c2,diff_frame(u2,u1,relations,op)) return clauses_imply(p1,p2) and clauses_imply(c1,c2) else: if not is_prenex_universal(c2) or not is_prenex_universal(p2): return False c2 = And(c2,clauses_to_formula(diff_frame(u2,u1,relations,op))) return clauses_imply_formula_cex(p1,p2) and clauses_imply_formula_cex(c1,c2)
def implies(s1,s2): assert isinstance(s1,SemValue) and type(s1) is type(s2) op = s1.op axioms = im.background_theory() u1,c1,p1 = s1.comps u2,c2,p2 = s2.comps if u1 == None and u2 != None: return False # print "c1: {}".format(c1) # print "axioms: {}".format(axioms) # print "df: {}".format(diff_frame(u1,u2,relations,op)) c1 = and_clauses(c1,axioms,diff_frame(u1,u2,op)) if isinstance(c2,Clauses): if not c2.is_universal_first_order() or not p2.is_universal_first_order(): return False c2 = and_clauses(c2,diff_frame(u2,u1,op)) return clauses_imply(p1,p2) and clauses_imply(c1,c2) else: if not is_prenex_universal(c2) or not is_prenex_universal(p2): return False c2 = And(c2,clauses_to_formula(diff_frame(u2,u1,op))) return clauses_imply_formula_cex(p1,p2) and clauses_imply_formula_cex(c1,c2)
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
def vc_to_goal(lineno,name,vc,action): return pr.make_goal(lineno,name,[],lg.Not(lu.clauses_to_formula(vc)), annot=(action,vc.annot))