from dreamcoder.type import *
from dreamcoder.program import *
from dreamcoder.frontier import *
from collections import Counter
class MatchFailure(Exception):
pass
class Matcher(object):
def __init__(self, context):
self.context = context
self.variableBindings = {}
@staticmethod
def match(context, fragment, expression, numberOfArguments):
if not mightMatch(fragment, expression):
raise MatchFailure()
m = Matcher(context)
tp = fragment.visit(m, expression, [], numberOfArguments)
return m.context, tp, m.variableBindings
def application(
self,
fragment,
expression,
environment,
numberOfArguments):
'''returns tp of fragment.'''
if not isinstance(expression, Application):
raise MatchFailure()
ft = fragment.f.visit(
self,
expression.f,
environment,
numberOfArguments + 1)
xt = fragment.x.visit(self, expression.x, environment, 0)
self.context, returnType = self.context.makeVariable()
try:
self.context = self.context.unify(ft, arrow(xt, returnType))
except UnificationFailure:
raise MatchFailure()
return returnType.apply(self.context)
def index(self, fragment, expression, environment, numberOfArguments):
# This is a bound variable
surroundingAbstractions = len(environment)
if fragment.bound(surroundingAbstractions):
if expression == fragment:
return environment[fragment.i].apply(self.context)
else:
raise MatchFailure()
# This is a free variable
i = fragment.i - surroundingAbstractions
# Make sure that it doesn't refer to anything bound by a
# lambda in the fragment. Otherwise it cannot be safely lifted
# out of the fragment and preserve semantics
for fv in expression.freeVariables():
if fv < len(environment):
raise MatchFailure()
# The value is going to be lifted out of the fragment
try:
expression = expression.shift(-surroundingAbstractions)
except ShiftFailure:
raise MatchFailure()
# Wrap it in the appropriate number of lambda expressions & applications
# This is because everything has to be in eta-longform
if numberOfArguments > 0:
expression = expression.shift(numberOfArguments)
for j in reversed(range(numberOfArguments)):
expression = Application(expression, Index(j))
for _ in range(numberOfArguments):
expression = Abstraction(expression)
# Added to the bindings
if i in self.variableBindings:
(tp, binding) = self.variableBindings[i]
if binding != expression:
raise MatchFailure()
else:
self.context, tp = self.context.makeVariable()
self.variableBindings[i] = (tp, expression)
return tp
def abstraction(
self,
fragment,
expression,
environment,
numberOfArguments):
if not isinstance(expression, Abstraction):
raise MatchFailure()
self.context, argumentType = self.context.makeVariable()
returnType = fragment.body.visit(
self, expression.body, [argumentType] + environment, 0)
return arrow(argumentType, returnType)
def primitive(self, fragment, expression, environment, numberOfArguments):
if fragment != expression:
raise MatchFailure()
self.context, tp = fragment.tp.instantiate(self.context)
return tp
def invented(self, fragment, expression, environment, numberOfArguments):
if fragment != expression:
raise MatchFailure()
self.context, tp = fragment.tp.instantiate(self.context)
return tp
def fragmentVariable(
self,
fragment,
expression,
environment,
numberOfArguments):
raise Exception(
'Deprecated: matching against fragment variables. Convert fragment to canonical form to get rid of fragment variables.')
def mightMatch(f, e, d=0):
'''Checks whether fragment f might be able to match against expression e'''
if f.isIndex:
if f.bound(d):
return f == e
return True
if f.isPrimitive or f.isInvented:
return f == e
if f.isAbstraction:
return e.isAbstraction and mightMatch(f.body, e.body, d + 1)
if f.isApplication:
return e.isApplication and mightMatch(
f.x, e.x, d) and mightMatch(
f.f, e.f, d)
assert False
def canonicalFragment(expression):
'''
Puts a fragment into a canonical form:
1. removes all FragmentVariable's
2. renames all free variables based on depth first traversal
'''
return expression.visit(CanonicalVisitor(), 0)
class CanonicalVisitor(object):
def __init__(self):
self.numberOfAbstractions = 0
self.mapping = {}
def fragmentVariable(self, e, d):
self.numberOfAbstractions += 1
return Index(self.numberOfAbstractions + d - 1)
def primitive(self, e, d): return e
def invented(self, e, d): return e
def application(self, e, d):
return Application(e.f.visit(self, d), e.x.visit(self, d))
def abstraction(self, e, d):
return Abstraction(e.body.visit(self, d + 1))
def index(self, e, d):
if e.bound(d):
return e
i = e.i - d
if i in self.mapping:
return Index(d + self.mapping[i])
self.mapping[i] = self.numberOfAbstractions
self.numberOfAbstractions += 1
return Index(self.numberOfAbstractions - 1 + d)
def fragmentSize(f, boundVariableCost=0.1, freeVariableCost=0.01):
freeVariables = 0
leaves = 0
boundVariables = 0
for surroundingAbstractions, e in f.walk():
if isinstance(e, (Primitive, Invented)):
leaves += 1
if isinstance(e, Index):
if e.bound(surroundingAbstractions):
boundVariables += 1
else:
freeVariables += 1
assert not isinstance(e, FragmentVariable)
return leaves + boundVariableCost * \
boundVariables + freeVariableCost * freeVariables
def primitiveSize(e):
if e.isInvented:
e = e.body
return fragmentSize(e)
def defragment(expression):
'''Converts a fragment into an invented primitive'''
if isinstance(expression, (Primitive, Invented)):
return expression
expression = canonicalFragment(expression)
for _ in range(expression.numberOfFreeVariables):
expression = Abstraction(expression)
return Invented(expression)
class RewriteFragments(object):
def __init__(self, fragment):
self.fragment = fragment
self.concrete = defragment(fragment)
def tryRewrite(self, e, numberOfArguments):
try:
context, t, bindings = Matcher.match(
Context.EMPTY, self.fragment, e, numberOfArguments)
except MatchFailure:
return None
assert frozenset(bindings.keys()) == frozenset(range(len(bindings))),\
"Perhaps the fragment is not in canonical form?"
e = self.concrete
for j in range(len(bindings) - 1, -1, -1):
_, b = bindings[j]
e = Application(e, b)
return e
def application(self, e, numberOfArguments):
e = Application(e.f.visit(self, numberOfArguments + 1),
e.x.visit(self, 0))
return self.tryRewrite(e, numberOfArguments) or e
def index(self, e, numberOfArguments): return e
def invented(self, e, numberOfArguments): return e
def primitive(self, e, numberOfArguments): return e
def abstraction(self, e, numberOfArguments):
e = Abstraction(e.body.visit(self, 0))
return self.tryRewrite(e, numberOfArguments) or e
def rewrite(self, e): return e.visit(self, 0)
@staticmethod
def rewriteFrontier(frontier, fragment):
worker = RewriteFragments(fragment)
return Frontier([FrontierEntry(program=worker.rewrite(e.program),
logLikelihood=e.logLikelihood,
logPrior=e.logPrior,
logPosterior=e.logPosterior)
for e in frontier],
task=frontier.task)
def proposeFragmentsFromFragment(f):
'''Abstracts out repeated structure within a single fragment'''
yield f
freeVariables = f.numberOfFreeVariables
closedSubtrees = Counter(
subtree for _,
subtree in f.walk() if not isinstance(
subtree,
Index) and subtree.closed)
del closedSubtrees[f]
for subtree, freq in closedSubtrees.items():
if freq < 2:
continue
yield canonicalFragment(f.substitute(subtree, Index(freeVariables)))
def nontrivial(f):
if not isinstance(f, Application):
return False
# Curry
if isinstance(f.x, FragmentVariable):
return False
if isinstance(f.x, Index):
# Make sure that the index is used somewhere else
if not any(
isinstance(
child,
Index) and child.i -
surroundingAbstractions == f.x.i for surroundingAbstractions,
child in f.f.walk()):
return False
numberOfHoles = 0
numberOfVariables = 0
numberOfPrimitives = 0
for surroundingAbstractions, child in f.walk():
if isinstance(child, (Primitive, Invented)):
numberOfPrimitives += 1
if isinstance(child, FragmentVariable):
numberOfHoles += 1
if isinstance(child, Index) and child.free(surroundingAbstractions):
numberOfVariables += 1
#eprint("Fragment %s has %d calls and %d variables and %d primitives"%(f,numberOfHoles,numberOfVariables,numberOfPrimitives))
return numberOfPrimitives + 0.5 * \
(numberOfHoles + numberOfVariables) > 1.5 and numberOfPrimitives >= 1
def violatesLaziness(fragment):
"""
conditionals are lazy on the second and third arguments. this
invariant must be maintained by learned fragments.
"""
for surroundingAbstractions, child in fragment.walkUncurried():
if not child.isApplication:
continue
f, xs = child.applicationParse()
if not (f.isPrimitive and f.name == "if"):
continue
# curried conditionals always violate laziness
if len(xs) != 3:
return True
# yes/no branches
y = xs[1]
n = xs[2]
return \
any(yc.isIndex and yc.i >= yd
for yd, yc in y.walk(surroundingAbstractions)) or \
any(nc.isIndex and nc.i >= nd
for nd, nc in n.walk(surroundingAbstractions))
return False
def proposeFragmentsFromProgram(p, arity):
def fragment(expression, a, toplevel=True):
"""Generates fragments that unify with expression"""
if a == 1:
yield FragmentVariable.single
if a == 0:
yield expression
return
if isinstance(expression, Abstraction):
# Symmetry breaking: (\x \y \z ... f(x,y,z,...)) defragments to be
# the same as f(x,y,z,...)
if not toplevel:
for b in fragment(expression.body, a, toplevel=False):
yield Abstraction(b)
elif isinstance(expression, Application):
for fa in range(a + 1):
for f in fragment(expression.f, fa, toplevel=False):
for x in fragment(expression.x, a - fa, toplevel=False):
yield Application(f, x)
else:
assert isinstance(expression, (Invented, Primitive, Index))
def fragments(expression, a):
"""Generates fragments that unify with subexpressions of expression"""
yield from fragment(expression, a)
if isinstance(expression, Application):
curry = True
if curry:
yield from fragments(expression.f, a)
yield from fragments(expression.x, a)
else:
# Pretend that it is not curried
function, arguments = expression.applicationParse()
yield from fragments(function, a)
for argument in arguments:
yield from fragments(argument, a)
elif isinstance(expression, Abstraction):
yield from fragments(expression.body, a)
else:
assert isinstance(expression, (Invented, Primitive, Index))
return {canonicalFragment(f) for b in range(arity + 1)
for f in fragments(p, b) if nontrivial(f)}
def proposeFragmentsFromFrontiers(frontiers, a, CPUs=1):
fragmentsFromEachFrontier = parallelMap(
CPUs, lambda frontier: {
fp for entry in frontier.entries for f in proposeFragmentsFromProgram(
entry.program, a) for fp in proposeFragmentsFromFragment(f)}, frontiers)
allFragments = Counter(f for frontierFragments in fragmentsFromEachFrontier
for f in frontierFragments)
return [fragment for fragment, frequency in allFragments.items()
if frequency >= 2 and fragment.wellTyped() and nontrivial(fragment)]