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()

is_primitive()

is_var()

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)

dir()

is_function()

is_primitive()

is_var()

res()

substitute(subs)

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)

categ()

is_function()

is_primitive()

is_var()

restrs()

substitute(subs)

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)

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)

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)

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

Bases: nltk.parse.chart.EdgeI

categ()

dot()

end()

is_complete()

is_incomplete()

length()

lhs()

nextsym()

rhs()

rule()

span()

start()

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

Bases: nltk.parse.chart.EdgeI

Class representing leaf edges in a CCG derivation.

categ()

dot()

end()

is_complete()

is_incomplete()

leaf()

length()

lhs()

nextsym()

rhs()

span()

start()

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)

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