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