nltk.sem.Expression¶
- class nltk.sem.Expression[source]¶
Bases:
SubstituteBindingsI
This is the base abstract object for all logical expressions
- equiv(other, prover=None)[source]¶
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 againstprover – a
nltk.inference.api.Prover
- substitute_bindings(bindings)[source]¶
- 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)[source]¶
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)[source]¶
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)[source]¶
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?
- visit(function, combinator)[source]¶
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 combinationR
- visit_structured(function, combinator)[source]¶
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()[source]¶
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()[source]¶
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()[source]¶
Return a set of individual constants (non-predicates). :return: set of
Variable
objects