Coverage for nltk.sem.linearlogic: 30%

raise LinearLogicApplicationException('Dependencies unfulfilled when attempting to apply Linear Logic formula %s to %s' % (function_simp, argument_simp))

if set(function_simp.antecedent.dependencies) == argument_indices:

raise LinearLogicApplicationException('Dependencies not a proper subset of indices when attempting to apply Linear Logic formula %s to %s' % (function_simp, argument_simp))

self.function = function

self.argument = argument

self.bindings = bindings

def simplify(self, bindings=None):

"""

Since function is an implication, return its consequent. There should be

no need to check that the application is valid since the checking is done

by the constructor.

:param bindings: ``BindingDict`` A dictionary of bindings used to simplify

:return: ``Expression``

"""

if not bindings:

bindings = self.bindings

return self.function.simplify(bindings).consequent

def __eq__(self, other):

return self.__class__ == other.__class__ and \

self.function == other.function and self.argument == other.argument

def __str__(self):

return str(self.function) + Tokens.OPEN + str(self.argument) + Tokens.CLOSE

def __hash__(self):

return hash('%s%s%s' % (hash(self.antecedent), Tokens.OPEN, hash(self.consequent)))

class BindingDict(object):

def __init__(self, binding_list=None):

"""

:param binding_list: list of (``VariableExpression``, ``AtomicExpression``) to initialize the dictionary

"""

self.d = {}

if binding_list:

for (v, b) in binding_list:

self[v] = b

def __setitem__(self, variable, binding):

"""

A binding is consistent with the dict if its variable is not already bound, OR if its

variable is already bound to its argument.

:param variable: ``VariableExpression`` The variable bind

:param binding: ``Expression`` The expression to which 'variable' should be bound

:raise VariableBindingException: If the variable cannot be bound in this dictionary

"""

assert isinstance(variable, VariableExpression)

assert isinstance(binding, Expression)

assert variable != binding

try:

existing = self.d[variable]

except KeyError:

existing = None

if not existing or binding == existing:

self.d[variable] = binding

else:

raise VariableBindingException('Variable %s already bound to another value' % (variable))

def __getitem__(self, variable):

"""

Return the expression to which 'variable' is bound

"""

assert isinstance(variable, VariableExpression)

intermediate = self.d[variable]

while intermediate:

try:

intermediate = self.d[intermediate]

except KeyError:

return intermediate

def __contains__(self, item):

return item in self.d

def __add__(self, other):

"""

:param other: ``BindingDict`` The dict with which to combine self

:return: ``BindingDict`` A new dict containing all the elements of both parameters

:raise VariableBindingException: If the parameter dictionaries are not consistent with each other

"""

try:

combined = BindingDict()

for v in self.d:

combined[v] = self.d[v]

for v in other.d:

combined[v] = other.d[v]

return combined

except VariableBindingException:

raise VariableBindingException('Attempting to add two contradicting'\

' VariableBindingsLists: %s, %s' % (self, other))

def __str__(self):

return '{' + ', '.join(['%s: %s' % (v, self.d[v]) for v in self.d]) + '}'

def __repr__(self):

return 'BindingDict: ' + str(self)

class VariableBindingException(Exception): pass

class UnificationException(Exception):

def __init__(self, a, b, bindings):

Exception.__init__(self, 'Cannot unify %s with %s given %s' % (a, b, bindings))

class LinearLogicApplicationException(Exception): pass

class Tokens(object):

#Punctuation

OPEN = '('

CLOSE = ')'

#Operations

IMP = '-o'

PUNCT = [OPEN, CLOSE]

TOKENS = PUNCT + [IMP]

class LinearLogicParser(LogicParser):

"""A linear logic expression parser."""

def __init__(self):

LogicParser.__init__(self)

self.operator_precedence = {APP: 1, Tokens.IMP: 2, None: 3}

self.right_associated_operations += [Tokens.IMP]

def get_all_symbols(self):

return Tokens.TOKENS

def handle(self, tok, context):

if tok not in Tokens.TOKENS:

return self.handle_variable(tok, context)

elif tok == Tokens.OPEN:

return self.handle_open(tok, context)

def get_BooleanExpression_factory(self, tok):

if tok == Tokens.IMP:

return ImpExpression

else:

return None

def make_BooleanExpression(self, factory, first, second):

return factory(first, second)

def attempt_ApplicationExpression(self, expression, context):

"""Attempt to make an application expression. If the next tokens

are an argument in parens, then the argument expression is a

function being applied to the arguments. Otherwise, return the

argument expression."""

if self.has_priority(APP, context):

if self.inRange(0) and self.token(0) == Tokens.OPEN:

self.token() #swallow then open paren

argument = self.parse_Expression(APP)

self.assertNextToken(Tokens.CLOSE)

expression = ApplicationExpression(expression, argument, None)

return expression

def make_VariableExpression(self, name):

if name[0].isupper():

return VariableExpression(name)

else:

return ConstantExpression(name)

def demo():

llp = LinearLogicParser()

print(llp.parse(r'f'))

print(llp.parse(r'(g -o f)'))

print(llp.parse(r'((g -o G) -o G)'))

print(llp.parse(r'g -o h -o f'))

print(llp.parse(r'(g -o f)(g)').simplify())

print(llp.parse(r'(H -o f)(g)').simplify())

print(llp.parse(r'((g -o G) -o G)((g -o f))').simplify())

print(llp.parse(r'(H -o H)((g -o f))').simplify())

if __name__ == '__main__':

demo()

Coverage for nltk.sem.linearlogic : 30%

220 statements 65 run 155 missing 0 excluded