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