def encode_term(t, n, sort): if isinstance(t, ivy_logic.Ite): cond = formula_to_z3_int(t.args[0]) thenterm = encode_term(t.args[1], n, sort) elseterm = encode_term(t.args[2], n, sort) return [z3.If(cond, x, y) for x, y in zip(thenterm, elseterm)] if t.rep in ivy_logic.sig.constructors: try: m = sort.defines().index(t.rep.name) except ValueError: print "{} : {} : {}".format(sort, sort.defines(), t.rep) exit(1) return binenc(m, n) else: # return [atom_to_z3(ivy_logic.Atom(t.rep + ':' + str(n-1-i),t.args)) # for i in range(n)] args = [term_to_z3(arg) for arg in t.args] # print "encode_term t={}".format(t) sig = ivy_logic.RelationSort(t.rep.sort.dom).to_z3() res = [ apply_z3_func(z3.Function(t.rep.name + ':' + str(n - 1 - i), *sig), args) for i in range(n) ] # print "encode_term res={}".format(res) return res
def materialize_from_selected(self): if hasattr(self,'mark'): sorts = [self.lookup_node(x).sort for x in [self.mark,self.current_node]] required_sort = ivy_logic.RelationSort(sorts) rels = [r for r in self.g.relations if r.sort == required_sort] items = [str(r.rel_lit) for r in rels] msg = "Materialize this relation from selected node:" uu.listbox_dialog(self.tk,self.root,msg,items,command=functools.partial(self.materialize_from_selected_aux,rels))
def update_conjs(self): mod = self for i, cax in enumerate(mod.labeled_conjs): fmla = cax.formula csname = 'conjecture:' + str(i) variables = list(lu.used_variables_ast(fmla)) sort = il.RelationSort([v.sort for v in variables]) sym = il.Symbol(csname, sort) space = ics.NamedSpace(il.Literal(0, fmla)) mod.concept_spaces.append((sym(*variables), space))
def conjecture(self, ax): fmla = sortify_with_inference(ax) try: self.domain.conjs.append(formula_to_clauses(fmla)) except ValueError: raise IvyError(ax, "conjecture must be a clause") # Make a conecpt space from the conjecture csname = 'conjecture:' + str(len(self.domain.conjs)) variables = list(lu.used_variables_ast(fmla)) sort = ivy_logic.RelationSort([v.sort for v in variables]) sym = ivy_logic.Symbol(csname, sort) space = NamedSpace(ivy_logic.Literal(0, fmla)) self.domain.concept_spaces.append((sym(*variables), space))
def sorted_sort_universe(self, sort): elems = self.constants[sort] # print "elems: {}".format(map(str,elems)) vs = [ivy_logic.Variable(s, sort) for s in ["X", "Y"]] order = ivy_logic.Symbol("<", ivy_logic.RelationSort([sort, sort])) order_atom = atom_to_z3(order(*vs)) z3_vs = map(term_to_z3, vs) # print "order_atom: {}".format(order_atom) try: fun = z3.Function self.model[order.to_z3()] # print "sorting..." elems = sorted(elems, SortOrder(z3_vs, order_atom, self.model)) except IndexError: pass # print "elems: {}".format(map(str,elems)) return map(constant_from_z3, elems)
def emit_templates(self): add_impl( """ int CLASSNAME::temp_counter = 0; std::ostream &operator <<(std::ostream &s, const CLASSNAME &t){ s << "{"; switch (t.tag) { """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var add_impl(' case {}: s << "{}:" << {}; break;\n'.format(idx,sort.name,self.downcast(idx,'t'))) add_impl( """ } s << "}"; return s; } template <> CLASSNAME _arg<CLASSNAME>(std::vector<ivy_value> &args, unsigned idx, long long bound) { if (args[idx].atom.size()) throw out_of_bounds("unexpected value for sort SORTNAME: " + args[idx].atom,args[idx].pos); if (args[idx].fields.size() == 0) return CLASSNAME(); if (args[idx].fields.size() != 1) throw out_of_bounds("too many fields for sort SORTNAME (expected one)",args[idx].pos); """.replace('CLASSNAME',self.short_name()).replace('SORTNAME',self.sort.name)) for idx,var in enumerate(self.variants): sort,ctype = var add_impl(' if (args[idx].fields[0].atom == "{}") return {};\n'.format(sort.name,self.upcast(idx,'_arg<{}>(args[idx].fields[0].fields,0,0)'.format(ctype)))) add_impl( """ throw out_of_bounds("unexpected field sort SORTNAME: " + args[idx].fields[0].atom, args[idx].pos); } template <> void __ser<CLASSNAME>(ivy_ser &res, const CLASSNAME &inp) { """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var add_impl(' if (inp.tag == {}) {{res.open_tag({},"{}"); __ser(res,{}); res.close_tag();}}\n'.format(idx,idx,sort.name,self.downcast(idx,'inp'))) add_impl( """ } template <> void __deser<CLASSNAME>(ivy_deser &res, CLASSNAME &inp) { std::vector<std::string> tags; """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var add_impl(' tags.push_back("{}");\n'.format(sort.name)) add_impl( """ int tag = res.open_tag(tags); switch (tag) { """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var add_impl(' case {}: {{{} tmp; __deser(res,tmp); inp = {}; break;}} \n'.format(idx,ctype,self.upcast(idx,'tmp'))) add_impl( """ } res.close_tag(); } #ifdef Z3PP_H_ template <> void __from_solver<CLASSNAME>( gen &g, const z3::expr &v, CLASSNAME &res) { """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var pto = ivy_solver.solver_name(ivy_logic.Symbol('*>',ivy_logic.RelationSort([self.sort,sort]))) add_impl(' {\n') add_impl(' z3::sort sort = g.sort("{}");\n'.format(sort.name)) add_impl(' z3::func_decl pto = g.ctx.function("{}",g.sort("{}"),g.sort("{}"),g.ctx.bool_sort());\n'.format(pto,self.sort.name,sort.name)) add_impl(' // std::cout << g.model << std::endl;\n') add_impl(' Z3_ast_vector av = Z3_model_get_sort_universe(g.ctx, g.model, sort);\n') add_impl(' if (av) {\n') add_impl(' z3::expr_vector univ(g.ctx,av);\n') add_impl(' for (unsigned i = 0; i < univ.size(); i++){\n') add_impl(' if (eq(g.model.eval(pto(v,univ[i]),true),g.ctx.bool_val(true))){\n') add_impl(' {} tmp;\n'.format(ctype)) add_impl(' __from_solver(g,univ[i],tmp);') add_impl(' res = {};\n'.format(self.upcast(idx,'tmp'))) add_impl(' }\n') add_impl(' }\n') add_impl(' }\n') add_impl(' }\n') add_impl( """ } template <> z3::expr __to_solver<CLASSNAME>( gen &g, const z3::expr &v, CLASSNAME &val) { // std::cout << v << ":" << v.get_sort() << std::endl; """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var pto = ivy_solver.solver_name(ivy_logic.Symbol('*>',ivy_logic.RelationSort([self.sort,sort]))) add_impl(' if (val.tag == {}) {{\n'.format(idx)) add_impl(' z3::func_decl pto = g.ctx.function("{}",g.sort("{}"),g.sort("{}"),g.ctx.bool_sort());\n'.format(pto,self.sort.name,sort.name)) add_impl(' z3::expr X = g.ctx.constant("X",g.sort("{}"));\n'.format(sort.name)) add_impl(' {} tmp = {};\n'.format(ctype,self.downcast(idx,'val'))) add_impl(' return exists(X,pto(v,X) && __to_solver(g,X,tmp));\n') add_impl(' }\n') add_impl( """ z3::expr conj = g.ctx.bool_val(false); """.replace('CLASSNAME',self.short_name())) for idx,var in enumerate(self.variants): sort,ctype = var pto = ivy_solver.solver_name(ivy_logic.Symbol('*>',ivy_logic.RelationSort([self.sort,sort]))) add_impl(' {\n') add_impl(' z3::func_decl pto = g.ctx.function("{}",g.sort("{}"),g.sort("{}"),g.ctx.bool_sort());\n'.format(pto,self.sort.name,sort.name)) add_impl(' z3::expr Y = g.ctx.constant("Y",g.sort("{}"));\n'.format(sort.name)) add_impl(' conj = conj && forall(Y,!pto(v,Y));\n') add_impl(' }\n') add_impl( """ return conj; } template <> void __randomize<CLASSNAME>( gen &g, const z3::expr &apply_expr) { std::ostringstream os; os << "__SORTNAME__tmp" << CLASSNAME::temp_counter++; std::string temp = os.str(); z3::sort range = apply_expr.get_sort(); z3::expr disj = g.ctx.bool_val(false); """.replace('CLASSNAME',self.short_name()).replace('SORTNAME',self.sort.name)) add_impl('int tag = rand() % {};\n'.format(len(self.variants))) for idx,var in enumerate(self.variants): sort,ctype = var pto = ivy_solver.solver_name(ivy_logic.Symbol('*>',ivy_logic.RelationSort([self.sort,sort]))) add_impl(' if (tag == {}) {{\n'.format(idx)) add_impl(' z3::func_decl pto = g.ctx.function("{}",g.sort("{}"),g.sort("{}"),g.ctx.bool_sort());\n'.format(pto,self.sort.name,sort.name)) add_impl(' z3::expr X = g.ctx.constant(temp.c_str(),g.sort("{}"));\n'.format(sort.name)) add_impl(' z3::expr pred = pto(apply_expr,X);\n') add_impl(' g.add_alit(pred);\n') add_impl(' __randomize<{}>(g,X);\n'.format(ctype)) add_impl(' }\n') add_impl( """ } #endif """.replace('CLASSNAME',self.short_name()))
def get_relation_sort(sig, args, term=None): return ivy_logic.RelationSort(get_arg_sorts(sig, args, term))
def create_isolate(iso, mod=None, **kwargs): mod = mod or im.module # treat initializers as exports after_inits = mod.mixins["init"] del mod.mixins["init"] mod.exports.extend( ivy_ast.ExportDef(ivy_ast.Atom(a.mixer()), ivy_ast.Atom('')) for a in after_inits) # check all mixin declarations for name, mixins in mod.mixins.iteritems(): for mixin in mixins: with ASTContext(mixins): action1, action2 = (lookup_action(mixin, mod, a.relname) for a in mixin.args) # check all the delagate declarations for dl in mod.delegates: lookup_action(dl.args[0], mod, dl.delegated()) if dl.delegee() and dl.delegee() not in mod.hierarchy: raise iu.IvyError(dl.args[1], "{} is not a module instance".format(name)) # check all the export declarations for exp in mod.exports: expname = exp.args[0].rep if expname not in mod.actions: raise iu.IvyError(exp, "undefined action: {}".format(expname)) # create the import actions, if requested extra_with = [] extra_strip = {} if create_imports.get(): newimps = [] for imp in mod.imports: if imp.args[1].rep == '': impname = imp.args[0].rep if impname not in mod.actions: raise iu.IvyError(imp, "undefined action: {}".format(impname)) action = mod.actions[impname] if not (type(action) == ia.Sequence and not action.args): raise iu.IvyError( imp, "cannot import implemented action: {}".format(impname)) extname = 'imp__' + impname call = ia.CallAction( *([ivy_ast.Atom(extname, action.formal_params)] + action.formal_returns)) call.formal_params = action.formal_params call.formal_returns = action.formal_returns call.lineno = action.lineno mod.actions[impname] = call mod.actions[extname] = action newimps.append( ivy_ast.ImportDef(ivy_ast.Atom(extname), imp.args[1])) extra_with.append(ivy_ast.Atom(impname)) # extra_with.append(ivy_ast.Atom(extname)) if iso and iso in mod.isolates: ps = mod.isolates[iso].params() extra_strip[impname] = [a.rep for a in ps] extra_strip[extname] = [a.rep for a in ps] else: newimps.append(imp) mod.imports = newimps mixers = set() for ms in mod.mixins.values(): for m in ms: mixers.add(m.mixer()) # Determine the mixin order (as a side effect on module.mixins) get_mixin_order(iso, mod) # Construct an isolate if iso: isolate_component(mod, iso, extra_with=extra_with, extra_strip=extra_strip) else: if mod.isolates and cone_of_influence.get(): raise iu.IvyError(None, 'no isolate specified on command line') # apply all the mixins in no particular order for name, mixins in mod.mixins.iteritems(): for mixin in mixins: action1, action2 = (lookup_action(mixin, mod, a.relname) for a in mixin.args) mixed = ia.apply_mixin(mixin, action1, action2) mod.actions[mixin.args[1].relname] = mixed # find the globally exported actions (all if none specified, for compat) if mod.exports: mod.public_actions.clear() for e in mod.exports: if not e.scope(): # global export mod.public_actions.add(e.exported()) else: for a in mod.actions: mod.public_actions.add(a) # Create one big external action if requested for name in mod.public_actions: mod.actions[name].label = name ext = kwargs['ext'] if 'ext' in kwargs else ext_action.get() if ext is not None: ext_acts = [mod.actions[x] for x in sorted(mod.public_actions)] ext_act = ia.EnvAction(*ext_acts) mod.public_actions.add(ext) mod.actions[ext] = ext_act # Check native interpretations of symbols slv.check_compat() # Make concept spaces from the conjecture for i, cax in enumerate(mod.labeled_conjs): fmla = cax.formula csname = 'conjecture:' + str(i) variables = list(lu.used_variables_ast(fmla)) sort = ivy_logic.RelationSort([v.sort for v in variables]) sym = ivy_logic.Symbol(csname, sort) space = ics.NamedSpace(ivy_logic.Literal(0, fmla)) mod.concept_spaces.append((sym(*variables), space)) ith.check_theory() # get rid of useless actions cone = get_mod_cone(mod) if cone_of_influence.get(): for a in list(mod.actions): if a not in cone: del mod.actions[a] else: for a in list(mod.actions): if a not in cone and not a.startswith('ext:') and a not in mixers: ea = 'ext:' + a if ea in mod.actions and ea not in cone: if ia.has_code(mod.actions[a]): iu.warn(mod.actions[a], "action {} is never called".format(a)) fix_initializers(mod, after_inits) # show the compiled code if requested if show_compiled.get(): ivy_printer.print_module(mod)
def create_isolate(iso,mod = None,**kwargs): mod = mod or im.module # check all mixin declarations for name,mixins in mod.mixins.iteritems(): for mixin in mixins: with ASTContext(mixins): action1,action2 = (lookup_action(mixin,mod,a.relname) for a in mixin.args) # check all the delagate declarations for dl in mod.delegates: lookup_action(dl.args[0],mod,dl.delegated()) if dl.delegee() and dl.delegee() not in mod.hierarchy: raise iu.IvyError(dl.args[1],"{} is not a module instance".format(name)) # Determine the mixin order (as a side effect on module.mixins) get_mixin_order(iso,mod) # Construct an isolate if iso: isolate_component(mod,iso) else: if mod.isolates: raise iu.IvyError(None,'no isolate specified on command line') # apply all the mixins in no particular order for name,mixins in mod.mixins.iteritems(): for mixin in mixins: action1,action2 = (lookup_action(mixin,mod,a.relname) for a in mixin.args) mixed = ia.apply_mixin(mixin,action1,action2) mod.actions[mixin.args[1].relname] = mixed # find the globally exported actions (all if none specified, for compat) if mod.exports: mod.public_actions.clear() for e in mod.exports: if not e.scope(): # global export mod.public_actions.add(e.exported()) else: for a in mod.actions: mod.public_actions.add(a) # Create one big external action if requested ext = kwargs['ext'] if 'ext' in kwargs else ext_action.get() if ext is not None: ext_acts = [mod.actions[x] for x in sorted(mod.public_actions)] ext_act = ia.EnvAction(*ext_acts) mod.public_actions.add(ext); mod.actions[ext] = ext_act; # Check native interpretations of symbols slv.check_compat() # Make concept spaces from the conjecture for i,cax in enumerate(mod.labeled_conjs): fmla = cax.formula csname = 'conjecture:'+ str(i) variables = list(lu.used_variables_ast(fmla)) sort = ivy_logic.RelationSort([v.sort for v in variables]) sym = ivy_logic.Symbol(csname,sort) space = ics.NamedSpace(ivy_logic.Literal(0,fmla)) mod.concept_spaces.append((sym(*variables),space)) ith.check_theory() if show_compiled.get(): for x,y in mod.actions.iteritems(): print iu.pretty("action {} = {}".format(x,y))
def scenario(self, scen): for (s, lineno) in scen.places(): with ASTContext(scen): sym = add_symbol(s, ivy_logic.RelationSort([])) self.domain.all_relations.append((sym, 0)) self.domain.relations[sym] = 0