laywerrobot/lib/python3.6/site-packages/nltk/sem/drt.py
2020-08-27 21:55:39 +02:00

1258 lines
49 KiB
Python

# Natural Language Toolkit: Discourse Representation Theory (DRT)
#
# Author: Dan Garrette <dhgarrette@gmail.com>
#
# Copyright (C) 2001-2018 NLTK Project
# URL: <http://nltk.org/>
# For license information, see LICENSE.TXT
from __future__ import print_function, unicode_literals
import operator
from functools import reduce
from itertools import chain
from six import string_types
from nltk.compat import python_2_unicode_compatible
from nltk.sem.logic import (APP, AbstractVariableExpression, AllExpression,
AndExpression, ApplicationExpression, BinaryExpression,
BooleanExpression, ConstantExpression, EqualityExpression,
EventVariableExpression, ExistsExpression, Expression,
FunctionVariableExpression, ImpExpression,
IndividualVariableExpression, LambdaExpression, Tokens,
LogicParser, NegatedExpression, OrExpression, Variable,
is_eventvar, is_funcvar, is_indvar, unique_variable)
# Import Tkinter-based modules if they are available
try:
from six.moves.tkinter import Canvas, Tk
from six.moves.tkinter_font import Font
from nltk.util import in_idle
except ImportError:
# No need to print a warning here, nltk.draw has already printed one.
pass
class DrtTokens(Tokens):
DRS = 'DRS'
DRS_CONC = '+'
PRONOUN = 'PRO'
OPEN_BRACKET = '['
CLOSE_BRACKET = ']'
COLON = ':'
PUNCT = [DRS_CONC, OPEN_BRACKET, CLOSE_BRACKET, COLON]
SYMBOLS = Tokens.SYMBOLS + PUNCT
TOKENS = Tokens.TOKENS + [DRS] + PUNCT
class DrtParser(LogicParser):
"""A lambda calculus expression parser."""
def __init__(self):
LogicParser.__init__(self)
self.operator_precedence = dict(
[(x,1) for x in DrtTokens.LAMBDA_LIST] + \
[(x,2) for x in DrtTokens.NOT_LIST] + \
[(APP,3)] + \
[(x,4) for x in DrtTokens.EQ_LIST+Tokens.NEQ_LIST] + \
[(DrtTokens.COLON,5)] + \
[(DrtTokens.DRS_CONC,6)] + \
[(x,7) for x in DrtTokens.OR_LIST] + \
[(x,8) for x in DrtTokens.IMP_LIST] + \
[(None,9)])
def get_all_symbols(self):
"""This method exists to be overridden"""
return DrtTokens.SYMBOLS
def isvariable(self, tok):
return tok not in DrtTokens.TOKENS
def handle(self, tok, context):
"""This method is intended to be overridden for logics that
use different operators or expressions"""
if tok in DrtTokens.NOT_LIST:
return self.handle_negation(tok, context)
elif tok in DrtTokens.LAMBDA_LIST:
return self.handle_lambda(tok, context)
elif tok == DrtTokens.OPEN:
if self.inRange(0) and self.token(0) == DrtTokens.OPEN_BRACKET:
return self.handle_DRS(tok, context)
else:
return self.handle_open(tok, context)
elif tok.upper() == DrtTokens.DRS:
self.assertNextToken(DrtTokens.OPEN)
return self.handle_DRS(tok, context)
elif self.isvariable(tok):
if self.inRange(0) and self.token(0) == DrtTokens.COLON:
return self.handle_prop(tok, context)
else:
return self.handle_variable(tok, context)
def make_NegatedExpression(self, expression):
return DrtNegatedExpression(expression)
def handle_DRS(self, tok, context):
# a DRS
refs = self.handle_refs()
if self.inRange(0) and self.token(0) == DrtTokens.COMMA: #if there is a comma (it's optional)
self.token() # swallow the comma
conds = self.handle_conds(context)
self.assertNextToken(DrtTokens.CLOSE)
return DRS(refs, conds, None)
def handle_refs(self):
self.assertNextToken(DrtTokens.OPEN_BRACKET)
refs = []
while self.inRange(0) and self.token(0) != DrtTokens.CLOSE_BRACKET:
# Support expressions like: DRS([x y],C) == DRS([x,y],C)
if refs and self.token(0) == DrtTokens.COMMA:
self.token() # swallow the comma
refs.append(self.get_next_token_variable('quantified'))
self.assertNextToken(DrtTokens.CLOSE_BRACKET)
return refs
def handle_conds(self, context):
self.assertNextToken(DrtTokens.OPEN_BRACKET)
conds = []
while self.inRange(0) and self.token(0) != DrtTokens.CLOSE_BRACKET:
# Support expressions like: DRS([x y],C) == DRS([x, y],C)
if conds and self.token(0) == DrtTokens.COMMA:
self.token() # swallow the comma
conds.append(self.process_next_expression(context))
self.assertNextToken(DrtTokens.CLOSE_BRACKET)
return conds
def handle_prop(self, tok, context):
variable = self.make_VariableExpression(tok)
self.assertNextToken(':')
drs = self.process_next_expression(DrtTokens.COLON)
return DrtProposition(variable, drs)
def make_EqualityExpression(self, first, second):
"""This method serves as a hook for other logic parsers that
have different equality expression classes"""
return DrtEqualityExpression(first, second)
def get_BooleanExpression_factory(self, tok):
"""This method serves as a hook for other logic parsers that
have different boolean operators"""
if tok == DrtTokens.DRS_CONC:
return lambda first, second: DrtConcatenation(first, second, None)
elif tok in DrtTokens.OR_LIST:
return DrtOrExpression
elif tok in DrtTokens.IMP_LIST:
def make_imp_expression(first, second):
if isinstance(first, DRS):
return DRS(first.refs, first.conds, second)
if isinstance(first, DrtConcatenation):
return DrtConcatenation(first.first, first.second, second)
raise Exception('Antecedent of implication must be a DRS')
return make_imp_expression
else:
return None
def make_BooleanExpression(self, factory, first, second):
return factory(first, second)
def make_ApplicationExpression(self, function, argument):
return DrtApplicationExpression(function, argument)
def make_VariableExpression(self, name):
return DrtVariableExpression(Variable(name))
def make_LambdaExpression(self, variables, term):
return DrtLambdaExpression(variables, term)
class DrtExpression(object):
"""
This is the base abstract DRT Expression from which every DRT
Expression extends.
"""
_drt_parser = DrtParser()
@classmethod
def fromstring(cls, s):
return cls._drt_parser.parse(s)
def applyto(self, other):
return DrtApplicationExpression(self, other)
def __neg__(self):
return DrtNegatedExpression(self)
def __and__(self, other):
raise NotImplementedError()
def __or__(self, other):
assert isinstance(other, DrtExpression)
return DrtOrExpression(self, other)
def __gt__(self, other):
assert isinstance(other, DrtExpression)
if isinstance(self, DRS):
return DRS(self.refs, self.conds, other)
if isinstance(self, DrtConcatenation):
return DrtConcatenation(self.first, self.second, other)
raise Exception('Antecedent of implication must be a DRS')
def equiv(self, other, prover=None):
"""
Check for logical equivalence.
Pass the expression (self <-> other) to the theorem prover.
If the prover says it is valid, then the self and other are equal.
:param other: an ``DrtExpression`` to check equality against
:param prover: a ``nltk.inference.api.Prover``
"""
assert isinstance(other, DrtExpression)
f1 = self.simplify().fol();
f2 = other.simplify().fol();
return f1.equiv(f2, prover)
@property
def type(self):
raise AttributeError("'%s' object has no attribute 'type'" %
self.__class__.__name__)
def typecheck(self, signature=None):
raise NotImplementedError()
def __add__(self, other):
return DrtConcatenation(self, other, None)
def get_refs(self, recursive=False):
"""
Return the set of discourse referents in this DRS.
:param recursive: bool Also find discourse referents in subterms?
:return: list of ``Variable`` objects
"""
raise NotImplementedError()
def is_pronoun_function(self):
""" Is self of the form "PRO(x)"? """
return isinstance(self, DrtApplicationExpression) and \
isinstance(self.function, DrtAbstractVariableExpression) and \
self.function.variable.name == DrtTokens.PRONOUN and \
isinstance(self.argument, DrtIndividualVariableExpression)
def make_EqualityExpression(self, first, second):
return DrtEqualityExpression(first, second)
def make_VariableExpression(self, variable):
return DrtVariableExpression(variable)
def resolve_anaphora(self):
return resolve_anaphora(self)
def eliminate_equality(self):
return self.visit_structured(lambda e: e.eliminate_equality(),
self.__class__)
def pretty_format(self):
"""
Draw the DRS
:return: the pretty print string
"""
return '\n'.join(self._pretty())
def pretty_print(self):
print(self.pretty_format())
def draw(self):
DrsDrawer(self).draw()
@python_2_unicode_compatible
class DRS(DrtExpression, Expression):
"""A Discourse Representation Structure."""
def __init__(self, refs, conds, consequent=None):
"""
:param refs: list of ``DrtIndividualVariableExpression`` for the
discourse referents
:param conds: list of ``Expression`` for the conditions
"""
self.refs = refs
self.conds = conds
self.consequent = consequent
def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
"""Replace all instances of variable v with expression E in self,
where v is free in self."""
if variable in self.refs:
#if a bound variable is the thing being replaced
if not replace_bound:
return self
else:
i = self.refs.index(variable)
if self.consequent:
consequent = self.consequent.replace(variable, expression, True, alpha_convert)
else:
consequent = None
return DRS(self.refs[:i]+[expression.variable]+self.refs[i+1:],
[cond.replace(variable, expression, True, alpha_convert)
for cond in self.conds],
consequent)
else:
if alpha_convert:
# any bound variable that appears in the expression must
# be alpha converted to avoid a conflict
for ref in (set(self.refs) & expression.free()):
newvar = unique_variable(ref)
newvarex = DrtVariableExpression(newvar)
i = self.refs.index(ref)
if self.consequent:
consequent = self.consequent.replace(ref, newvarex, True, alpha_convert)
else:
consequent = None
self = DRS(self.refs[:i]+[newvar]+self.refs[i+1:],
[cond.replace(ref, newvarex, True, alpha_convert)
for cond in self.conds],
consequent)
#replace in the conditions
if self.consequent:
consequent = self.consequent.replace(variable, expression, replace_bound, alpha_convert)
else:
consequent = None
return DRS(self.refs,
[cond.replace(variable, expression, replace_bound, alpha_convert)
for cond in self.conds],
consequent)
def free(self):
""":see: Expression.free()"""
conds_free = reduce(operator.or_, [c.free() for c in self.conds], set())
if self.consequent:
conds_free.update(self.consequent.free())
return conds_free - set(self.refs)
def get_refs(self, recursive=False):
""":see: AbstractExpression.get_refs()"""
if recursive:
conds_refs = self.refs + list(chain(*(c.get_refs(True) for c in self.conds)))
if self.consequent:
conds_refs.extend(self.consequent.get_refs(True))
return conds_refs
else:
return self.refs
def visit(self, function, combinator):
""":see: Expression.visit()"""
parts = list(map(function, self.conds))
if self.consequent:
parts.append(function(self.consequent))
return combinator(parts)
def visit_structured(self, function, combinator):
""":see: Expression.visit_structured()"""
consequent = (function(self.consequent) if self.consequent else None)
return combinator(self.refs, list(map(function, self.conds)), consequent)
def eliminate_equality(self):
drs = self
i = 0
while i < len(drs.conds):
cond = drs.conds[i]
if isinstance(cond, EqualityExpression) and \
isinstance(cond.first, AbstractVariableExpression) and \
isinstance(cond.second, AbstractVariableExpression):
drs = DRS(list(set(drs.refs)-set([cond.second.variable])),
drs.conds[:i]+drs.conds[i+1:],
drs.consequent)
if cond.second.variable != cond.first.variable:
drs = drs.replace(cond.second.variable, cond.first, False, False)
i = 0
i -= 1
i += 1
conds = []
for cond in drs.conds:
new_cond = cond.eliminate_equality()
new_cond_simp = new_cond.simplify()
if not isinstance(new_cond_simp, DRS) or \
new_cond_simp.refs or new_cond_simp.conds or \
new_cond_simp.consequent:
conds.append(new_cond)
consequent = (drs.consequent.eliminate_equality() if drs.consequent else None)
return DRS(drs.refs, conds, consequent)
def fol(self):
if self.consequent:
accum = None
if self.conds:
accum = reduce(AndExpression, [c.fol() for c in self.conds])
if accum:
accum = ImpExpression(accum, self.consequent.fol())
else:
accum = self.consequent.fol()
for ref in self.refs[::-1]:
accum = AllExpression(ref, accum)
return accum
else:
if not self.conds:
raise Exception("Cannot convert DRS with no conditions to FOL.")
accum = reduce(AndExpression, [c.fol() for c in self.conds])
for ref in map(Variable, self._order_ref_strings(self.refs)[::-1]):
accum = ExistsExpression(ref, accum)
return accum
def _pretty(self):
refs_line = ' '.join(self._order_ref_strings(self.refs))
cond_lines = [cond for cond_line in [filter(lambda s: s.strip(), cond._pretty())
for cond in self.conds]
for cond in cond_line]
length = max([len(refs_line)] + list(map(len, cond_lines)))
drs = ([' _' + '_' * length + '_ ',
'| ' + refs_line.ljust(length) + ' |',
'|-' + '-' * length + '-|'] +
['| ' + line.ljust(length) + ' |' for line in cond_lines] +
['|_' + '_' * length + '_|'])
if self.consequent:
return DrtBinaryExpression._assemble_pretty(drs, DrtTokens.IMP,
self.consequent._pretty())
return drs
def _order_ref_strings(self, refs):
strings = ["%s" % ref for ref in refs]
ind_vars = []
func_vars = []
event_vars = []
other_vars = []
for s in strings:
if is_indvar(s):
ind_vars.append(s)
elif is_funcvar(s):
func_vars.append(s)
elif is_eventvar(s):
event_vars.append(s)
else:
other_vars.append(s)
return sorted(other_vars) + \
sorted(event_vars, key=lambda v: int([v[2:],-1][len(v[2:]) == 0])) + \
sorted(func_vars, key=lambda v: (v[0], int([v[1:],-1][len(v[1:])==0]))) + \
sorted(ind_vars, key=lambda v: (v[0], int([v[1:],-1][len(v[1:])==0])))
def __eq__(self, other):
r"""Defines equality modulo alphabetic variance.
If we are comparing \x.M and \y.N, then check equality of M and N[x/y]."""
if isinstance(other, DRS):
if len(self.refs) == len(other.refs):
converted_other = other
for (r1, r2) in zip(self.refs, converted_other.refs):
varex = self.make_VariableExpression(r1)
converted_other = converted_other.replace(r2, varex, True)
if self.consequent == converted_other.consequent and \
len(self.conds) == len(converted_other.conds):
for c1, c2 in zip(self.conds, converted_other.conds):
if not (c1 == c2):
return False
return True
return False
def __ne__(self, other):
return not self == other
__hash__ = Expression.__hash__
def __str__(self):
drs = '([%s],[%s])' % (','.join(self._order_ref_strings(self.refs)),
', '.join("%s" % cond for cond in self.conds)) # map(str, self.conds)))
if self.consequent:
return DrtTokens.OPEN + drs + ' ' + DrtTokens.IMP + ' ' + \
"%s" % self.consequent + DrtTokens.CLOSE
return drs
def DrtVariableExpression(variable):
"""
This is a factory method that instantiates and returns a subtype of
``DrtAbstractVariableExpression`` appropriate for the given variable.
"""
if is_indvar(variable.name):
return DrtIndividualVariableExpression(variable)
elif is_funcvar(variable.name):
return DrtFunctionVariableExpression(variable)
elif is_eventvar(variable.name):
return DrtEventVariableExpression(variable)
else:
return DrtConstantExpression(variable)
class DrtAbstractVariableExpression(DrtExpression, AbstractVariableExpression):
def fol(self):
return self
def get_refs(self, recursive=False):
""":see: AbstractExpression.get_refs()"""
return []
def _pretty(self):
s = "%s" % self
blank = ' '*len(s)
return [blank, blank, s, blank]
def eliminate_equality(self):
return self
class DrtIndividualVariableExpression(DrtAbstractVariableExpression, IndividualVariableExpression):
pass
class DrtFunctionVariableExpression(DrtAbstractVariableExpression, FunctionVariableExpression):
pass
class DrtEventVariableExpression(DrtIndividualVariableExpression, EventVariableExpression):
pass
class DrtConstantExpression(DrtAbstractVariableExpression, ConstantExpression):
pass
@python_2_unicode_compatible
class DrtProposition(DrtExpression, Expression):
def __init__(self, variable, drs):
self.variable = variable
self.drs = drs
def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
if self.variable == variable:
assert isinstance(expression, DrtAbstractVariableExpression), "Can only replace a proposition label with a variable"
return DrtProposition(expression.variable, self.drs.replace(variable, expression, replace_bound, alpha_convert))
else:
return DrtProposition(self.variable, self.drs.replace(variable, expression, replace_bound, alpha_convert))
def eliminate_equality(self):
return DrtProposition(self.variable, self.drs.eliminate_equality())
def get_refs(self, recursive=False):
return (self.drs.get_refs(True) if recursive else [])
def __eq__(self, other):
return self.__class__ == other.__class__ and \
self.variable == other.variable and \
self.drs == other.drs
def __ne__(self, other):
return not self == other
__hash__ = Expression.__hash__
def fol(self):
return self.drs.fol()
def _pretty(self):
drs_s = self.drs._pretty()
blank = ' ' * len("%s" % self.variable)
return ([blank + ' ' + line for line in drs_s[:1]] +
["%s" % self.variable + ':' + line for line in drs_s[1:2]] +
[blank + ' ' + line for line in drs_s[2:]])
def visit(self, function, combinator):
""":see: Expression.visit()"""
return combinator([function(self.drs)])
def visit_structured(self, function, combinator):
""":see: Expression.visit_structured()"""
return combinator(self.variable, function(self.drs))
def __str__(self):
return 'prop(%s, %s)' % (self.variable, self.drs)
class DrtNegatedExpression(DrtExpression, NegatedExpression):
def fol(self):
return NegatedExpression(self.term.fol())
def get_refs(self, recursive=False):
""":see: AbstractExpression.get_refs()"""
return self.term.get_refs(recursive)
def _pretty(self):
term_lines = self.term._pretty()
return ([' ' + line for line in term_lines[:2]] +
['__ ' + line for line in term_lines[2:3]] +
[' | ' + line for line in term_lines[3:4]] +
[' ' + line for line in term_lines[4:]])
class DrtLambdaExpression(DrtExpression, LambdaExpression):
def alpha_convert(self, newvar):
"""Rename all occurrences of the variable introduced by this variable
binder in the expression to ``newvar``.
:param newvar: ``Variable``, for the new variable
"""
return self.__class__(newvar, self.term.replace(self.variable,
DrtVariableExpression(newvar), True))
def fol(self):
return LambdaExpression(self.variable, self.term.fol())
def _pretty(self):
variables = [self.variable]
term = self.term
while term.__class__ == self.__class__:
variables.append(term.variable)
term = term.term
var_string = ' '.join("%s" % v for v in variables) + DrtTokens.DOT
term_lines = term._pretty()
blank = ' ' * len(var_string)
return ([' ' + blank + line for line in term_lines[:1]] +
[' \ ' + blank + line for line in term_lines[1:2]] +
[' /\ ' + var_string + line for line in term_lines[2:3]] +
[' ' + blank + line for line in term_lines[3:]])
class DrtBinaryExpression(DrtExpression, BinaryExpression):
def get_refs(self, recursive=False):
""":see: AbstractExpression.get_refs()"""
return self.first.get_refs(True) + self.second.get_refs(True) if recursive else []
def _pretty(self):
return DrtBinaryExpression._assemble_pretty(self._pretty_subex(self.first), self.getOp(), self._pretty_subex(self.second))
@staticmethod
def _assemble_pretty(first_lines, op, second_lines):
max_lines = max(len(first_lines), len(second_lines))
first_lines = _pad_vertically(first_lines, max_lines)
second_lines = _pad_vertically(second_lines, max_lines)
blank = ' ' * len(op)
first_second_lines = list(zip(first_lines, second_lines))
return ([' ' + first_line + ' ' + blank + ' ' + second_line + ' ' for first_line, second_line in first_second_lines[:2]] +
['(' + first_line + ' ' + op + ' ' + second_line + ')' for first_line, second_line in first_second_lines[2:3]] +
[' ' + first_line + ' ' + blank + ' ' + second_line + ' ' for first_line, second_line in first_second_lines[3:]])
def _pretty_subex(self, subex):
return subex._pretty()
class DrtBooleanExpression(DrtBinaryExpression, BooleanExpression):
pass
class DrtOrExpression(DrtBooleanExpression, OrExpression):
def fol(self):
return OrExpression(self.first.fol(), self.second.fol())
def _pretty_subex(self, subex):
if isinstance(subex, DrtOrExpression):
return [line[1:-1] for line in subex._pretty()]
return DrtBooleanExpression._pretty_subex(self, subex)
class DrtEqualityExpression(DrtBinaryExpression, EqualityExpression):
def fol(self):
return EqualityExpression(self.first.fol(), self.second.fol())
@python_2_unicode_compatible
class DrtConcatenation(DrtBooleanExpression):
"""DRS of the form '(DRS + DRS)'"""
def __init__(self, first, second, consequent=None):
DrtBooleanExpression.__init__(self, first, second)
self.consequent = consequent
def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
"""Replace all instances of variable v with expression E in self,
where v is free in self."""
first = self.first
second = self.second
consequent = self.consequent
# If variable is bound
if variable in self.get_refs():
if replace_bound:
first = first.replace(variable, expression, replace_bound, alpha_convert)
second = second.replace(variable, expression, replace_bound, alpha_convert)
if consequent:
consequent = consequent.replace(variable, expression, replace_bound, alpha_convert)
else:
if alpha_convert:
# alpha convert every ref that is free in 'expression'
for ref in (set(self.get_refs(True)) & expression.free()):
v = DrtVariableExpression(unique_variable(ref))
first = first.replace(ref, v, True, alpha_convert)
second = second.replace(ref, v, True, alpha_convert)
if consequent:
consequent = consequent.replace(ref, v, True, alpha_convert)
first = first.replace(variable, expression, replace_bound, alpha_convert)
second = second.replace(variable, expression, replace_bound, alpha_convert)
if consequent:
consequent = consequent.replace(variable, expression, replace_bound, alpha_convert)
return self.__class__(first, second, consequent)
def eliminate_equality(self):
#TODO: at some point. for now, simplify.
drs = self.simplify()
assert not isinstance(drs, DrtConcatenation)
return drs.eliminate_equality()
def simplify(self):
first = self.first.simplify()
second = self.second.simplify()
consequent = (self.consequent.simplify() if self.consequent else None)
if isinstance(first, DRS) and isinstance(second, DRS):
# For any ref that is in both 'first' and 'second'
for ref in (set(first.get_refs(True)) & set(second.get_refs(True))):
# alpha convert the ref in 'second' to prevent collision
newvar = DrtVariableExpression(unique_variable(ref))
second = second.replace(ref, newvar, True)
return DRS(first.refs + second.refs, first.conds + second.conds, consequent)
else:
return self.__class__(first, second, consequent)
def get_refs(self, recursive=False):
""":see: AbstractExpression.get_refs()"""
refs = self.first.get_refs(recursive) + self.second.get_refs(recursive)
if self.consequent and recursive:
refs.extend(self.consequent.get_refs(True))
return refs
def getOp(self):
return DrtTokens.DRS_CONC
def __eq__(self, other):
r"""Defines equality modulo alphabetic variance.
If we are comparing \x.M and \y.N, then check equality of M and N[x/y]."""
if isinstance(other, DrtConcatenation):
self_refs = self.get_refs()
other_refs = other.get_refs()
if len(self_refs) == len(other_refs):
converted_other = other
for (r1,r2) in zip(self_refs, other_refs):
varex = self.make_VariableExpression(r1)
converted_other = converted_other.replace(r2, varex, True)
return self.first == converted_other.first and \
self.second == converted_other.second and \
self.consequent == converted_other.consequent
return False
def __ne__(self, other):
return not self == other
__hash__ = DrtBooleanExpression.__hash__
def fol(self):
e = AndExpression(self.first.fol(), self.second.fol())
if self.consequent:
e = ImpExpression(e, self.consequent.fol())
return e
def _pretty(self):
drs = DrtBinaryExpression._assemble_pretty(self._pretty_subex(self.first),
self.getOp(),
self._pretty_subex(self.second))
if self.consequent:
drs = DrtBinaryExpression._assemble_pretty(drs, DrtTokens.IMP,
self._pretty(self.consequent))
return drs
def _pretty_subex(self, subex):
if isinstance(subex, DrtConcatenation):
return [line[1:-1] for line in subex._pretty()]
return DrtBooleanExpression._pretty_subex(self, subex)
def visit(self, function, combinator):
""":see: Expression.visit()"""
if self.consequent:
return combinator([function(self.first), function(self.second), function(self.consequent)])
else:
return combinator([function(self.first), function(self.second)])
def __str__(self):
first = self._str_subex(self.first)
second = self._str_subex(self.second)
drs = Tokens.OPEN + first + ' ' + self.getOp() \
+ ' ' + second + Tokens.CLOSE
if self.consequent:
return DrtTokens.OPEN + drs + ' ' + DrtTokens.IMP + ' ' + \
"%s" % self.consequent + DrtTokens.CLOSE
return drs
def _str_subex(self, subex):
s = "%s" % subex
if isinstance(subex, DrtConcatenation) and subex.consequent is None:
return s[1:-1]
return s
class DrtApplicationExpression(DrtExpression, ApplicationExpression):
def fol(self):
return ApplicationExpression(self.function.fol(), self.argument.fol())
def get_refs(self, recursive=False):
""":see: AbstractExpression.get_refs()"""
return (self.function.get_refs(True) + self.argument.get_refs(True)
if recursive else [])
def _pretty(self):
function, args = self.uncurry()
function_lines = function._pretty()
args_lines = [arg._pretty() for arg in args]
max_lines = max(map(len, [function_lines] + args_lines))
function_lines = _pad_vertically(function_lines, max_lines)
args_lines = [_pad_vertically(arg_lines, max_lines) for arg_lines in args_lines]
func_args_lines = list(zip(function_lines, list(zip(*args_lines))))
return ([func_line + ' ' + ' '.join(args_line) + ' ' for func_line, args_line in func_args_lines[:2]] +
[func_line + '(' + ','.join(args_line) + ')' for func_line, args_line in func_args_lines[2:3]] +
[func_line + ' ' + ' '.join(args_line) + ' ' for func_line, args_line in func_args_lines[3:]])
def _pad_vertically(lines, max_lines):
pad_line = [' ' * len(lines[0])]
return lines + pad_line * (max_lines - len(lines))
@python_2_unicode_compatible
class PossibleAntecedents(list, DrtExpression, Expression):
def free(self):
"""Set of free variables."""
return set(self)
def replace(self, variable, expression, replace_bound=False, alpha_convert=True):
"""Replace all instances of variable v with expression E in self,
where v is free in self."""
result = PossibleAntecedents()
for item in self:
if item == variable:
self.append(expression)
else:
self.append(item)
return result
def _pretty(self):
s = "%s" % self
blank = ' ' * len(s)
return [blank, blank, s]
def __str__(self):
return '[' + ','.join("%s" % it for it in self) + ']'
class AnaphoraResolutionException(Exception):
pass
def resolve_anaphora(expression, trail=[]):
if isinstance(expression, ApplicationExpression):
if expression.is_pronoun_function():
possible_antecedents = PossibleAntecedents()
for ancestor in trail:
for ref in ancestor.get_refs():
refex = expression.make_VariableExpression(ref)
#==========================================================
# Don't allow resolution to itself or other types
#==========================================================
if refex.__class__ == expression.argument.__class__ and \
not (refex == expression.argument):
possible_antecedents.append(refex)
if len(possible_antecedents) == 1:
resolution = possible_antecedents[0]
else:
resolution = possible_antecedents
return expression.make_EqualityExpression(expression.argument, resolution)
else:
r_function = resolve_anaphora(expression.function, trail + [expression])
r_argument = resolve_anaphora(expression.argument, trail + [expression])
return expression.__class__(r_function, r_argument)
elif isinstance(expression, DRS):
r_conds = []
for cond in expression.conds:
r_cond = resolve_anaphora(cond, trail + [expression])
# if the condition is of the form '(x = [])' then raise exception
if isinstance(r_cond, EqualityExpression):
if isinstance(r_cond.first, PossibleAntecedents):
#Reverse the order so that the variable is on the left
temp = r_cond.first
r_cond.first = r_cond.second
r_cond.second = temp
if isinstance(r_cond.second, PossibleAntecedents):
if not r_cond.second:
raise AnaphoraResolutionException("Variable '%s' does not "
"resolve to anything." % r_cond.first)
r_conds.append(r_cond)
if expression.consequent:
consequent = resolve_anaphora(expression.consequent, trail + [expression])
else:
consequent = None
return expression.__class__(expression.refs, r_conds, consequent)
elif isinstance(expression, AbstractVariableExpression):
return expression
elif isinstance(expression, NegatedExpression):
return expression.__class__(resolve_anaphora(expression.term, trail + [expression]))
elif isinstance(expression, DrtConcatenation):
if expression.consequent:
consequent = resolve_anaphora(expression.consequent, trail + [expression])
else:
consequent = None
return expression.__class__(resolve_anaphora(expression.first, trail + [expression]),
resolve_anaphora(expression.second, trail + [expression]),
consequent)
elif isinstance(expression, BinaryExpression):
return expression.__class__(resolve_anaphora(expression.first, trail + [expression]),
resolve_anaphora(expression.second, trail + [expression]))
elif isinstance(expression, LambdaExpression):
return expression.__class__(expression.variable, resolve_anaphora(expression.term, trail + [expression]))
class DrsDrawer(object):
BUFFER = 3 #Space between elements
TOPSPACE = 10 #Space above whole DRS
OUTERSPACE = 6 #Space to the left, right, and bottom of the whle DRS
def __init__(self, drs, size_canvas=True, canvas=None):
"""
:param drs: ``DrtExpression``, The DRS to be drawn
:param size_canvas: bool, True if the canvas size should be the exact size of the DRS
:param canvas: ``Canvas`` The canvas on which to draw the DRS. If none is given, create a new canvas.
"""
master = None
if not canvas:
master = Tk()
master.title("DRT")
font = Font(family='helvetica', size=12)
if size_canvas:
canvas = Canvas(master, width=0, height=0)
canvas.font = font
self.canvas = canvas
(right, bottom) = self._visit(drs, self.OUTERSPACE, self.TOPSPACE)
width = max(right+self.OUTERSPACE, 100)
height = bottom+self.OUTERSPACE
canvas = Canvas(master, width=width, height=height)#, bg='white')
else:
canvas = Canvas(master, width=300, height=300)
canvas.pack()
canvas.font = font
self.canvas = canvas
self.drs = drs
self.master = master
def _get_text_height(self):
"""Get the height of a line of text"""
return self.canvas.font.metrics("linespace")
def draw(self, x=OUTERSPACE, y=TOPSPACE):
"""Draw the DRS"""
self._handle(self.drs, self._draw_command, x, y)
if self.master and not in_idle():
self.master.mainloop()
else:
return self._visit(self.drs, x, y)
def _visit(self, expression, x, y):
"""
Return the bottom-rightmost point without actually drawing the item
:param expression: the item to visit
:param x: the top of the current drawing area
:param y: the left side of the current drawing area
:return: the bottom-rightmost point
"""
return self._handle(expression, self._visit_command, x, y)
def _draw_command(self, item, x, y):
"""
Draw the given item at the given location
:param item: the item to draw
:param x: the top of the current drawing area
:param y: the left side of the current drawing area
:return: the bottom-rightmost point
"""
if isinstance(item, string_types):
self.canvas.create_text(x, y, anchor='nw', font=self.canvas.font, text=item)
elif isinstance(item, tuple):
# item is the lower-right of a box
(right, bottom) = item
self.canvas.create_rectangle(x, y, right, bottom)
horiz_line_y = y + self._get_text_height() + (self.BUFFER * 2) #the line separating refs from conds
self.canvas.create_line(x, horiz_line_y, right, horiz_line_y)
return self._visit_command(item, x, y)
def _visit_command(self, item, x, y):
"""
Return the bottom-rightmost point without actually drawing the item
:param item: the item to visit
:param x: the top of the current drawing area
:param y: the left side of the current drawing area
:return: the bottom-rightmost point
"""
if isinstance(item, string_types):
return (x + self.canvas.font.measure(item), y + self._get_text_height())
elif isinstance(item, tuple):
return item
def _handle(self, expression, command, x=0, y=0):
"""
:param expression: the expression to handle
:param command: the function to apply, either _draw_command or _visit_command
:param x: the top of the current drawing area
:param y: the left side of the current drawing area
:return: the bottom-rightmost point
"""
if command == self._visit_command:
#if we don't need to draw the item, then we can use the cached values
try:
#attempt to retrieve cached values
right = expression._drawing_width + x
bottom = expression._drawing_height + y
return (right, bottom)
except AttributeError:
#the values have not been cached yet, so compute them
pass
if isinstance(expression, DrtAbstractVariableExpression):
factory = self._handle_VariableExpression
elif isinstance(expression, DRS):
factory = self._handle_DRS
elif isinstance(expression, DrtNegatedExpression):
factory = self._handle_NegatedExpression
elif isinstance(expression, DrtLambdaExpression):
factory = self._handle_LambdaExpression
elif isinstance(expression, BinaryExpression):
factory = self._handle_BinaryExpression
elif isinstance(expression, DrtApplicationExpression):
factory = self._handle_ApplicationExpression
elif isinstance(expression, PossibleAntecedents):
factory = self._handle_VariableExpression
elif isinstance(expression, DrtProposition):
factory = self._handle_DrtProposition
else:
raise Exception(expression.__class__.__name__)
(right, bottom) = factory(expression, command, x, y)
#cache the values
expression._drawing_width = right - x
expression._drawing_height = bottom - y
return (right, bottom)
def _handle_VariableExpression(self, expression, command, x, y):
return command("%s" % expression, x, y)
def _handle_NegatedExpression(self, expression, command, x, y):
# Find the width of the negation symbol
right = self._visit_command(DrtTokens.NOT, x, y)[0]
# Handle term
(right, bottom) = self._handle(expression.term, command, right, y)
# Handle variables now that we know the y-coordinate
command(DrtTokens.NOT, x, self._get_centered_top(y, bottom - y, self._get_text_height()))
return (right, bottom)
def _handle_DRS(self, expression, command, x, y):
left = x + self.BUFFER #indent the left side
bottom = y + self.BUFFER #indent the top
# Handle Discourse Referents
if expression.refs:
refs = ' '.join("%s"%r for r in expression.refs)
else:
refs = ' '
(max_right, bottom) = command(refs, left, bottom)
bottom += (self.BUFFER * 2)
# Handle Conditions
if expression.conds:
for cond in expression.conds:
(right, bottom) = self._handle(cond, command, left, bottom)
max_right = max(max_right, right)
bottom += self.BUFFER
else:
bottom += self._get_text_height() + self.BUFFER
# Handle Box
max_right += self.BUFFER
return command((max_right, bottom), x, y)
def _handle_ApplicationExpression(self, expression, command, x, y):
function, args = expression.uncurry()
if not isinstance(function, DrtAbstractVariableExpression):
#It's not a predicate expression ("P(x,y)"), so leave arguments curried
function = expression.function
args = [expression.argument]
# Get the max bottom of any element on the line
function_bottom = self._visit(function, x, y)[1]
max_bottom = max([function_bottom] + [self._visit(arg, x, y)[1] for arg in args])
line_height = max_bottom - y
# Handle 'function'
function_drawing_top = self._get_centered_top(y, line_height, function._drawing_height)
right = self._handle(function, command, x, function_drawing_top)[0]
# Handle open paren
centred_string_top = self._get_centered_top(y, line_height, self._get_text_height())
right = command(DrtTokens.OPEN, right, centred_string_top)[0]
# Handle each arg
for (i,arg) in enumerate(args):
arg_drawing_top = self._get_centered_top(y, line_height, arg._drawing_height)
right = self._handle(arg, command, right, arg_drawing_top)[0]
if i+1 < len(args):
#since it's not the last arg, add a comma
right = command(DrtTokens.COMMA + ' ', right, centred_string_top)[0]
# Handle close paren
right = command(DrtTokens.CLOSE, right, centred_string_top)[0]
return (right, max_bottom)
def _handle_LambdaExpression(self, expression, command, x, y):
# Find the width of the lambda symbol and abstracted variables
variables = DrtTokens.LAMBDA + "%s" % expression.variable + DrtTokens.DOT
right = self._visit_command(variables, x, y)[0]
# Handle term
(right, bottom) = self._handle(expression.term, command, right, y)
# Handle variables now that we know the y-coordinate
command(variables, x, self._get_centered_top(y, bottom - y, self._get_text_height()))
return (right, bottom)
def _handle_BinaryExpression(self, expression, command, x, y):
# Get the full height of the line, based on the operands
first_height = self._visit(expression.first, 0, 0)[1]
second_height = self._visit(expression.second, 0, 0)[1]
line_height = max(first_height, second_height)
# Handle open paren
centred_string_top = self._get_centered_top(y, line_height, self._get_text_height())
right = command(DrtTokens.OPEN, x, centred_string_top)[0]
# Handle the first operand
first_height = expression.first._drawing_height
(right, first_bottom) = self._handle(expression.first, command, right, self._get_centered_top(y, line_height, first_height))
# Handle the operator
right = command(' %s ' % expression.getOp(), right, centred_string_top)[0]
# Handle the second operand
second_height = expression.second._drawing_height
(right, second_bottom) = self._handle(expression.second, command, right, self._get_centered_top(y, line_height, second_height))
# Handle close paren
right = command(DrtTokens.CLOSE, right, centred_string_top)[0]
return (right, max(first_bottom, second_bottom))
def _handle_DrtProposition(self, expression, command, x, y):
# Find the width of the negation symbol
right = command(expression.variable, x, y)[0]
# Handle term
(right, bottom) = self._handle(expression.term, command, right, y)
return (right, bottom)
def _get_centered_top(self, top, full_height, item_height):
"""Get the y-coordinate of the point that a figure should start at if
its height is 'item_height' and it needs to be centered in an area that
starts at 'top' and is 'full_height' tall."""
return top + (full_height - item_height) / 2
def demo():
print('='*20 + 'TEST PARSE' + '='*20)
dexpr = DrtExpression.fromstring
print(dexpr(r'([x,y],[sees(x,y)])'))
print(dexpr(r'([x],[man(x), walks(x)])'))
print(dexpr(r'\x.\y.([],[sees(x,y)])'))
print(dexpr(r'\x.([],[walks(x)])(john)'))
print(dexpr(r'(([x],[walks(x)]) + ([y],[runs(y)]))'))
print(dexpr(r'(([],[walks(x)]) -> ([],[runs(x)]))'))
print(dexpr(r'([x],[PRO(x), sees(John,x)])'))
print(dexpr(r'([x],[man(x), -([],[walks(x)])])'))
print(dexpr(r'([],[(([x],[man(x)]) -> ([],[walks(x)]))])'))
print('='*20 + 'Test fol()' + '='*20)
print(dexpr(r'([x,y],[sees(x,y)])').fol())
print('='*20 + 'Test alpha conversion and lambda expression equality' + '='*20)
e1 = dexpr(r'\x.([],[P(x)])')
print(e1)
e2 = e1.alpha_convert(Variable('z'))
print(e2)
print(e1 == e2)
print('='*20 + 'Test resolve_anaphora()' + '='*20)
print(resolve_anaphora(dexpr(r'([x,y,z],[dog(x), cat(y), walks(z), PRO(z)])')))
print(resolve_anaphora(dexpr(r'([],[(([x],[dog(x)]) -> ([y],[walks(y), PRO(y)]))])')))
print(resolve_anaphora(dexpr(r'(([x,y],[]) + ([],[PRO(x)]))')))
print('='*20 + 'Test pretty_print()' + '='*20)
dexpr(r"([],[])").pretty_print()
dexpr(r"([],[([x],[big(x), dog(x)]) -> ([],[bark(x)]) -([x],[walk(x)])])").pretty_print()
dexpr(r"([x,y],[x=y]) + ([z],[dog(z), walk(z)])").pretty_print()
dexpr(r"([],[([x],[]) | ([y],[]) | ([z],[dog(z), walk(z)])])").pretty_print()
dexpr(r"\P.\Q.(([x],[]) + P(x) + Q(x))(\x.([],[dog(x)]))").pretty_print()
def test_draw():
try:
from six.moves.tkinter import Tk
except ImportError:
from nose import SkipTest
raise SkipTest("tkinter is required, but it's not available.")
expressions = [
r'x',
r'([],[])',
r'([x],[])',
r'([x],[man(x)])',
r'([x,y],[sees(x,y)])',
r'([x],[man(x), walks(x)])',
r'\x.([],[man(x), walks(x)])',
r'\x y.([],[sees(x,y)])',
r'([],[(([],[walks(x)]) + ([],[runs(x)]))])',
r'([x],[man(x), -([],[walks(x)])])',
r'([],[(([x],[man(x)]) -> ([],[walks(x)]))])'
]
for e in expressions:
d = DrtExpression.fromstring(e)
d.draw()
if __name__ == '__main__':
demo()