nltk.ccg package

Submodules

nltk.ccg.api module

class nltk.ccg.api.AbstractCCGCategory

Bases: object

Interface for categories in combinatory grammars.

can_unify(other)

Determines whether two categories can be unified.

• Returns None if they cannot be unified
• Returns a list of necessary substitutions if they can.

is_function()

Returns true if the category is a function application.

is_primitive()

Returns true if the category is primitive.

is_var()

Returns true if the category is a variable.

substitute(substitutions)

Takes a set of (var, category) substitutions, and replaces every occurrence of the variable with the corresponding category.

class nltk.ccg.api.CCGVar(prim_only=False)

Bases: nltk.ccg.api.AbstractCCGCategory

Class representing a variable CCG category. Used for conjunctions (and possibly type-raising, if implemented as a unary rule).

can_unify(other)

If the variable can be replaced with other a substitution is returned.

id()

is_function()

Returns true if the category is a function application.

is_primitive()

Returns true if the category is primitive.

is_var()

Returns true if the category is a variable.

classmethod new_id()

A class method allowing generation of unique variable identifiers.

classmethod reset_id()

substitute(substitutions)

If there is a substitution corresponding to this variable, return the substituted category.

unicode_repr

Return repr(self).

class nltk.ccg.api.Direction(dir, restrictions)

Bases: object

Class representing the direction of a function application. Also contains maintains information as to which combinators may be used with the category.

can_compose()

can_cross()

can_unify(other)

dir()

is_backward()

is_forward()

is_variable()

restrs()

A list of restrictions on the combinators. ‘.’ denotes that permuting operations are disallowed ‘,’ denotes that function composition is disallowed ‘_’ denotes that the direction has variable restrictions. (This is redundant in the current implementation of type-raising)

substitute(subs)

unicode_repr

Return repr(self).

class nltk.ccg.api.FunctionalCategory(res, arg, dir)

Bases: nltk.ccg.api.AbstractCCGCategory

Class that represents a function application category. Consists of argument and result categories, together with an application direction.

arg()

can_unify(other)

Determines whether two categories can be unified. - Returns None if they cannot be unified - Returns a list of necessary substitutions if they can.

dir()

is_function()

Returns true if the category is a function application.

is_primitive()

Returns true if the category is primitive.

is_var()

Returns true if the category is a variable.

res()

substitute(subs)

Takes a set of (var, category) substitutions, and replaces every occurrence of the variable with the corresponding category.

unicode_repr

Return repr(self).

class nltk.ccg.api.PrimitiveCategory(categ, restrictions=[])

Bases: nltk.ccg.api.AbstractCCGCategory

Class representing primitive categories. Takes a string representation of the category, and a list of strings specifying the morphological subcategories.

can_unify(other)

Determines whether two categories can be unified. - Returns None if they cannot be unified - Returns a list of necessary substitutions if they can.

categ()

is_function()

Returns true if the category is a function application.

is_primitive()

Returns true if the category is primitive.

is_var()

Returns true if the category is a variable.

restrs()

substitute(subs)

Takes a set of (var, category) substitutions, and replaces every occurrence of the variable with the corresponding category.

unicode_repr

Return repr(self).

nltk.ccg.chart module

The lexicon is constructed by calling lexicon.fromstring(<lexicon string>).

In order to construct a parser, you also need a rule set. The standard English rules are provided in chart as chart.DefaultRuleSet.

The parser can then be constructed by calling, for example: parser = chart.CCGChartParser(<lexicon>, <ruleset>)

Parsing is then performed by running parser.parse(<sentence>.split()).

While this returns a list of trees, the default representation of the produced trees is not very enlightening, particularly given that it uses the same tree class as the CFG parsers. It is probably better to call: chart.printCCGDerivation(<parse tree extracted from list>) which should print a nice representation of the derivation.

This entire process is shown far more clearly in the demonstration: python chart.py

class nltk.ccg.chart.BackwardTypeRaiseRule

Bases: nltk.parse.chart.AbstractChartRule

Class for applying backward type raising.

NUMEDGES = 2

apply(chart, grammar, left_edge, right_edge)

Return a generator that will add edges licensed by this rule and the given edges to the chart, one at a time. Each time the generator is resumed, it will either add a new edge and yield that edge; or return.

Parameters:edges (list(EdgeI)) – A set of existing edges. The number of edges that should be passed to apply() is specified by the NUM_EDGES class variable. Return type:iter(EdgeI)

unicode_repr

Return repr(self).

class nltk.ccg.chart.BinaryCombinatorRule(combinator)

Bases: nltk.parse.chart.AbstractChartRule

Class implementing application of a binary combinator to a chart. Takes the directed combinator to apply.

NUMEDGES = 2

apply(chart, grammar, left_edge, right_edge)

Return a generator that will add edges licensed by this rule and the given edges to the chart, one at a time. Each time the generator is resumed, it will either add a new edge and yield that edge; or return.

Parameters:edges (list(EdgeI)) – A set of existing edges. The number of edges that should be passed to apply() is specified by the NUM_EDGES class variable. Return type:iter(EdgeI)

unicode_repr

Return repr(self).

class nltk.ccg.chart.CCGChart(tokens)

Bases: nltk.parse.chart.Chart

class nltk.ccg.chart.CCGChartParser(lexicon, rules, trace=0)

Bases: nltk.parse.api.ParserI

Chart parser for CCGs. Based largely on the ChartParser class from NLTK.

lexicon()

parse(tokens)

Returns:An iterator that generates parse trees for the sentence.

When possible this list is sorted from most likely to least likely.

Parameters:sent (list(str)) – The sentence to be parsed Return type:iter(Tree)

class nltk.ccg.chart.CCGEdge(span, categ, rule)

Bases: nltk.parse.chart.EdgeI

categ()

dot()

Return this edge’s dot position, which indicates how much of the hypothesized structure is consistent with the sentence. In particular, self.rhs[:dot] is consistent with tokens[self.start():self.end()].

Return type:int

end()

Return the end index of this edge’s span.

Return type:int

is_complete()

Return True if this edge’s structure is fully consistent with the text.

Return type:bool

is_incomplete()

Return True if this edge’s structure is partially consistent with the text.

Return type:bool

length()

Return the length of this edge’s span.

Return type:int

lhs()

Return this edge’s left-hand side, which specifies what kind of structure is hypothesized by this edge.

See:TreeEdge and LeafEdge for a description of the left-hand side values for each edge type.

nextsym()

Return the element of this edge’s right-hand side that immediately follows its dot.

Return type:Nonterminal or terminal or None

rhs()

Return this edge’s right-hand side, which specifies the content of the structure hypothesized by this edge.

See:TreeEdge and LeafEdge for a description of the right-hand side values for each edge type.

rule()

span()

Return a tuple (s, e), where tokens[s:e] is the portion of the sentence that is consistent with this edge’s structure.

Return type:tuple(int, int)

start()

Return the start index of this edge’s span.

Return type:int

class nltk.ccg.chart.CCGLeafEdge(pos, token, leaf)

Bases: nltk.parse.chart.EdgeI

Class representing leaf edges in a CCG derivation.

categ()

dot()

Return this edge’s dot position, which indicates how much of the hypothesized structure is consistent with the sentence. In particular, self.rhs[:dot] is consistent with tokens[self.start():self.end()].

Return type:int

end()

Return the end index of this edge’s span.

Return type:int

is_complete()

Return True if this edge’s structure is fully consistent with the text.

Return type:bool

is_incomplete()

Return True if this edge’s structure is partially consistent with the text.

Return type:bool

leaf()

length()

Return the length of this edge’s span.

Return type:int

lhs()

Return this edge’s left-hand side, which specifies what kind of structure is hypothesized by this edge.

See:TreeEdge and LeafEdge for a description of the left-hand side values for each edge type.

nextsym()

Return the element of this edge’s right-hand side that immediately follows its dot.

Return type:Nonterminal or terminal or None

rhs()

Return this edge’s right-hand side, which specifies the content of the structure hypothesized by this edge.

See:TreeEdge and LeafEdge for a description of the right-hand side values for each edge type.

span()

Return a tuple (s, e), where tokens[s:e] is the portion of the sentence that is consistent with this edge’s structure.

Return type:tuple(int, int)

start()

Return the start index of this edge’s span.

Return type:int

token()

class nltk.ccg.chart.ForwardTypeRaiseRule

Bases: nltk.parse.chart.AbstractChartRule

Class for applying forward type raising

NUMEDGES = 2

apply(chart, grammar, left_edge, right_edge)

Return a generator that will add edges licensed by this rule and the given edges to the chart, one at a time. Each time the generator is resumed, it will either add a new edge and yield that edge; or return.

Parameters:edges (list(EdgeI)) – A set of existing edges. The number of edges that should be passed to apply() is specified by the NUM_EDGES class variable. Return type:iter(EdgeI)

unicode_repr

Return repr(self).

nltk.ccg.chart.compute_semantics(children, edge)

nltk.ccg.chart.demo()

nltk.ccg.chart.printCCGDerivation(tree)

nltk.ccg.chart.printCCGTree(lwidth, tree)

nltk.ccg.combinator module

CCG Combinators

class nltk.ccg.combinator.BackwardCombinator(combinator, predicate, suffix='')

Bases: nltk.ccg.combinator.DirectedBinaryCombinator

The backward equivalent of the ForwardCombinator class.

can_combine(left, right)

combine(left, right)

unicode_repr

Return repr(self).

class nltk.ccg.combinator.DirectedBinaryCombinator

Bases: object

Wrapper for the undirected binary combinator. It takes left and right categories, and decides which is to be the function, and which the argument. It then decides whether or not they can be combined.

can_combine(left, right)

combine(left, right)

class nltk.ccg.combinator.ForwardCombinator(combinator, predicate, suffix='')

Bases: nltk.ccg.combinator.DirectedBinaryCombinator

Class representing combinators where the primary functor is on the left.

Takes an undirected combinator, and a predicate which adds constraints restricting the cases in which it may apply.

can_combine(left, right)

combine(left, right)

unicode_repr

Return repr(self).

class nltk.ccg.combinator.UndirectedBinaryCombinator

Bases: object

Abstract class for representing a binary combinator. Merely defines functions for checking if the function and argument are able to be combined, and what the resulting category is.

Note that as no assumptions are made as to direction, the unrestricted combinators can perform all backward, forward and crossed variations of the combinators; these restrictions must be added in the rule class.

can_combine(function, argument)

combine(function, argument)

class nltk.ccg.combinator.UndirectedComposition

Bases: nltk.ccg.combinator.UndirectedBinaryCombinator

Functional composition (harmonic) combinator. Implements rules of the form X/Y Y/Z -> X/Z (B>) And the corresponding backwards and crossed variations.

can_combine(function, argument)

combine(function, argument)

unicode_repr

Return repr(self).

class nltk.ccg.combinator.UndirectedFunctionApplication

Bases: nltk.ccg.combinator.UndirectedBinaryCombinator

Class representing function application. Implements rules of the form: X/Y Y -> X (>) And the corresponding backwards application rule

can_combine(function, argument)

combine(function, argument)

unicode_repr

Return repr(self).

class nltk.ccg.combinator.UndirectedSubstitution

Bases: nltk.ccg.combinator.UndirectedBinaryCombinator

Substitution (permutation) combinator. Implements rules of the form Y/Z (XY)/Z -> X/Z (<Sx) And other variations.

can_combine(function, argument)

combine(function, argument)

unicode_repr

Return repr(self).

class nltk.ccg.combinator.UndirectedTypeRaise

Bases: nltk.ccg.combinator.UndirectedBinaryCombinator

Undirected combinator for type raising.

can_combine(function, arg)

combine(function, arg)

unicode_repr

Return repr(self).

nltk.ccg.combinator.backwardBxConstraint(left, right)

nltk.ccg.combinator.backwardOnly(left, right)

nltk.ccg.combinator.backwardSxConstraint(left, right)

nltk.ccg.combinator.backwardTConstraint(left, right)

nltk.ccg.combinator.bothBackward(left, right)

nltk.ccg.combinator.bothForward(left, right)

nltk.ccg.combinator.crossedDirs(left, right)

nltk.ccg.combinator.forwardOnly(left, right)

nltk.ccg.combinator.forwardSConstraint(left, right)

nltk.ccg.combinator.forwardTConstraint(left, right)

nltk.ccg.combinator.innermostFunction(categ)

nltk.ccg.lexicon module

CCG Lexicons

class nltk.ccg.lexicon.CCGLexicon(start, primitives, families, entries)

Bases: object

Class representing a lexicon for CCG grammars.

• primitives: The list of primitive categories for the lexicon
• families: Families of categories
• entries: A mapping of words to possible categories

categories(word)

Returns all the possible categories for a word

start()

Return the target category for the parser

unicode_repr

Return repr(self).

class nltk.ccg.lexicon.Token(token, categ, semantics=None)

Bases: object

Class representing a token.

token => category {semantics} e.g. eat => Svar[pl]/var {x y.eat(x,y)}

• token (string)
• categ (string)
• semantics (Expression)

categ()

semantics()

nltk.ccg.lexicon.augParseCategory(line, primitives, families, var=None)

Parse a string representing a category, and returns a tuple with (possibly) the CCG variable for the category

nltk.ccg.lexicon.fromstring(lex_str, include_semantics=False)

Convert string representation into a lexicon for CCGs.

nltk.ccg.lexicon.matchBrackets(string)

Separate the contents matching the first set of brackets from the rest of the input.

nltk.ccg.lexicon.nextCategory(string)

Separate the string for the next portion of the category from the rest of the string

nltk.ccg.lexicon.parseApplication(app)

Parse an application operator

nltk.ccg.lexicon.parsePrimitiveCategory(chunks, primitives, families, var)

Parse a primitive category

If the primitive is the special category ‘var’, replace it with the correct CCGVar.

nltk.ccg.lexicon.parseSubscripts(subscr)

Parse the subscripts for a primitive category

nltk.ccg.logic module

Helper functions for CCG semantics computation

nltk.ccg.logic.compute_composition_semantics(function, argument)

nltk.ccg.logic.compute_function_semantics(function, argument)

nltk.ccg.logic.compute_substitution_semantics(function, argument)

nltk.ccg.logic.compute_type_raised_semantics(semantics)

Module contents

Combinatory Categorial Grammar.

For more information see nltk/doc/contrib/ccg/ccg.pdf