nltk.sem.Expression

class nltk.sem.Expression

Bases: SubstituteBindingsI

This is the base abstract object for all logical expressions

classmethod fromstring(s, type_check=False, signature=None)

applyto(other)

negate()

If this is a negated expression, remove the negation. Otherwise add a negation.

equiv(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.

Parameters

• other – an Expression to check equality against

• prover – a nltk.inference.api.Prover

substitute_bindings(bindings)

Returns

The object that is obtained by replacing each variable bound by bindings with its values. Aliases are already resolved. (maybe?)

Return type

(any)

typecheck(signature=None)

Infer and check types. Raise exceptions if necessary.

Parameters

signature – dict that maps variable names to types (or string representations of types)

Returns

the signature, plus any additional type mappings

findtype(variable)

Find the type of the given variable as it is used in this expression. For example, finding the type of “P” in “P(x) & Q(x,y)” yields “<e,t>”

Parameters

variable – Variable

replace(variable, expression, replace_bound=False, alpha_convert=True)

Replace every instance of ‘variable’ with ‘expression’ :param variable: Variable The variable to replace :param expression: Expression The expression with which to replace it :param replace_bound: bool Should bound variables be replaced? :param alpha_convert: bool Alpha convert automatically to avoid name clashes?

normalize(newvars=None)

Rename auto-generated unique variables

visit(function, combinator)

Recursively visit subexpressions. Apply ‘function’ to each subexpression and pass the result of each function application to the ‘combinator’ for aggregation:

return combinator(map(function, self.subexpressions))

Bound variables are neither applied upon by the function nor given to the combinator. :param function: Function<Expression,T> to call on each subexpression :param combinator: Function<list<T>,R> to combine the results of the function calls :return: result of combination R

visit_structured(function, combinator)

Recursively visit subexpressions. Apply ‘function’ to each subexpression and pass the result of each function application to the ‘combinator’ for aggregation. The combinator must have the same signature as the constructor. The function is not applied to bound variables, but they are passed to the combinator. :param function: Function to call on each subexpression :param combinator: Function with the same signature as the constructor, to combine the results of the function calls :return: result of combination

variables()

Return a set of all the variables for binding substitution. The variables returned include all free (non-bound) individual variables and any variable starting with ‘?’ or ‘@’. :return: set of Variable objects

free()

Return a set of all the free (non-bound) variables. This includes both individual and predicate variables, but not constants. :return: set of Variable objects

constants()

Return a set of individual constants (non-predicates). :return: set of Variable objects

predicates()

Return a set of predicates (constants, not variables). :return: set of Variable objects

simplify()

Returns

beta-converted version of this expression

make_VariableExpression(variable)