def eval_expr(exp, env, out):
return conde(
(
eq([quote, out], exp),
no_item(out, is_internal),
missing(quote, env),
),
fresh(lambda lst: conjp(
eq([list_, lst, ...], exp),
missing(list_, env),
eval_list(lst, env, out),
)),
fresh(
5, lambda fn, arg, var, body, cenv: conj(
eval_list(exp, env, [fn, arg]),
conde(
eval_builtin(fn, arg, out),
(
eq(Closure(var, body, cenv), fn),
eval_expr(body, Env(var, arg, cenv), out),
),
))),
fresh(
2, lambda var, body: conjp(
eq([lambda_, [var], body], exp),
eq(Closure(var, body, env), out),
eqt(var, Symbol),
missing(lambda_, env),
)),
(eqt(exp, Symbol), lookup(exp, env, out)),
(builtin(exp, out), missing(exp, env)),
)
def eval_list(lst, env, out):
return conde((eq([], lst), eq([], out)),
fresh(
4, lambda h, t, oh, ot: conjp(
eq([h, t, ...], lst),
eq([oh, ot, ...], out),
eval_expr(h, env, oh),
eval_list(t, env, ot),
)))
def missing(var, env):
return disj(
eq((), env),
fresh(
3, lambda rest, sym, val: conjp(
eq(Env(sym, val, rest), env),
neq(sym, var),
missing(var, rest),
)),
)
def lookup(o, v, x):
return fresh(
3, lambda a, b, t: conj(
eq(o, ((a, b), t)),
conde(
[eq(a, v), eq(b, TMono(x))],
fresh(
3, lambda po, pb, pm: conjp(
eq(a, v),
eq(b, TPoly(po, pb)),
infer(pb, po, x, pm),
)),
[neq(a, v), lookup(t, v, x)],
)))
def main():
states = Var()
big = Var()
small = Var()
_ = Var()
__ = Var()
for i in range(1, BIG + 1):
p = conjp(eq([(big, small, _), __, ...], states),
disj(
eq(big, i),
conj(neq(big, i), eq(small, i)),
), jugs(states))
for answer in run(1, states, p):
print("{}:".format(i))
for b, s, a in reversed(answer):
print(b, s, a)
print()
def solve():
solutions = {}
states = Var()
big = Var()
small = Var()
_ = Var()
__ = Var()
for i in range(1, BIG + 1):
p = conjp(
eq([(big, small, _), __, ...], states),
disj(
eq(big, i),
conj(neq(big, i), eq(small, i)),
),
jugs(states)
)
for answer in run(1, states, p):
solutions[i] = list(reversed(answer))
return solutions
def calc(e, o):
a, b = Var(), Var()
ca, cb = Var(), Var()
op = Var()
return conde([
eq((op, a, b), e),
calc(a, ca),
calc(b, cb),
conde(
[eq("+", op), add(ca, cb, o)],
[eq("-", op), sub(ca, cb, o)],
[eq("*", op), mul(ca, cb, o)],
[eq("/", op), div(ca, cb, o)],
)
], [eqt(e, int), eq(e, o)])
import pytest
from mk.core import conj, eq
from mk.dsl import conjp
from mk.ext.lists import no_item
from mk.run import initial, reify
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
GOALS_DATA = [
(eq(a, []), a, [[]]),
(eq(a, [1]), a, [[1]]),
(conj(eq(a, [b]), eq(b, 1)), a, [[1]]),
(eq(a, [a]), a, []),
(conj(eq(a, [b]), eq(b, [1, 2])), a, [[[1, 2]]]),
(conj(eq(a, [0, b]), eq(b, [1, 2])), a, [[0, [1, 2]]]),
(conj(eq(a, [b, ...]), eq(b, [1, 2])), a, [[1, 2]]),
(conj(eq(a, [0, b, ...]), eq(b, [1, 2])), a, [[0, 1, 2]]),
(conjp(eq(a, [1]), eq(b, [1]), eq(a, b)), a, [[1]]),
(conjp(eq(a, [1]), eq(b, [2]), eq(a, b)), a, []),
(conjp(eq(a, [1]), eq(b, [1, 2]), eq(a, b)), a, []),
(conjp(eq(a, [1]), eq(b, []), eq(a, b)), a, []),
(eq([1], [1]), None, [None]),
(conj(eq(a, [1]), eq(a, [1])), a, [[1]]),
(conj(eq(a, [1]), eq([1], a)), a, [[1]]),
def delay_goal(a, b):
return conde(
eq(b, (1, a)),
(eq(a, 1), delay_goal(2, b)),
(eq(a, 2), delay_goal(3, b), eq(a, b))
)
def zzz_goal(a, b):
return conde(
eq(b, (1, a)),
(eq(a, 1), zzz(lambda: zzz_goal(2, b))),
(eq(a, 2), zzz(lambda: zzz_goal(3, b)), eq(a, b))
)
(eq(a, 1), zzz(lambda: zzz_goal(2, b))),
(eq(a, 2), zzz(lambda: zzz_goal(3, b)), eq(a, b))
)
@delay
def delay_goal(a, b):
return conde(
eq(b, (1, a)),
(eq(a, 1), delay_goal(2, b)),
(eq(a, 2), delay_goal(3, b), eq(a, b))
)
GOALS_DATA = [
(conj(eq(a, 1), fresh(lambda x: conj(eq(a, x), eq(x, c)))), c, [1]),
(
conj(
eq(a, 1),
fresh(2, lambda x, y: conj(eq((x, y), (a, 2)), eq(c, (x, y))))
),
c,
[(1, 2)]
),
(conjp(eq(a, 1), eq(b, 2), eq(c, (a, b))), c, [(1, 2)]),
(conjp(disjp(eq(a, 1), eq(a, 2), eq(a, 3)), eq(c, a)), c, [1, 3, 2]),
(
conde(
(eq(a, 1), eq(b, 2), eq(c, a)),
(eq(a, 2), eq(b, 3), eq(c, b)),
eq(c, 5),
import pytest
from mk.core import conj, disj, eq, eqt
from mk.run import initial
from mk.stream import unfold
from mk.unify import Var, convert
a = Var()
b = Var()
GOALS_DATA = [
(eq(a, 1), [{a: 1}]),
(disj(eq(a, 1), eq(a, 2)), [{a: 1}, {a: 2}]),
(conj(eq(a, 1), eq(a, 1)), [{a: 1}]),
(conj(eq(a, 1), eq(a, 2)), []),
(eqt(a, int), [{}]),
(conj(eq(a, 1), eqt(a, int)), [{a: 1}]),
(conj(eqt(a, int), eq(a, 1)), [{a: 1}]),
(conj(eq(a, 1), eqt(a, str)), []),
(conj(eqt(a, str), eq(a, 1)), []),
(conj(eqt(a, int), eqt(a, int)), [{}]),
(conj(eqt(a, int), eqt(a, str)), []),
(conj(conj(eqt(a, int), eqt(b, int)), eq(a, b)), [{a: b}]),
(conj(conj(eqt(a, int), eqt(b, str)), eq(a, b)), []),
(conj(conj(eq(a, [1]), eq(b, 1)), eq(a, [b])), [{a: convert([1]), b: 1}]),
(conj(conj(eq(a, [b]), eq(b, 1)), eq(a, [1])), [{a: convert([b]), b: 1}]),
(conj(conj(eq(a, [b]), eq(b, 1)), eq(a, [2])), [])
import pytest
from mk.core import conj, eq, eqt
from mk.disequality import neq, neqt
from mk.run import initial
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
GOALS_DATA = [
(neq(a, 1), [{}]),
(conj(eq(a, 1), neq(a, 2)), [{a: 1}]),
(conj(eq(a, 1), neq(a, 1)), []),
(conj(neq(a, 1), eq(a, 1)), []),
(conj(conj(eq(a, 1), neq(a, b)), eqt(b, str)), [{a: 1}]),
(neqt(a, int), [{}]),
(conj(eq(a, 1), neqt(a, str)), [{a: 1}]),
(conj(eqt(a, int), neqt(a, str)), [{}]),
(conj(eq(a, 1), neqt(a, int)), []),
(conj(eqt(a, int), neqt(a, int)), []),
(conj(neqt(a, int), eq(a, 1)), []),
(conj(neqt(a, int), eqt(a, int)), []),
]
@pytest.mark.parametrize("goal, expected", GOALS_DATA)
def test_disequality(goal, expected):
assert [s for s, _, _ in unfold(goal(initial()))] == expected
def eval_builtin(fn, arg, out):
return fresh(lambda t: conde(
(eq(fn, car_fn), eq([out, t, ...], arg)),
(eq(fn, cdr_fn), eq([t, out, ...], arg)),
))
def infer(expr, env, typ, ann):
return conde(
fresh(lambda n: conjp(
eq(expr, Sym(n)),
lookup(env, n, typ),
eq(ann, Ann(expr, typ)),
)),
fresh(
6, lambda f, ft, fa, a, at, aa: conjp(
eq(expr, App(f, a)),
infer(a, env, at, aa),
infer(f, env, TFunc(at, typ), fa),
eq(ann, App(fa, aa)),
)),
fresh(
5, lambda v, vt, b, bt, ba: conjp(
eq(expr, Abs(Sym(v), b)),
infer(b, ((v, TMono(vt)), env), bt, ba),
eq(typ, TFunc(vt, bt)),
eq(ann, Abs(Ann(Sym(v), vt), ba)),
)),
fresh(
4, lambda n, v, b, bm: conjp(
eq(expr, Let(Sym(n), v, b)),
infer(b, ((n, TPoly(env, v)), env), typ, bm),
eq(ann, Let(Sym(n), v, bm)),
)),
fresh(
3, lambda n, b, bm: conjp(
eq(expr, Rec(Sym(n), b)),
infer(b, ((n, TMono(typ)), env), typ, bm),
eq(ann, Rec(Ann(Sym(n), typ), bm)),
)),
fresh(
6, lambda c, cm, a, am, b, bm: conjp(
eq(expr, If(c, a, b)),
infer(c, env, TTerm("bool"), cm),
infer(a, env, typ, am),
infer(b, env, typ, bm),
eq(ann, If(cm, am, bm)),
)),
[eqt(expr, int), eq(typ, TTerm("int")),
eq(ann, expr)],
[eqt(expr, bool),
eq(typ, TTerm("bool")),
eq(ann, expr)],
)
a = Var()
b = Var()
c = Var()
GOALS_DATA = [
(add(1, 2, a), [{
a: 3
}]),
(add(1, a, 3), [{
a: 2
}]),
(add(a, 2, 3), [{
a: 1
}]),
(conj(add(1, a, b), eq(a, 2)), [{
a: 2,
b: 3
}]),
(conj(add(a, 2, b), eq(a, 1)), [{
a: 1,
b: 3
}]),
(conj(add(a, b, 3), eq(a, 1)), [{
a: 1,
b: 2
}]),
(conj(conj(add(a, b, c), eq(a, 1)), eq(b, 2)), [{
a: 1,
b: 2,
c: 3
def lookup(var, env, out):
return fresh(
3, lambda rest, sym, val: conj(
eq(Env(sym, val, rest), env),
conde((eq(sym, var), eq(val, out)),
(neq(sym, var), lookup(var, rest, out)))))
def jugs(states):
return disj(
eq([(0, 0, "")], states),
fresh(
8,
lambda big, small, act, prev_big, prev_small, tail, _, __: conjp(
eq([(big, small, act), tail, ...], states),
eq([(prev_big, prev_small, _), __, ...], tail),
conde(
[
conde(
[
eq(small, prev_small),
conde(
[eq(big, BIG), eq(act, "fill big")],
[eq(big, 0), eq(act, "empty big")])],
[
fresh(
lambda total: conjp(
conde(
[eq(big, BIG), eq(act, "to big")],
[
eq(small, SMALL),
eq(act, "to small")],
[
eq(small, 0), neq(big, BIG),
eq(act, "to big")],
[
eq(big, 0), neq(small, SMALL),
eq(act, "to small")]),
add(big, small, total),
add(prev_big, prev_small, total)))]),
neq(big, prev_big)],
[
eq(big, prev_big),
conde(
[eq(small, SMALL), eq(act, "fill small")],
[eq(small, 0), eq(act, "empty small")]),
neq(small, prev_small)]),
gte(big, 0), lte(big, BIG),
gte(small, 0), lte(small, SMALL),
jugs(tail),
)))
import pytest
from mk.core import conj, eq
from mk.deferred import predicate, relation
from mk.dsl import conjp
from mk.run import initial
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
GOALS_DATA = [
(conj(eq(a, 1), predicate(a, lambda a: a > 0)), [{
a: 1
}]),
(conj(predicate(a, lambda a: a > 0), eq(a, 1)), [{
a: 1
}]),
(conj(eq(a, 0), predicate(a, lambda a: a > 0)), []),
(conj(predicate(a, lambda a: a > 0), eq(a, 0)), []),
(predicate(a, lambda a: a > 0), [{}]),
(conjp(eq(a, 1), eq(b, 0), relation(a, b, lambda a, b: a > b)), [{
a: 1,
b: 0
}]),
(conjp(relation(a, b, lambda a, b: a > b), eq(a, 1), eq(b, 0)), [{
a: 1,
b: 0
}]),
(conjp(eq(a, 1), relation(a, b, lambda a, b: a > b), eq(b, 0)), [{
a: 1,
from collections import namedtuple
import pytest
from mk.core import eq, eqt
from mk.dsl import conjp
from mk.run import run
from mk.unify import Var
a = Var()
b = Var()
RUN_DATA = [
(eq(a, 1), a, 1),
(conjp(eq(a, (1, b)), eq(b, 2)), a, (1, 2)),
(conjp(eq(a, (1, b)), eq(b, 2)), (a, b), ((1, 2), 2)),
]
@pytest.mark.parametrize("goal, query, expected", RUN_DATA)
def test_run(goal, query, expected):
assert next(run(0, query, goal)) == expected
Tuple = namedtuple("Tuple", "a, b")
REIFY_DATA = [
(eq(a, a), a, '_0:_0'),
(eq(a, (1, b)), a, '(1, _0:_0)'),
(eq(a, Tuple(1, b)), a, 'Tuple(a=1, b=_0:_0)'),
(eq(a, [1, b]), a, '[1, _0:_0]'),
(eq(a, [1, b, ...]), a, '[1, _0:_0, Ellipsis]'),
import pytest
from mk.core import conj, eq
from mk.dsl import conjp
from mk.ext.tuples import no_item
from mk.run import initial, reify
from mk.stream import unfold
from mk.unify import Var
a = Var()
b = Var()
Tuple = namedtuple("Tuple", "x, y")
GOALS_DATA = [
(eq(a, ()), a, [()]),
(eq(a, (1, )), a, [(1, )]),
(conj(eq(a, (b, )), eq(b, 1)), a, [(1, )]),
(eq(a, (a, )), a, []),
(conjp(eq(a, (1, )), eq(b, (1, )), eq(a, b)), a, [(1, )]),
(conjp(eq(a, (1, )), eq(b, (2, )), eq(a, b)), a, []),
(conjp(eq(a, (1, )), eq(b, (1, 2)), eq(a, b)), a, []),
(conjp(eq(a, (1, )), eq(b, ()), eq(a, b)), a, []),
(conj(eq(a, Tuple(1, 2)), eq(a, Tuple(1, 2))), a, [Tuple(1, 2)]),
(conj(eq(a, Tuple(1, 1)), eq(a, Tuple(1, 2))), a, []),
(conj(eq(a, Tuple(1, 2)), eq(a, (1, 2))), a, []),
(no_item((1, 2, 3), lambda v: v == 0), None, [None]),
(no_item((1, 2, 3), lambda v: v == 1), None, []),
(conj(no_item(a, lambda v: v == 0), eq(a, (1, 2, 3))), None, [None]),
(conj(no_item(a, lambda v: v == 1), eq(a, (1, 2, 3))), None, []),
(no_item((1, (1, 2), (1, 2, (1, 2, 3))), lambda v: v == 0), None, [None]),
def builtin(fn, out):
return conde(
(eq(fn, car), eq(out, car_fn)),
(eq(fn, cdr), eq(out, cdr_fn)),
)
