def _read_depgraph(node, depgraph, label_counter=None, parent=None):
if not label_counter:
label_counter = Counter()
if node['rel'].lower() in ['spec', 'punct']:
# the value of a 'spec' entry is a word, not an FStructure
return (node['word'], node['tag'])
else:
fstruct = FStructure()
fstruct.pred = None
fstruct.label = FStructure._make_label(label_counter.get())
fstruct.parent = parent
word, tag = node['word'], node['tag']
if tag[:2] == 'VB':
if tag[2:3] == 'D':
fstruct.safeappend('tense', ('PAST', 'tense'))
fstruct.pred = (word, tag[:2])
if not fstruct.pred:
fstruct.pred = (word, tag)
children = [
depgraph.nodes[idx] for idx in chain(*node['deps'].values())
]
for child in children:
fstruct.safeappend(
child['rel'],
FStructure._read_depgraph(child, depgraph, label_counter,
fstruct),
)
return fstruct
def skolemise(self):
"""
Perform a simple Skolemisation operation. Existential quantifiers are
simply dropped and all variables they introduce are renamed so that
they are unique.
"""
return self._skolemise(set(), Counter())
def _read_depgraph(node, depgraph, label_counter=None, parent=None):
if not label_counter:
label_counter = Counter()
if node["rel"].lower() in ["spec", "punct"]:
# the value of a 'spec' entry is a word, not an FStructure
return (node["word"], node["tag"])
else:
fstruct = FStructure()
fstruct.pred = None
fstruct.label = FStructure._make_label(label_counter.get())
fstruct.parent = parent
word, tag = node["word"], node["tag"]
if tag[:2] == "VB":
if tag[2:3] == "D":
fstruct.safeappend("tense", ("PAST", "tense"))
fstruct.pred = (word, tag[:2])
if not fstruct.pred:
fstruct.pred = (word, tag)
children = [
depgraph.nodes[idx] for idx in chain(*node["deps"].values())
]
for child in children:
fstruct.safeappend(
child["rel"],
FStructure._read_depgraph(child, depgraph, label_counter,
fstruct),
)
return fstruct
def compile(self, counter=None):
"""From Iddo Lev's PhD Dissertation p108-109"""
if not counter:
counter = Counter()
(compiled_glue,
new_forms) = self.glue.simplify().compile_pos(counter, self.__class__)
return new_forms + [
self.__class__(self.meaning, compiled_glue, set([counter.get()]))
]
def to_glueformula_list(self, depgraph, node=None, counter=None, verbose=False):
if node is None:
top = depgraph.nodelist[0]
root = depgraph.nodelist[top['deps'][0]]
return self.to_glueformula_list(depgraph, root, Counter(), verbose)
glueformulas = self.lookup(node, depgraph, counter)
for dep_idx in node['deps']:
dep = depgraph.nodelist[dep_idx]
glueformulas.extend(self.to_glueformula_list(depgraph, dep, counter, verbose))
return glueformulas
def gfl_to_compiled(self, gfl):
index_counter = Counter()
return_list = []
for gf in gfl:
return_list.extend(gf.compile(index_counter))
if self.verbose:
print("Compiled Glue Premises:")
for cgf in return_list:
print(cgf)
return return_list
def to_glueformula_list(self, depgraph, node=None, counter=None, verbose=False):
if node is None:
# TODO: should it be depgraph.root? Is this code tested?
top = depgraph.nodes[0]
depList = sum(list(top['deps'].values()), [])
root = depgraph.nodes[depList[0]]
return self.to_glueformula_list(depgraph, root, Counter(), verbose)
glueformulas = self.lookup(node, depgraph, counter)
for dep_idx in sum(list(node['deps'].values()), []):
dep = depgraph.nodes[dep_idx]
glueformulas.extend(self.to_glueformula_list(depgraph, dep, counter, verbose))
return glueformulas
def to_glueformula_list(self,
depgraph,
node=None,
counter=None,
verbose=False):
if node is None:
top = depgraph.nodes[0]
depList = sum(list(top['deps'].values()), [])
root = depgraph.nodes[depList[0]]
#print (root)
return self.to_glueformula_list(depgraph, root, Counter(), verbose)
glueformulas = self.lookup(node, depgraph, counter)
for dep_idx in sum(list(node['deps'].values()), []):
dep = depgraph.nodes[dep_idx]
glueformulas.extend(
self.to_glueformula_list(depgraph, dep, counter, verbose))
return glueformulas
class InstantiateVarsChart(Chart):
"""
A specialized chart that 'instantiates' variables whose names
start with '@', by replacing them with unique new variables.
In particular, whenever a complete edge is added to the chart, any
variables in the edge's C{lhs} whose names start with '@' will be
replaced by unique new L{IndVariable}s.
"""
def __init__(self, tokens):
Chart.__init__(self, tokens)
self._instantiated = set()
def insert(self, edge, child_pointer_list):
if edge in self._instantiated: return False
edge = self.instantiate_edge(edge)
return Chart.insert(self, edge, child_pointer_list)
def instantiate_edge(self, edge):
# If the edge is a leaf, or is not complete, or is
# already in the chart, then just return it as-is.
if not isinstance(edge, FeatureTreeEdge): return edge
if not edge.is_complete(): return edge
if edge in self._edge_to_cpls: return edge
# Get a list of variables that need to be instantiated.
# If there are none, then return the edge as-is.
inst_vars = self.inst_vars(edge)
if not inst_vars: return edge
# Instantiate the edge!
self._instantiated.add(edge)
lhs = edge.lhs().substitute_bindings(inst_vars)
return FeatureTreeEdge(edge.span(), lhs, edge.rhs(), edge.dot(),
edge.bindings())
counter = Counter(100)
def inst_vars(self, edge):
return dict((var, unique_variable(self.counter).variable)
for var in edge.lhs().variables()
if var.name.startswith('@'))
AllExpression,
NegatedExpression,
ExistsExpression,
Variable,
ImpExpression,
AndExpression,
unique_variable,
LambdaExpression,
IffExpression,
OrExpression,
FunctionVariableExpression,
)
from nltk.inference.api import Prover, BaseProverCommand
_counter = Counter()
class ProverParseError(Exception):
pass
class TableauProver(Prover):
_assume_false = False
def _prove(self, goal=None, assumptions=None, verbose=False):
if not assumptions:
assumptions = []
result = None
try:
def parse(self, data, signature=None):
self._label_counter = Counter(-1)
return DrtParser.parse(self, data, signature)
class VariableBinderExpression(Expression):
"""A variable binding expression: e.g. \\x.M."""
# for generating "unique" variable names during alpha conversion.
_counter = Counter()
def __init__(self, variable, term):
Expression.__init__(self)
assert isinstance(variable, Variable)
assert isinstance(term, Expression)
self.variable = variable
self.term = term
self.prefix = self.__class__.PREFIX.rstrip()
self.binder = (self.prefix, self.variable.name)
self.body = str(self.term)
# nb: __ne__ defined by Expression
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 self.__class__ == other.__class__:
if self.variable == other.variable:
return self.term == other.term
else:
# Comparing \x.M and \y.N.
# Relabel y in N with x and continue.
relabeled = self._relabel(other)
return self.term == relabeled
else:
return False
def _relabel(self, other):
"""
Relabel C{other}'s bound variables to be the same as C{self}'s
variable.
"""
var = VariableExpression(self.variable)
return other.term.replace(other.variable, var)
def variables(self):
vars = [self.variable]
for var in self.term.variables():
if var not in vars: vars.append(var)
return vars
def free(self):
return self.term.free().difference(set([self.variable]))
def subterms(self):
return self.term.subterms().union([self])
def replace(self, variable, expression, replace_bound=False):
if self.variable == variable:
if not replace_bound: return self
else:
return self.__class__(
expression, self.term.replace(variable, expression, True))
if replace_bound or self.variable in expression.free():
v = 'z' + str(self._counter.get())
if not replace_bound: self = self.alpha_convert(Variable(v))
return self.__class__(
self.variable,
self.term.replace(variable, expression, replace_bound))
def alpha_convert(self, newvar):
"""
Rename all occurrences of the variable introduced by this variable
binder in the expression to @C{newvar}.
"""
term = self.term.replace(self.variable, VariableExpression(newvar))
return self.__class__(newvar, term)
def simplify(self):
return self.__class__(self.variable, self.term.simplify())
def infixify(self):
return self.__class__(self.variable, self.term.infixify())
def __str__(self, continuation=0):
# Print \x.\y.M as \x y.M.
if continuation:
prefix = ' '
else:
prefix = self.__class__.PREFIX
if self.term.__class__ == self.__class__:
return '%s%s%s' % (prefix, self.variable, self.term.__str__(1))
else:
return '%s%s.%s' % (prefix, self.variable, self.term)
def __hash__(self):
return hash(str(self.normalize()))
