def interpret(self, thing): sig = self.domain.sig interp = sig.interp if isinstance(thing.formula.args[1], ivy_ast.NativeType): lhs = thing.formula.args[0].rep if lhs in interp or lhs in self.domain.native_types: raise IvyError(thing, "{} is already interpreted".format(lhs)) self.domain.native_types[lhs] = thing.formula.args[1] return lhs, rhs = (a.rep for a in thing.formula.args) self.domain.interps[lhs].append(thing) if lhs in self.domain.native_types: raise IvyError(thing, "{} is already interpreted".format(lhs)) if lhs in interp: if interp[lhs] != rhs: raise IvyError(thing, "{} is already interpreted".format(lhs)) return if isinstance(rhs, ivy_ast.Range): interp[lhs] = ivy_logic.EnumeratedSort(lhs, [ "{}:{}".format(i, lhs) for i in range(int(rhs.lo), int(rhs.hi) + 1) ]) return for x, y, z in zip([sig.sorts, sig.symbols], [slv.is_solver_sort, slv.is_solver_op], ['sort', 'symbol']): if lhs in x: if not y(rhs): raise IvyError(thing, "{} not a native {}".format(rhs, z)) interp[lhs] = rhs return raise IvyUndefined(thing, lhs)
expr_context.code.append(CallAction(ivy_ast.Atom(self.rep, args), res)) return res() return (ivy_logic.Equals if self.rep == '=' else ivy_logic.find_polymorphic_symbol(self.rep))(*args) ivy_ast.App.cmpl = ivy_ast.Atom.cmpl = compile_app ivy_ast.Variable.cmpl = lambda self: ivy_logic.Variable( self.rep, ivy_logic.find_sort(self.sort) if isinstance(self.sort, str) else self.sort) ivy_ast.ConstantSort.cmpl = lambda self: ivy_logic.ConstantSort(self.rep) ivy_ast.EnumeratedSort.cmpl = lambda self: ivy_logic.EnumeratedSort( self.name, self.extension) SymbolList.cmpl = lambda self: self.clone( [find_symbol(s) for s in self.symbols]) def cquant(q): return ivy_logic.ForAll if isinstance(q, ivy_ast.Forall) else ivy_logic.Exists ivy_ast.Quantifier.cmpl = lambda self: cquant( self)([v.compile() for v in self.bounds], self.args[0].compile()) ivy_ast.LabeledFormula.cmpl = lambda self: self.clone( [self.label, sortify_with_inference(self.formula)])
# # print clauses # print # z3_formula = clauses_to_z3(clauses) # print z3_formula # print # print # f = clauses_to_z3(ivy_logic.to_clauses("[[p()],[~p()]]")) # s = z3.Solver() # s.add(f) # print s.check() # should be unsat # f1 = clauses_to_z3(ivy_logic.to_clauses("[[p()]]")) # f2 = clauses_to_z3(ivy_logic.to_clauses("[[~p()]]")) # s = z3.Solver() # s.add(f1) # s.add(f2) # print s.check() # this is also unsat # ivy_logic.add_symbol('p',ivy_logic.RelationSort([ivy_logic.universe])) # cls = to_clauses("p(x) & ~p(y)") # print clauses_model_to_clauses(cls) s = ivy_logic.EnumeratedSort(["a", "b", "c"]) for c in s.defines(): t = add_symbol(c, s) ivy_logic.sig.constructors.add(t) add_symbol('f', ivy_logic.FunctionSort([ivy_logic.universe], s)) cls = to_clauses("f(x) = a & f(y) = b") print clauses_model_to_clauses(cls)