concepts.language.neural_ccg.grammar.NeuralCCGSyntaxType#

class NeuralCCGSyntaxType[source]#

Bases: CCGComposable

Data structure for neural CCG syntax types. NeuralCCGSyntaxType implements a different version of the syntax type than the CCGSyntaxType.

Specifically, the NeuralCCGSyntaxType define syntaxes based on the signature of its meaning. It has two parts:

the signature of the semantic form, including the argument types and the return type.
the linearization of the semantics.

IMPORTANT: Arguments are combined from right to left. Thus, argument_types[-1] is the first argument. There is one possible confusion about linearization:

Although LinearizationTuple has two fields: index and direction, only type will be used during computation. LinearizationTuple.index is used to record the mapping from the original “function” definition, most likely produced by iter_from_function.

Example: Suppose we have a function definition def func(string, int) -> string. Running iter_from_function(func) will get you six possible syntax types:

string/0:string/1:int, string0:string/1:int, string0:string1:int, string/1:int/0:string, string1:int/0:string, string1:int0:string

Consider a specifc type string0:int/1:string. It has the following fields:

return_type: string
argument_types: [int, string]
linearization: [LinearizationTuple(0, CCGCompositionDirection.LEFT), LinearizationTuple(1, CCGCompositionDirection.RIGHT)]

Here, the first argument should come from fapp, of type string. The second argument should come from bapp, of type int. The linearization[i].index is never used in the computation. However, it does record the argument order mapping from the original “func(string, int) -> string”.

See also concepts.language.neural_ccg.search.NeuralCCGLexiconSearcher.gen_lexicons().

Methods

`bapp`(lhs)	Backward application composition.
`compose`(rhs, composition_type)	Compose this element with another element.
`coord`(other)	Coordination composition.
`coord3`(lhs, rhs)	Coordination composition with three elements.
`derive_lang_syntax_type`(lang_syntax_type)	Create a new syntax type that has an associated standard linguistic syntax type.
`fapp`(rhs)	Forward application composition.
`iter_from_function`(function[, nr_used_arguments])	Create all possible linearization of the corresponding function.
`none`(rhs)	None composition (composition with a None element).

Attributes

`arity`	The arity of the syntax type.
`is_conj`	Whether this element is a conjunction.
`is_function`	Whether the syntax type is a function type.
`is_none`	Whether this element is None.
`is_value`	Whether the syntax type is a value type.
`typename`
`return_type`	The return type of the syntax.
`argument_types`	The argument types of the syntax.
`linearization`	The linearization of arguments.
`lang_syntax_type`	Optionally, a `CCGSyntaxType` can be associated with the `NeuralCCGSyntaxType`.

__init__(return_type, argument_types=None, linearization=None, lang_syntax_type=None, function_typename=None)[source]#

Parameters:

return_type (None | str | ObjectType | ValueType)
argument_types (Iterable[ObjectType | ValueType | FunctionType] | None)
linearization (Iterable[LinearizationTuple] | None)
lang_syntax_type (CCGSyntaxType | None)
function_typename (str | None)

__new__(**kwargs)#

bapp(lhs)#

Backward application composition.

Parameters:: lhs (CCGComposable)
Return type:: CCGComposable

compose(rhs, composition_type)#

Compose this element with another element. This function will call the corresponding composition function according to the composition type. Note that since the coordination composition has three arguments, this function will return a CCGCoordinationImmNode for the first two arguments in coordination composition.

Parameters:

rhs (CCGComposable | CCGCoordinationImmNode) – the right-hand side element.
composition_type (CCGCompositionType) – the composition type.

Returns:

The composed element.

Return type:

CCGComposable | CCGCoordinationImmNode

coord(other)#

Coordination composition.

Parameters:: other (CCGComposable | CCGCoordinationImmNode)
Return type:: CCGComposable | CCGCoordinationImmNode

coord3(lhs, rhs)#

Coordination composition with three elements.

Parameters:

lhs (CCGComposable)
rhs (CCGComposable)

Return type:

CCGComposable

derive_lang_syntax_type(lang_syntax_type)[source]#

Create a new syntax type that has an associated standard linguistic syntax type.

Parameters:: lang_syntax_type (CCGSyntaxType) – the syntax type.
Returns:: A new NeuralCCGSyntaxType with the same signature and linearization, but with an associated standard linguistic syntax type.
Return type:: NeuralCCGSyntaxType

fapp(rhs)#

Forward application composition.

Parameters:: rhs (CCGComposable)
Return type:: CCGComposable

classmethod iter_from_function(function, nr_used_arguments=None)[source]#

Create all possible linearization of the corresponding function.

Parameters:

function (Function) – the function.
nr_used_arguments (int | None) – do enumeration only for the first N arguments. Useful when the function has constant arguments that will be bound with word types.

Yields:

all possible NeuralCCGSyntaxType derived from the given function signature.

Return type:

Iterable[Tuple[NeuralCCGSyntaxType, Function]]

none(rhs)#

None composition (composition with a None element).

Parameters:: rhs (CCGComposable)
Return type:: CCGComposable

argument_types: Tuple[ObjectType | ValueType | FunctionType, ...]#: The argument types of the syntax.

property arity: int#: The arity of the syntax type. That is, the number of arguments it needs to combine before it becomes a primitive syntax type.

property is_conj: bool#: Whether this element is a conjunction.

property is_function: bool#: Whether the syntax type is a function type. That is, whether it can do function application with another syntax type.

property is_none: bool#: Whether this element is None.

property is_value: bool#: Whether the syntax type is a value type. That is, whether it is a primitive syntax type.

lang_syntax_type: CCGSyntaxType | None#: Optionally, a CCGSyntaxType can be associated with the NeuralCCGSyntaxType.

linearization: Tuple[LinearizationTuple, ...]#: The linearization of arguments. See the docstring for details.

return_type: None | str | ObjectType | ValueType#: The return type of the syntax.

property typename#