from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem # Declarations x, y = Vars('x y', fgsort) nil, c = Consts('nil c', fgsort) nxt = Function('nxt', fgsort, fgsort) prv = Function('prv', fgsort, fgsort) lsegprev = RecFunction('lsegprev', fgsort, fgsort, boolsort) dlseg = RecFunction('dlseg', fgsort, fgsort, boolsort) AddRecDefinition(lsegprev, (x, y) , If(x == y, True, lsegprev(x, nxt(y)))) AddRecDefinition(dlseg, (x, y) , If(x == y, True, And(prv(nxt(x)) == x, dlseg(nxt(x), y)))) AddAxiom((), nxt(nil) == nil) # Problem parameters goal = Implies(dlseg(x, y), Implies(x != c, lsegprev(y, x))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string v1, v2 = Vars('v1 v2', fgsort) lemma_grammar_args = [v1, v2, nil] lemma_grammar_terms = {v1, v2, prv(nxt(v1)), prv(nxt(nxt(v1))), nil, prv(nxt(v2)), nxt(nil), nxt(v1), prv(nxt(prv(nxt(v1)))), nxt(prv(nxt(v1))), nxt(v2), nxt(nxt(v1))}
from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem def notInChildren(x): return And(Not(IsMember(x, hbst(lft(x)))), Not(IsMember(x, hbst(rght(x))))) # declarations x = Var('x', fgsort) y, nil = Consts('y nil', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) minr = RecFunction('minr', fgsort, intsort) maxr = RecFunction('maxr', fgsort, intsort) bst = RecFunction('bst', fgsort, boolsort) hbst = RecFunction('hbst', fgsort, fgsetsort) AddRecDefinition(minr, x, If(x == nil, 100, min_intsort(key(x), minr(lft(x)), minr(rght(x))))) AddRecDefinition(maxr, x, If(x == nil, -1, max_intsort(key(x), maxr(lft(x)), maxr(rght(x))))) AddRecDefinition(bst, x, If(x == nil, True, And(0 < key(x), And(key(x) < 100, And(bst(lft(x)), And(bst(rght(x)), And(maxr(lft(x)) <= key(x), And(key(x) <= minr(rght(x)), And(notInChildren(x), SetIntersect(hbst(lft(x)), hbst(rght(x))) == fgsetsort.lattice_bottom)))))))))
from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort, min_intsort, max_intsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from lemsynth.lemsynth_engine import solveProblem # Declarations x = Var('x', fgsort) y, nil = Consts('y nil', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) minr = Function('minr', fgsort, intsort) maxr = Function('maxr', fgsort, intsort) bst = RecFunction('bst', fgsort, boolsort) hbst = RecFunction('hbst', fgsort, fgsetsort) AddRecDefinition(minr, x, If(x == nil, 100, min_intsort(key(x), minr(lft(x)), minr(rght(x))))) AddRecDefinition(maxr, x, If(x == nil, -1, max_intsort(key(x), maxr(lft(x)), maxr(rght(x))))) AddRecDefinition(bst, x, If(x == nil, True, And(0 < key(x), And(key(x) < 100, And(bst(lft(x)), And(bst(rght(x)), And(maxr(lft(x)) <= key(x), key(x) <= minr(rght(x))))))))) AddRecDefinition(hbst, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(SetUnion(hbst(lft(x)), hbst(rght(x))), x))) AddAxiom((), lft(nil) == nil) AddAxiom((), rght(nil) == nil)
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) odd_lst = RecFunction('odd_lst', fgsort, boolsort) even_lst = RecFunction('even_lst', fgsort, boolsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition( even_lst, x, If(x == nil, True, If(nxt(x) == nil, False, even_lst(nxt(nxt(x)))))) AddRecDefinition( odd_lst, x, If(x == nil, False, If(nxt(x) == nil, True, odd_lst(nxt(nxt(x)))))) AddAxiom((), nxt(nil) == nil) # vc pgm = If(x == nil, ret == nil, ret == nxt(x)) goal = Implies(even_lst(x), Implies(pgm, lst(ret)))
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem # Declarations x, y = Vars('x y', fgsort) nil, c = Consts('nil c', fgsort) nxt = Function('nxt', fgsort, fgsort) prv = Function('prv', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) dlst = RecFunction('dlst', fgsort, boolsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition(dlst, x, If(x == nil, True, If(nxt(x) == nil, True, And(prv(nxt(x)) == x, dlst(nxt(x)))))) AddRecDefinition(lseg, (x, y) , If(x == y, True, lseg(nxt(x), y))) AddAxiom((), nxt(nil) == nil) # Problem parameters goal = Implies(lseg(x, y), Implies(x != c, Implies(dlst(y), lst(x)))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet, SetAdd from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x, y, v, z = Vars('x y v z', fgsort) nil = Const('nil', fgsort) nxt = Function('nxt', fgsort, fgsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) hlseg = RecFunction('hlseg', fgsort, fgsort, fgsort, boolsort) AddRecDefinition(lseg, (x, y), If(x == nil, False, If(nxt(x) == y, True, lseg(nxt(x), y)))) # v \in hlseg(x, y) AddRecDefinition(hlseg, (x, y, v), If(x == nil, False, If(v == x, True, hlseg(nxt(x), y, v)))) AddAxiom((), nxt(nil) == nil) # Uncomment this line for fixed_depth=1 mode # config_params['goal_instantiation_mode'] = proveroptions.fixed_depth # Default depth is 1 # Uncomment these two lines for manual instantiation mode # config_params['goal_instantiation_mode'] = proveroptions.manual_instantiation # config_params['goal_instantiation_terms'] = {x, nxt(x)}
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.prover import NPSolver from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) key = Function('key', fgsort, intsort) lst = RecFunction('lst', fgsort, boolsort) slst = RecFunction('slst', fgsort, boolsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition( slst, x, If(x == nil, True, If(nxt(x) == nil, True, And(key(x) <= key(nxt(x)), slst(nxt(x)))))) AddAxiom((), nxt(nil) == nil) # vc pgm = If(x == nil, ret == nil, ret == nxt(x)) goal = Implies(slst(x), Implies(pgm, lst(ret))) # check validity with natural proof solver and no hardcoded lemmas np_solver = NPSolver() solution = np_solver.solve(make_pfp_formula(goal))
from lemsynth.lemsynth_engine import solveProblem def notInChildren(x): return And(Not(IsMember(x, htree(lft(x)))), Not(IsMember(x, htree(rght(x))))) # declarations x, y = Vars('x y', fgsort) nil, ret = Consts('nil ret', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) tree = RecFunction('tree', fgsort, boolsort) dag = RecFunction('dag', fgsort, boolsort) maxheap = RecFunction('maxheap', fgsort, boolsort) htree = RecFunction('htree', fgsort, fgsetsort) AddRecDefinition( dag, x, If(x == nil, True, And(notInChildren(x), And(dag(lft(x)), dag(rght(x)))))) AddRecDefinition( maxheap, x, If( x == nil, True, And( notInChildren(x), And( SetIntersect(htree(lft(x)), htree(rght(x))) == fgsetsort.lattice_bottom,
from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort, min_intsort, max_intsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from lemsynth.lemsynth_engine import solveProblem # Declarations x = Var('x', fgsort) nil = Const('nil', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) minr = Function('minr', fgsort, intsort) maxr = Function('maxr', fgsort, intsort) bst = RecFunction('bst', fgsort, boolsort) AddRecDefinition(minr, x, If(x == nil, -1, min_intsort(key(x), minr(lft(x)), minr(rght(x))))) AddRecDefinition(maxr, x, If(x == nil, 100, max_intsort(key(x), maxr(lft(x)), maxr(rght(x))))) AddRecDefinition(bst, x, If(x == nil, True, And(0 < key(x), And(key(x) < 100, And(bst(lft(x)), And(bst(rght(x)), And(maxr(lft(x)) <= key(x), key(x) <= minr(rght(x))))))))) AddAxiom((), lft(nil) == nil) AddAxiom((), rght(nil) == nil) # Problem parameters goal = Implies(bst(x), Implies(k <= minr(lft(x)), k <= minr(x)))
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) rlst = RecFunction('rlst', fgsort, boolsort) red = Function('red', fgsort, boolsort) black = Function('black', fgsort, boolsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition( rlst, x, If( x == nil, True, And( Or( And(red(x), And(Not(black(x)), And(black(nxt(x)), Not(red(nxt(x)))))), And(black(x), And(Not(red(x)), And(red(nxt(x)), Not(black(nxt(x))))))), rlst(nxt(x)))))
from z3 import IsSubset, Union, SetIntersect, SetComplement, SetAdd, EmptySet, IsMember from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x, y = Vars('x y', fgsort) nil = Const('nil', fgsort) k = Const('k', intsort) nxt = Function('nxt', fgsort, fgsort) key = Function('key', fgsort, intsort) lst = RecFunction('lst', fgsort, boolsort) hlst = RecFunction('hlst', fgsort, fgsetsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition(hlst, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(hlst(nxt(x)), x))) AddRecDefinition(lseg, (x, y), If(x == y, True, lseg(nxt(x), y))) AddAxiom((), nxt(nil) == nil) # vc goal = Implies(lst(x), Implies(key(x) != k, Implies(IsMember(y, hlst(x)), lseg(x,y)))) # check validity with natural proof solver and no hardcoded lemmas np_solver = NPSolver() solution = np_solver.solve(make_pfp_formula(goal)) if not solution.if_sat: print('goal (no lemmas) is valid')
import importlib_resources import z3 from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from lemsynth.lemsynth_engine import solveProblem # Declarations x = Var('x', fgsort) l = Var('l', intsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) lstlen = RecFunction('lstlen', fgsort, intsort, boolsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition(lstlen, (x, l), If(x == nil, l == 0, lstlen(nxt(x), l - 1))) AddAxiom((), nxt(nil) == nil) # Problem parameters pgm = If(x == nil, ret == nil, ret == nxt(x)) goal = Implies(lstlen(x, l), Implies(pgm, lst(ret))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string v = Var('v', fgsort) m = Var('m', intsort) lemma_grammar_args = [v, m, nil]
if len(exprs) == 0: return z3.BoolVal(True) elif len(exprs) == 1: return exprs[0] else: return And(exprs[0], binary_anded(exprs[1:])) # Signature x = Var('x', fgsort) nil = Const('nil', fgsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) parent = Function('parent', fgsort, fgsort) key = Function('key', fgsort, intsort) tree = RecFunction('tree', fgsort, boolsort) signature = dict() signature['x'] = x signature['nil'] = nil signature['lft'] = lft signature['rght'] = rght signature['parent'] = parent signature['key'] = key signature['tree'] = tree # Additional recursive definitions htree = RecFunction('htree', fgsort, fgsetsort) AddRecDefinition( htree, x, If(x == nil, fgsetsort.lattice_bottom,
from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem x, y, nx, ny = Vars('x y nx ny', fgsort) # ADT definition of nats zero = Const('zero', fgsort) succ = Function('succ', fgsort, fgsort) # projection function - analogous to tail of list pred = Function('pred', fgsort, fgsort) # rec defs plus = RecFunction('plus', fgsort, fgsort, fgsort) AddRecDefinition(plus, (x, y), If(x == zero, y, succ(plus(pred(x), y)))) # axioms AddAxiom(x, pred(succ(x)) == x) AddAxiom(x, succ(x) != zero) goal = plus(x, y) == plus(y, x) # adt pfp of goal base_case = plus(zero, y) == plus(y, zero) induction_hypothesis = plus(nx, y) == plus(y, nx) induction_step = plus(succ(nx), y) == plus(y, succ(nx)) pfp_goal = Implies(induction_hypothesis, induction_step) orig_np_solver = NPSolver()
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions # Declarations a, zero = Consts('a zero', fgsort) suc = Function('suc', fgsort, fgsort) pred = Function('pred', fgsort, fgsort) AddAxiom(a, pred(suc(a)) == a) nat = RecFunction('nat', fgsort, boolsort) even = RecFunction('even', fgsort, boolsort) odd = RecFunction('odd', fgsort, boolsort) AddRecDefinition(nat, a, If(a == zero, True, nat(pred(a)))) AddRecDefinition(even, a, If(a == zero, True, odd(pred(a)))) AddRecDefinition(odd, a, If(a == zero, False, If(a == suc(zero), True, even(pred(a))))) # Problem parameters goal = Implies(nat(a), Or(even(a), odd(a))) pfp_of_goal = make_pfp_formula(goal) # Call a natural proofs solver npsolver = NPSolver() # Ask for proof npsolution = npsolver.solve(pfp_of_goal) class EvenOddTest(unittest.TestCase):
from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.prover import NPSolver from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) prv = Function('prv', fgsort, fgsort) key = Function('key', fgsort, intsort) dlst = RecFunction('dlst', fgsort, boolsort) sdlst = RecFunction('sdlst', fgsort, boolsort) AddRecDefinition( dlst, x, If(x == nil, True, If(nxt(x) == nil, True, And(prv(nxt(x)) == x, dlst(nxt(x)))))) AddRecDefinition( sdlst, x, If( x == nil, True, If( nxt(x) == nil, True, And(prv(nxt(x)) == x, And(key(x) <= key(nxt(x)), sdlst(nxt(x))))))) AddAxiom((), nxt(nil) == nil) AddAxiom((), prv(nil) == nil)
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem # Declarations x, y = Vars('x y', fgsort) nil, c = Consts('nil c', fgsort) nxt = Function('nxt', fgsort, fgsort) key = Function('key', fgsort, intsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) slseg = RecFunction('slseg', fgsort, fgsort, boolsort) AddRecDefinition(lseg, (x, y), If(x == y, True, lseg(nxt(x), y))) AddRecDefinition(slseg, (x, y), If(x == y, True, And(key(x) < key(nxt(x)), slseg(nxt(x), y)))) AddAxiom((), nxt(nil) == nil) # Problem parameters goal = Implies(slseg(x, y), Implies(x != c, lseg(x, y))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string v1, v2 = Vars('v1 v2', fgsort) lemma_grammar_args = [v1, v2, nil] lemma_grammar_terms = {v1, v2, nxt(v1), nxt(nxt(v1)), nxt(v2), nil, nxt(nil)}
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem # Declarations x, y = Vars('x y', fgsort) c = Const('c', fgsort) nxt = Function('nxt', fgsort, fgsort) prv = Function('prv', fgsort, fgsort) dlseg = RecFunction('dlseg', fgsort, fgsort, boolsort) AddRecDefinition(dlseg, (x, y), If(x == y, True, And(prv(nxt(x)) == x, dlseg(nxt(x), y)))) # Problem parameters goal = Implies(dlseg(x, y), Implies(And(x != y, x != c), dlseg(x, prv(y)))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string v1, v2 = Vars('v1 v2', fgsort) lemma_grammar_args = [v1, v2] lemma_grammar_terms = { nxt(nxt(v1)), nxt(prv(nxt(v1))), prv(prv(nxt(v1))),
import z3 from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem # Declarations x, y = Vars('x y', fgsort) nil = Const('nil', fgsort) nxt = Function('nxt', fgsort, fgsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) cyclic = RecFunction('cyclic', fgsort, boolsort) AddRecDefinition(lseg, (x, y) , If(x == y, True, If(x == nil, False, lseg(nxt(x), y)))) AddRecDefinition(cyclic, x, And(x != nil, lseg(nxt(x), x))) AddAxiom((), nxt(nil) == nil) # AddAxiom(x, Implies(cyclic(x), cyclic(nxt(x)))) # Problem parameters goal = Implies(lseg(x, y), Implies(cyclic(x), lseg(y, x))) # parameters representing the grammar for synth-fun and # terms on which finite model is extracted # TODO: extract this automatically from grammar_string
from lemsynth.lemsynth_engine import solveProblem l, tl = Vars('l tl', fgsort) k, h = Consts('k h', intsort) x = Var('x', intsort) # ADT definition of lists nil = Const('nil', fgsort) cons = Function('cons', intsort, fgsort, fgsort) # projections for cons head = Function('head', fgsort, intsort) tail = Function('tail', fgsort, fgsort) # rec defs slst = RecFunction('slst', fgsort, boolsort) elems = RecFunction('elems', fgsort, fgsetsort) member = RecFunction('member', fgsort, boolsort) AddRecDefinition( slst, l, If(l == nil, True, If(tail(l) == nil, True, And(head(l) <= head(tail(l)), slst(tail(l)))))) AddRecDefinition( elems, l, If(l == nil, fgsetsort.lattice_bottom, SetAdd(elems(tail(l)), head(l)))) AddRecDefinition( member, l, If(l == nil, False, If(k == head(l), True, If(k < head(l), False, member(tail(l)))))) # axioms
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.prover import NPSolver from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) l = Var('l', intsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) lstlen_bool = RecFunction('lstlen_bool', fgsort, boolsort) lstlen_int = RecFunction('lstlen_int', fgsort, intsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition(lstlen_bool, x, If(x == nil, True, lstlen_bool(nxt(x)))) AddRecDefinition(lstlen_int, x, If(x == nil, 0, lstlen_int(nxt(x)) + 1)) AddAxiom((), nxt(nil) == nil) # vc pgm = If(lstlen_int(x) == 1, ret == x, ret == nxt(x)) goal = Implies(lstlen_bool(x), Implies(pgm, lst(ret))) # check validity with natural proof solver and no hardcoded lemmas np_solver = NPSolver() solution = np_solver.solve(make_pfp_formula(goal)) if not solution.if_sat:
from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) nil, yc, zc = Consts('nil yc zc', fgsort) k = Const('k', intsort) nxt = Function('nxt', fgsort, fgsort) lsegy = RecFunction('lsegy', fgsort, boolsort) lsegz = RecFunction('lsegz', fgsort, boolsort) lsegy_p = RecFunction('lsegy_p', fgsort, boolsort) lsegz_p = RecFunction('lsegz_p', fgsort, boolsort) key = Function('key', fgsort, intsort) AddRecDefinition(lsegy, x, If(x == yc, True, lsegy(nxt(x)))) AddRecDefinition(lsegz, x, If(x == zc, True, lsegz(nxt(x)))) # lsegy_p, lsegz_p defs reflect change of nxt(y) == z AddRecDefinition(lsegy_p, x, If(x == yc, True, lsegy_p(If(x == yc, zc, nxt(x))))) AddRecDefinition(lsegz_p, x, If(x == zc, True, lsegz_p(If(x == yc, zc, nxt(x))))) AddAxiom((), nxt(nil) == nil) # vc goal = Implies(lsegy(x), Implies(key(x) != k, lsegz_p(x)))
from naturalproofs.prover import NPSolver from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) c, s, nil = Consts('c s nil', fgsort) v1 = Function('v1', fgsort, fgsort) v2 = Function('v2', fgsort, fgsort) p = Function('p', fgsort, fgsort) n = Function('n', fgsort, fgsort) reach_pgm = RecFunction('reach_pgm', fgsort, boolsort) # precondition AddAxiom((), v1(s) == n(v2(s))) cond = v1(p(x)) != nil assign1 = v1(x) == n(v1(p(x))) assign2 = v2(x) == n(v2(p(x))) assign = And(assign1, assign2) AddRecDefinition(reach_pgm, x, If(x == s, True, And(reach_pgm(p(x)), And(cond, assign)))) # vc lhs = v1(x) == nil rhs = n(v2(x)) == nil goal = Implies(reach_pgm(x), Implies(lhs, rhs))
from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet, SetAdd, IsMember from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x, y = Vars('x y', fgsort) nil = Const('nil', fgsort) k = Const('k', intsort) nxt = Function('nxt', fgsort, fgsort) lst = RecFunction('lst', fgsort, boolsort) lseg = RecFunction('lseg', fgsort, fgsort, boolsort) key = Function('key', fgsort, intsort) keys = RecFunction('keys', fgsort, intsetsort) AddRecDefinition(lst, x, If(x == nil, True, lst(nxt(x)))) AddRecDefinition(lseg, (x, y) , If(x == y, True, lseg(nxt(x), y))) AddRecDefinition(keys, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(keys(nxt(x)), key(x)))) AddAxiom((), nxt(nil) == nil) # vc goal = Implies(lseg(x, y), Implies(And(And(And(x != nil, y != nil), lst(x)), key(y) == k), IsMember(k, keys(x)))) # check validity with natural proof solver and no hardcoded lemmas np_solver = NPSolver() solution = np_solver.solve(make_pfp_formula(goal)) if not solution.if_sat:
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem # declarations x = Var('x', fgsort) nil, ret = Consts('nil ret', fgsort) nxt = Function('nxt', fgsort, fgsort) rlst = RecFunction('rlst', fgsort, boolsort) red = Function('red', fgsort, boolsort) black = Function('black', fgsort, boolsort) red_height = RecFunction('red_height', fgsort, intsort) black_height = RecFunction('black_height', fgsort, intsort) AddRecDefinition(rlst, x, If(x == nil, True, And(Or(And(red(x), And(Not(black(x)), And(black(nxt(x)), Not(red(nxt(x)))))), And(black(x), And(Not(red(x)), And(red(nxt(x)), Not(black(nxt(x))))))), rlst(nxt(x))))) AddRecDefinition(red_height, x, If(x == nil, 1, If(red(x), 1 + red_height(nxt(x)), red_height(nxt(x))))) AddRecDefinition(black_height, x, If(x == nil, 0,
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, Union, SetIntersect, SetComplement, EmptySet from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions # Declarations a, b, c, zero = Consts('a b c zero', fgsort) suc = Function('suc', fgsort, fgsort) pred = Function('pred', fgsort, fgsort) AddAxiom(a, pred(suc(a)) == a) nat = RecFunction('nat', fgsort, boolsort) add = RecFunction('add', fgsort, fgsort, fgsort, boolsort) AddRecDefinition(nat, a, If(a == zero, True, nat(pred(a)))) AddRecDefinition(add, (a, b, c), If(a == zero, b == c, add(pred(a), suc(b), c))) # Problem parameters goal = Implies(add(a, b, c), Implies(And(nat(a), nat(b)), nat(c))) pfp_of_goal = make_pfp_formula(goal) # Call a natural proofs solver npsolver = NPSolver() # Configure the solver npsolver.options.instantiation_mode = proveroptions.manual_instantiation npsolver.options.terms_to_instantiate = {a, b, c, zero, pred(b), suc(b)} # Ask for proof npsolution = npsolver.solve(pfp_of_goal)
from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem def notInChildren(x): return And(Not(IsMember(x, htree(lft(x)))), Not(IsMember(x, htree(rght(x))))) # declarations x, y = Vars('x y', fgsort) nil, ret = Consts('nil ret', fgsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) tree = RecFunction('tree', fgsort, boolsort) htree = RecFunction('htree', fgsort, fgsetsort) reach_lr = RecFunction('reach_lr', fgsort, fgsort, boolsort) AddRecDefinition( tree, x, If( x == nil, True, And( notInChildren(x), And( SetIntersect(htree(lft(x)), htree(rght(x))) == fgsetsort.lattice_bottom, And(tree(lft(x)), tree(rght(x))))))) AddRecDefinition( htree, x, If(x == nil, fgsetsort.lattice_bottom,
from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.pfp import make_pfp_formula from lemsynth.lemsynth_engine import solveProblem def notInChildren(x): return And(Not(IsMember(x, htree(lft(x)))), Not(IsMember(x, htree(rght(x))))) # declarations x, y = Vars('x y', fgsort) nil, ret = Consts('nil ret', fgsort) k = Const('k', intsort) key = Function('key', fgsort, intsort) lft = Function('lft', fgsort, fgsort) rght = Function('rght', fgsort, fgsort) dag = RecFunction('dag', fgsort, boolsort) tree = RecFunction('tree', fgsort, boolsort) htree = RecFunction('htree', fgsort, fgsetsort) AddRecDefinition(dag, x, If(x == nil, True, And(notInChildren(x), And(dag(lft(x)), dag(rght(x)))))) AddRecDefinition(tree, x, If(x == nil, True, And(notInChildren(x), And(SetIntersect(htree(lft(x)), htree(rght(x))) == fgsetsort.lattice_bottom, And(tree(lft(x)), tree(rght(x))))))) AddRecDefinition(htree, x, If(x == nil, fgsetsort.lattice_bottom, SetAdd(SetUnion(htree(lft(x)), htree(rght(x))), x))) AddAxiom((), lft(nil) == nil) AddAxiom((), rght(nil) == nil) # vc
from lemsynth.lemsynth_engine import solveProblem x, y, tx = Vars('x y tx', fgsort) hx = Var('hx', intsort) # ADT definition of lists nil = Const('nil', fgsort) cons = Function('cons', intsort, fgsort, fgsort) # projections for cons head = Function('head', fgsort, intsort) tail = Function('tail', fgsort, fgsort) # rec defs append = RecFunction('append', fgsort, fgsort, fgsort) length = RecFunction('length', fgsort, intsort) AddRecDefinition(append, (x, y), If(x == nil, y, cons(head(x), append(tail(x), y)))) AddRecDefinition(length, x, If(x == nil, 0, length(tail(x)) + 1)) # axioms AddAxiom(x, head(cons(hx, x)) == hx) AddAxiom(x, tail(cons(hx, x)) == x) AddAxiom(x, cons(hx, x) != nil) # len(append(x, y)) = len(x) + len(y) goal = length(append(x, y)) == length(x) + length(y) # adt pfp of goal base_case = length(append(nil, y)) == length(nil) + length(y)
from z3 import And, Or, Not, Implies, If from z3 import IsSubset, IsMember, SetUnion, SetIntersect, SetComplement, EmptySet, SetAdd from naturalproofs.uct import fgsort, fgsetsort, intsort, intsetsort, boolsort from naturalproofs.decl_api import Const, Consts, Var, Vars, Function, RecFunction, AddRecDefinition, AddAxiom from naturalproofs.prover import NPSolver import naturalproofs.proveroptions as proveroptions from lemsynth.lemsynth_engine import solveProblem x = Var('x', fgsort) nil = Const('nil', fgsort) k = Const('k', intsort) nxt = Function('nxt', fgsort, fgsort) key = Function('key', fgsort, intsort) slst = RecFunction('slst', fgsort, boolsort) keys = RecFunction('keys', fgsort, intsetsort) AddRecDefinition( slst, x, If(x == nil, True, If(nxt(x) == nil, True, And(key(x) <= key(nxt(x)), slst(nxt(x)))))) AddRecDefinition( keys, x, If(x == nil, intsetsort.lattice_bottom, SetAdd(keys(nxt(x)), key(x)))) AddAxiom((), nxt(nil) == nil) goal = Implies(slst(x), Implies(k < key(x), Not(IsMember(k, keys(x))))) name = 'lem-member' # leave all things related to grammar as empty, just using natural proof engine