def extract_pre_post_model(clauses,model,updated):
renaming = dict((v,new(v)) for v in updated)
ignore = lambda s: s.is_skolem() or is_new(s)
pre_clauses = clauses_model_to_clauses(clauses,ignore = ignore,model = model,numerals=use_numerals())
ignore = lambda s: s.is_skolem() or (not is_new(s) and s in renaming)
post_clauses = clauses_model_to_clauses(clauses,ignore = ignore,model = model,numerals=use_numerals())
post_clauses = rename_clauses(post_clauses,inverse_map(renaming))
return map(remove_taut_eqs_clauses,(pre_clauses,post_clauses))
def underapproximate_state(state,implied=[[]]):
if not hasattr(state,'unders'):
state.unders = [] # make sure we have this field
axioms = state.domain.background_theory(state.in_scope)
under = clauses_model_to_clauses(and_clauses(state.clauses,axioms),is_skolem,implied)
if under != None:
state.unders.append(self.new_state(under))
def __init__(self, clauses, model, vocab):
# iu.dbg('clauses')
self.clauses = clauses
self.model = model
self.vocab = vocab
self.current = dict()
mod_clauses = islv.clauses_model_to_clauses(clauses,
model=model,
numerals=True)
# iu.dbg('mod_clauses')
self.eqs = defaultdict(list)
for fmla in mod_clauses.fmlas:
if lg.is_eq(fmla):
lhs, rhs = fmla.args
if lg.is_app(lhs):
self.eqs[lhs.rep].append(fmla)
elif isinstance(fmla, lg.Not):
app = fmla.args[0]
if lg.is_app(app):
self.eqs[app.rep].append(lg.Equals(app, lg.Or()))
else:
if lg.is_app(fmla):
self.eqs[fmla.rep].append(lg.Equals(fmla, lg.And()))
# for sym in vocab:
# if not itr.is_new(sym) and not itr.is_skolem(sym):
# self.show_sym(sym,sym)
self.started = False
self.renaming = dict()
print
print 'Trace follows...'
print 80 * '*'
def reach_state(state, clauses=None):
""" Try to reach a state in one step from it's predecessor's
underapproximation. If reachable, update the state's
underapproximation with some known reachable state. Return the
reachable state. Else return None.
"""
if not (state.pred != None and state.update != None):
return None
pre = join_unders(state.pred)
if clauses == None:
clauses = state.clauses
print "reach_state: clauses = {}".format(clauses)
axioms = state.domain.background_theory(state.in_scope)
img = and_clauses(forward_image(pre, axioms, state.update), axioms,
clauses)
m = get_model_clauses(img)
ignore = lambda s, d=state.domain: s not in d.relations and s not in d.functions
if m:
# print "reach_state model = {}".format(m.model)
idx = find_true_disjunct(pre, m.eval)
post = clauses_model_to_clauses(img, ignore, model=m)
return add_under(
state, post, state.unders[idx],
dict((s, [c.skolem() for c in m.sort_universe(s)])
for s in m.sorts()))
return None
def __init__(self, clauses, model, vocab, top_level=True):
art.AnalysisGraph.__init__(self)
self.clauses = clauses
self.model = model
self.vocab = vocab
mod_clauses = islv.clauses_model_to_clauses(clauses,
model=model,
numerals=True)
self.eqs = defaultdict(list)
for fmla in mod_clauses.fmlas:
if lg.is_eq(fmla):
lhs, rhs = fmla.args
if lg.is_app(lhs):
self.eqs[lhs.rep].append(fmla)
elif isinstance(fmla, lg.Not):
app = fmla.args[0]
if lg.is_app(app):
self.eqs[app.rep].append(lg.Equals(app, lg.Or()))
else:
if lg.is_app(fmla):
self.eqs[fmla.rep].append(lg.Equals(fmla, lg.And()))
self.last_action = None
self.sub = None
self.returned = None
self.top_level = top_level
def underapproximate_state(state,implied=[[]]):
if not hasattr(state,'unders'):
state.unders = [] # make sure we have this field
axioms = state.domain.background_theory(state.in_scope)
under = clauses_model_to_clauses(and_clauses(state.clauses,axioms),is_skolem,implied)
if under != None:
state.unders.append(self.new_state(under))
def __init__(self, clauses, model, vocab, top_level=True):
TraceBase.__init__(self)
self.clauses = clauses
self.model = model
self.vocab = vocab
self.top_level = top_level
if clauses is not None:
ignore = lambda s: islv.solver_name(s) == None
mod_clauses = islv.clauses_model_to_clauses(clauses,
model=model,
numerals=True,
ignore=ignore)
self.eqs = defaultdict(list)
for fmla in mod_clauses.fmlas:
if lg.is_eq(fmla):
lhs, rhs = fmla.args
if lg.is_app(lhs):
self.eqs[lhs.rep].append(fmla)
elif isinstance(fmla, lg.Not):
app = fmla.args[0]
if lg.is_app(app):
self.eqs[app.rep].append(lg.Equals(app, lg.Or()))
else:
if lg.is_app(fmla):
self.eqs[fmla.rep].append(lg.Equals(fmla, lg.And()))
def satisfy(self, axioms, _get_model_clauses=None, final_cond=None):
""" Produce a state sequence if the symbolic history contains
one. Returns the sort universes and a sequence of states, or
None if the history is vacuous. """
if _get_model_clauses is None:
_get_model_clauses = small_model_clauses
# print "axioms: {}".format(axioms)
# A model of the post-state embeds a valuation for each time
# in the history.
# print "concrete state: {}".format(self.post)
# print "background: {}".format(axioms)
post = and_clauses(self.post, axioms)
# print "bounded check {"
model = _get_model_clauses(post, final_cond=final_cond)
# print "} bounded check"
if model == None:
# print "core = {}".format(unsat_core(post,true_clauses()))
return None
# we reconstruct the sub-model for each state composing the
# recorded renamings in reverse order. Here "renaming" maps
# symbols representing a past time onto current time skolems
renaming, states, maps = {}, [], reversed(self.maps)
while True:
# ignore all symbols except those representing the given past time
img = set(renaming[s] for s in renaming if not s.is_skolem())
ignore = lambda s: self.ignore(s, img, renaming)
# get the sub-mode for the given past time as a formula
if isinstance(final_cond, list):
final_cond = or_clauses(*[fc.cond() for fc in final_cond])
all_clauses = and_clauses(
post, final_cond) if final_cond != None else post
clauses = clauses_model_to_clauses(all_clauses,
ignore=ignore,
model=model,
numerals=use_numerals())
# map this formula into the past using inverse map
clauses = rename_clauses(clauses, inverse_map(renaming))
# remove tautology equalities, TODO: not sure if this is correct here
clauses = Clauses(
[f for f in clauses.fmlas if not is_tautology_equality(f)],
clauses.defs)
states.append(clauses)
try:
# update the inverse map by composing it with inverse
# of the next renaming (in reverse order)
renaming = compose_maps(next(maps), renaming)
except StopIteration:
break
uvs = model.universes(numerals=use_numerals())
# print "uvs: {}".format(uvs)
return uvs, [pure_state(clauses) for clauses in reversed(states)]
def satisfy(self, axioms, _get_model_clauses=None, final_cond=None):
""" Produce a state sequence if the symbolic history contains
one. Returns the sort universes and a sequence of states, or
None if the history is vacuous. """
if _get_model_clauses is None:
_get_model_clauses = small_model_clauses
# print "axioms: {}".format(axioms)
# A model of the post-state embeds a valuation for each time
# in the history.
# print "concrete state: {}".format(self.post)
# print "background: {}".format(axioms)
post = and_clauses(self.post,axioms)
# print "bounded check {"
model = _get_model_clauses(post,final_cond=final_cond)
# print "} bounded check"
if model == None:
# print "core = {}".format(unsat_core(post,true_clauses()))
return None
# we reconstruct the sub-model for each state composing the
# recorded renamings in reverse order. Here "renaming" maps
# symbols representing a past time onto current time skolems
renaming,states,maps = {},[],reversed(self.maps)
while True:
# ignore all symbols except those representing the given past time
img = set(renaming[s] for s in renaming if not s.is_skolem())
ignore = lambda s: self.ignore(s,img,renaming)
# get the sub-mode for the given past time as a formula
if isinstance(final_cond,list):
final_cond = or_clauses(*[fc.cond() for fc in final_cond])
all_clauses = and_clauses(post,final_cond) if final_cond != None else post
clauses = clauses_model_to_clauses(all_clauses,ignore = ignore, model = model, numerals=use_numerals())
# map this formula into the past using inverse map
clauses = rename_clauses(clauses,inverse_map(renaming))
# remove tautology equalities, TODO: not sure if this is correct here
clauses = Clauses(
[f for f in clauses.fmlas if not is_tautology_equality(f)],
clauses.defs
)
states.append(clauses)
try:
# update the inverse map by composing it with inverse
# of the next renaming (in reverse order)
renaming = compose_maps(next(maps),renaming)
except StopIteration:
break
uvs = model.universes(numerals=use_numerals())
# print "uvs: {}".format(uvs)
return uvs, [pure_state(clauses) for clauses in reversed(states)]
def reach_state(state,clauses=None):
""" Try to reach a state in one step from it's predecessor's
underapproximation. If reachable, update the state's
underapproximation with some known reachable state. Return the
reachable state. Else return None.
"""
if not(state.pred != None and state.update != None):
return None
pre = join_unders(state.pred)
if clauses == None:
clauses = state.clauses
print "reach_state: clauses = {}".format(clauses)
axioms = state.domain.background_theory(state.in_scope)
img = and_clauses(forward_image(pre,state.update),axioms,clauses)
m = get_model_clauses(img)
ignore = lambda s,d=state.domain: s not in d.relations and s not in d.functions
if m:
# print "reach_state model = {}".format(m.model)
idx = find_true_disjunct(pre,m.eval)
post = clauses_model_to_clauses(img,ignore,model=m)
return add_under(state,post,state.unders[idx],dict((s,[c.skolem() for c in m.sort_universe(s)]) for s in m.sorts()))
return None
