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))
