def s_retrieve(self, trace=False):
"""
Carry out S-Retrieval of binding operators in store. If hack=True,
serialize the bindop and core as strings and reparse. Ugh.
Each permutation of the store (i.e. list of binding operators) is
taken to be a possible scoping of quantifiers. We iterate through the
binding operators in each permutation, and successively apply them to
the current term, starting with the core semantic representation,
working from the inside out.
Binding operators are of the form::
bo(\P.all x.(man(x) -> P(x)),z1)
"""
for perm, store_perm in enumerate(self._permute(self.store)):
if trace:
print("Permutation %s" % (perm + 1))
term = self.core
for bindop in store_perm:
# we just want the arguments that are wrapped by the 'bo' predicate
quant, varex = tuple(bindop.args)
# use var to make an abstraction over the current term and then
# apply the quantifier to it
term = ApplicationExpression(
quant, LambdaExpression(varex.variable, term))
if trace:
print(" ", term)
term = term.simplify()
self.readings.append(term)
def s_retrieve(self, trace=False):
"""
Carry out S-Retrieval of binding operators in store. If hack=True,
serialize the bindop and core as strings and reparse. Ugh.
Each permutation of the store (i.e. list of binding operators) is
taken to be a possible scoping of quantifiers. We iterate through the
binding operators in each permutation, and successively apply them to
the current term, starting with the core semantic representation,
working from the inside out.
Binding operators are of the form::
bo(\P.all x.(man(x) -> P(x)),z1)
"""
for perm, store_perm in enumerate(self._permute(self.store)):
if trace:
print("Permutation %s" % (perm+1))
term = self.core
for bindop in store_perm:
# we just want the arguments that are wrapped by the 'bo' predicate
quant, varex = tuple(bindop.args)
# use var to make an abstraction over the current term and then
# apply the quantifier to it
term = ApplicationExpression(quant, LambdaExpression(varex.variable, term))
if trace:
print(" ", term)
term = term.simplify()
self.readings.append(term)
def demo():
from nltk_contrib.drt import DRT
DRT.testTp_equals()
print '\n'
lp = LogicParser()
a = lp.parse(r'some x.((man x) and (walks x))')
b = lp.parse(r'some x.((walks x) and (man x))')
bicond = ApplicationExpression(ApplicationExpression(Operator('iff'), a), b)
print "Trying to prove:\n '%s <-> %s'" % (a.infixify(), b.infixify())
print 'tableau: %s' % get_prover(bicond, prover_name='tableau').prove()
print 'Prover9: %s' % get_prover(bicond, prover_name='Prover9').prove()
print '\n'
demo_drt_glue_remove_duplicates()
lp = LogicParser()
a = lp.parse(r'all x.((man x) implies (mortal x))')
b = lp.parse(r'(man socrates)')
c1 = lp.parse(r'(mortal socrates)')
c2 = lp.parse(r'(not (mortal socrates))')
print get_prover(c1, [a,b], 'prover9').prove()
print get_prover(c2, [a,b], 'prover9').prove()
print get_model_builder(c1, [a,b], 'mace').build_model()
print get_model_builder(c2, [a,b], 'mace').build_model()
def replace_function_names(expr, resolution_guide, active=None):
if active is None:
active = {}
else:
active = dict(active)
if expr in resolution_guide:
for prev_pred, new_pred in resolution_guide[expr]:
active[prev_pred] = new_pred
if isinstance(expr, ConstantExpression) or \
isinstance(expr, AbstractVariableExpression) or \
isinstance(expr, Variable):
return expr
elif isinstance(expr, NegatedExpression):
expr.term = replace_function_names(expr.term, resolution_guide, active)
return expr
elif isinstance(expr, BinaryExpression):
child_exprs = [expr.first, expr.second]
exprs = [
replace_function_names(e, resolution_guide, active)
for e in child_exprs
]
expr.first = exprs[0]
expr.second = exprs[1]
elif isinstance(expr, ApplicationExpression):
func, args = expr.uncurry()
if str(func) in active:
func = type(func)(Variable(active[str(func)]))
args_exprs = [
replace_function_names(e, resolution_guide, active) for e in args
]
exprs = [func] + args_exprs
expr = functools.reduce(lambda f, a: ApplicationExpression(f, a),
exprs)
elif isinstance(expr, VariableBinderExpression):
child_exprs = [expr.variable, expr.term]
exprs = [
replace_function_names(e, resolution_guide, active)
for e in child_exprs
]
expr.variable = exprs[0]
expr.term = exprs[1]
else:
raise NotImplementedError(
'Expression not recognized: {0}, type: {1}'.format(
expr, type(expr)))
return expr
def fol(self):
return ApplicationExpression(self.function.fol(), self.argument.fol())
