conditions were interpreted as though they are conjoined. In fact, every DRS can be
translated into a formula of first-order logic, and the 
fol()
method implements this
translation.
>>> print drs1.fol()
exists x y.((angus(x) & dog(y)) & own(x,y))
In addition to the functionality available for first-order logic expressions, DRT
Expression
s have a DRS-concatenation operator, represented as the 
+
symbol. The
concatenation of two DRSs is a single DRS containing the merged discourse referents
and the conditions from both arguments. DRS-concatenation automatically α-converts
bound variables to avoid name-clashes.
>>> drs2 = dp.parse('([x], [walk(x)]) + ([y], [run(y)])')
>>> print drs2
(([x],[walk(x)]) + ([y],[run(y)]))
>>> print drs2.simplify()
([x,y],[walk(x), run(y)])
While all the conditions seen so far have been atomic, it is possible to embed one DRS
within another, and this is how universal quantification is handled. In 
drs3
, there are
no top-level discourse referents, and the sole condition is made up of two sub-DRSs,
connected by an implication. Again, we can use 
fol()
to get a handle on the truth
conditions.
>>> print drs3.fol()
all x.(dog(x) -> exists y.(ankle(y) & bite(x,y)))
We pointed out earlier that DRT is designed to allow anaphoric pronouns to be inter-
preted by linking to existing discourse referents. DRT sets constraints on which dis-
course referents are “accessible” as possible antecedents, but is not intended to explain
how a particular antecedent is chosen from the set of candidates. The module
nltk.sem.drt_resolve_anaphora
adopts a similarly conservative strategy: if the DRS
contains a condition of the form 
PRO(x)
, the method 
resolve_anaphora()
replaces this
with a condition of the form 
x = [...]
, where 
[...]
is a list of possible antecedents.
>>> drs6 = drs4 + drs5
>>> print drs6.simplify()
>>> print drs6.simplify().resolve_anaphora()
Since the algorithm for anaphora resolution has been separated into its own module,
this facilitates swapping in alternative procedures that try to make more intelligent
guesses about the correct antecedent.
Our treatment of DRSs is fully compatible with the existing machinery for handling λ-
abstraction, and consequently it is straightforward to build compositional semantic
representations that are based on DRT rather than first-order logic. This technique is
10.5  Discourse Semantics s | | 399
Acrobat reader merge pdf files - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
c# pdf merge; build pdf from multiple files
Acrobat reader merge pdf files - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
acrobat combine pdf files; batch combine pdf
illustrated in the following rule for indefinites (which is part of the grammar drt.fcfg).
For ease of comparison, we have added the parallel rule for indefinites from simple-
sem.fcfg.
Det[NUM=sg,SEM=<\P Q.([x],[]) + P(x) + Q(x)>] -> 'a'
Det[NUM=sg,SEM=<\P Q. exists x.(P(x) & Q(x))>] -> 'a'
To get a better idea of how the DRT rule works, look at this subtree for the 
NP
a dog:
(NP[NUM='sg', SEM=<\Q.(([x],[dog(x)]) + Q(x))>]
(Nom[NUM='sg', SEM=<\x.([],[dog(x)])>]
(N[NUM='sg', SEM=<\x.([],[dog(x)])>] dog)))))
The λ-abstract for the indefinite is applied as a function expression to 
\x.([],
[dog(x)])
which leads to 
\Q.(([x],[]) + ([],[dog(x)]) + Q(x))
; after simplification,
we get 
\Q.(([x],[dog(x)]) + Q(x))
as the representation for the 
NP
as a whole.
In order to parse with grammar drt.fcfg, we specify in the call to 
load_earley()
that
SEM
values in feature structures are to be parsed using 
DrtParser
in place of the default
LogicParser
.
>>> from nltk import load_parser
>>> trees = parser.nbest_parse('Angus owns a dog'.split())
>>> print trees[0].node['sem'].simplify()
([x,z2],[Angus(x), dog(z2), own(x,z2)])
Discourse Processing
When we interpret a sentence, we use a rich context for interpretation, determined in
part by the preceding context and in part by our background assumptions. DRT pro-
vides a theory of how the meaning of a sentence is integrated into a representation of
the prior discourse, but two things have been glaringly absent from the processing
approach just discussed. First, there has been no attempt to incorporate any kind of
inference; and second, we have only processed individual sentences. These omissions
are redressed by the module 
nltk.inference.discourse
.
Whereas a discourse is a sequence s
1
, ... s
n
of sentences, a discourse thread is a sequence
s
1
-r
i
, ... s
n
-r
j
of readings, one for each sentence in the discourse. The module processes
sentences incrementally, keeping track of all possible threads when there is ambiguity.
For simplicity, the following example ignores scope ambiguity:
>>> dt.readings()
s0 readings: s0-r0: exists x.(student(x) & dance(x))
s1 readings: s1-r0: all x.(student(x) -> person(x))
When a new sentence is added to the current discourse, setting the parameter
consistchk=True
causes consistency to be checked by invoking the model checker for
each thread, i.e., each sequence of admissible readings. In this case, the user has the
option of retracting the sentence in question.
400 | | Chapter 10: Analyzing the Meaning of Sentences
.NET PDF Document Viewing, Annotation, Conversion & Processing
Merge, split PDF files. Insert, delete PDF pages. Edit, update, delete PDF annotations from PDF file. Print. Support for all the print modes in Acrobat PDF.
c# merge pdf pages; pdf mail merge plug in
C# Windows Viewer - Image and Document Conversion & Rendering in
without using other external third-party dependencies like Adobe Acrobat. By using the Windows Viewer, you can convert word files as follows: Convert to PDF.
add pdf files together online; add pdf files together reader
>>> dt.add_sentence('No person dances', consistchk=True)
Inconsistent discourse d0 ['s0-r0', 's1-r0', 's2-r0']:
s0-r0: exists x.(student(x) & dance(x))
s1-r0: all x.(student(x) -> person(x))
s2-r0: -exists x.(person(x) & dance(x))
>>> dt.retract_sentence('No person dances', verbose=True)
Current sentences are
s0: A student dances
s1: Every student is a person
In a similar manner, we use 
informchk=True
to check whether a new sentence φ is
informative relative to the current discourse. The theorem prover treats existing sen-
tences in the thread as assumptions and attempts to prove φ; it is informative if no such
proof can be found.
>>> dt.add_sentence('A person dances', informchk=True)
Not informative relative to thread 'd0'
It is also possible to pass in an additional set of assumptions as background knowledge
and use these to filter out inconsistent readings; see the Discourse HOWTO at http://
www.nltk.org/howto for more details.
The 
discourse
module can accommodate semantic ambiguity and filter out readings
that are not admissible. The following example invokes both Glue Semantics as well
as DRT. Since the Glue Semantics module is configured to use the wide-coverage Malt
dependency parser, the input (Every dog chases a boy. He runs.) needs to be tagged as
well as tokenized.
>>> from nltk.tag import RegexpTagger
>>> tagger = RegexpTagger(
...     [('^(chases|runs)$', 'VB'),
...      ('^(a)$', 'ex_quant'),
...      ('^(every)$', 'univ_quant'),
...      ('^(dog|boy)$', 'NN'),
...      ('^(He)$', 'PRP')
... ])
>>> dt.readings()
s0 readings:
s1 readings:
s1-r0: ([x],[PRO(x), runs(x)])
The first sentence of the discourse has two possible readings, depending on the quan-
tifier scoping. The unique reading of the second sentence represents the pronoun He
via the condition 
PRO(x)
. Now let’s look at the discourse threads that result:
>>> dt.readings(show_thread_readings=True)
10.5  Discourse Semantics s | | 401
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. PowerPoint to PDF Conversion.
pdf merge; break pdf file into multiple files
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
Features and Benefits. Powerful image converter to convert images of JPG, JPEG formats to PDF files; No need for Adobe Acrobat Reader; Seamlessly integrated into
pdf combine; adding pdf pages together
([],[chases(x,z6)])), (z10 = z6), runs(z10)])
When we examine threads 
d0
and 
d1
, we see that reading 
s0-r0
, where every dog out-
scopes 
a boy
, is deemed inadmissible because the pronoun in the second sentence
cannot be resolved. By contrast, in thread 
d1
the pronoun (relettered to 
z10
) has been
bound via the equation 
(z10 = z6)
.
Inadmissible readings can be filtered out by passing the parameter 
filter=True
.
>>> dt.readings(show_thread_readings=True, filter=True)
([],[chases(x,z12)])), (z17 = z15), runs(z15)])
Although this little discourse is extremely limited, it should give you a feel for the kind
of semantic processing issues that arise when we go beyond single sentences, and also
a feel for the techniques that can be deployed to address them.
10.6  Summary
• First-order logic is a suitable language for representing natural language meaning
in a computational setting since it is flexible enough to represent many useful as-
pects of natural meaning, and there are efficient theorem provers for reasoning with
first-order logic. (Equally, there are a variety of phenomena in natural language
semantics which are believed to require more powerful logical mechanisms.)
• As well as translating natural language sentences into first-order logic, we can state
the truth conditions of these sentences by examining models of first-order formu-
las.
• In order to build meaning representations compositionally, we supplement first-
order logic with the λ-calculus.
• β-reduction in the λ-calculus corresponds semantically to application of a function
to an argument. Syntactically, it involves replacing a variable bound by λ in the
function expression with the expression that provides the argument in the function
application.
• A key part of constructing a model lies in building a valuation which assigns in-
terpretations to non-logical constants. These are interpreted as either n-ary predi-
cates or as individual constants.
• An open expression is an expression containing one or more free variables. Open
expressions receive an interpretation only when their free variables receive values
from a variable assignment.
• Quantifiers are interpreted by constructing, for a formula φ[x] open in variable x,
the set of individuals which make φ[x] true when an assignment g assigns them as
the value of x. The quantifier then places constraints on that set.
402 | | Chapter 10: Analyzing the Meaning of Sentences
C# PDF Converter Library SDK to convert PDF to other file formats
manipulate & convert standard PDF documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat.
acrobat reader merge pdf files; append pdf
C# Excel - Excel Conversion & Rendering in C#.NET
Excel documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Excel to PDF Conversion.
pdf mail merge; acrobat combine pdf
• A closed expression is one that has no free variables; that is, the variables are all
bound. A closed sentence is true or false with respect to all variable assignments.
• If two formulas differ only in the label of the variable bound by binding operator
(i.e., λ or a quantifier) , they are said to be α-equivalents. The result of relabeling
a bound variable in a formula is called α-conversion.
• Given a formula with two nested quantifiers Q
1
and Q
2
, the outermost quantifier
Q
1
is said to have wide scope (or scope over Q
2
). English sentences are frequently
ambiguous with respect to the scope of the quantifiers they contain.
• English sentences can be associated with a semantic representation by treating
SEM
as a feature in a feature-based grammar. The 
SEM
value of a complex expressions,
typically involves functional application of the 
SEM
values of the component
expressions.
10.7  Further Reading
Consult http://www.nltk.org/ for further materials on this chapter and on how to install
the Prover9 theorem prover and Mace4 model builder. General information about these
two inference tools is given by (McCune, 2008).
For more examples of semantic analysis with NLTK, please see the semantics and logic
HOWTOs at http://www.nltk.org/howto. Note that there are implementations of two
other approaches to scope ambiguity, namely Hole semantics as described in (Black-
burn & Bos, 2005), and Glue semantics, as described in (Dalrymple et al., 1999).
There are many phenomena in natural language semantics that have not been touched
on in this chapter, most notably:
1.Events, tense, and aspect
2.Semantic roles
3.Generalized quantifiers, such as most
4.Intensional constructions involving, for example, verbs such as may and believe
While (1) and (2) can be dealt with using first-order logic, (3) and (4) require different
logics. These issues are covered by many of the references in the following readings.
A comprehensive overview of results and techniques in building natural language front-
ends to databases can be found in (Androutsopoulos, Ritchie & Thanisch, 1995).
Any introductory book to modern logic will present propositional and first-order logic.
(Hodges, 1977) is highly recommended as an entertaining and insightful text with many
illustrations from natural language.
For a wide-ranging, two-volume textbook on logic that also presents contemporary
material on the formal semantics of natural language, including Montague Grammar
and intensional logic, see (Gamut, 1991a, 1991b). (Kamp & Reyle, 1993) provides the
10.7  Further Reading g | 403
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
PDF files to GIF images with high quality. It can be functioned as an integrated component without the use of external applications & Adobe Acrobat Reader.
all jpg to one pdf converter; best pdf merger
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
interface; Powerful image converter for Bitmap and PDF files; No need for Adobe Acrobat Reader & print driver during conversion; Support
how to combine pdf files; c# pdf merge
definitive account of Discourse Representation Theory, and covers a large and inter-
esting fragment of natural language, including tense, aspect, and modality. Another
comprehensive study of the semantics of many natural language constructions is (Car-
penter, 1997).
There are numerous works that introduce logical semantics within the framework of
linguistic theory. (Chierchia & McConnell-Ginet, 1990) is relatively agnostic about
syntax, while (Heim & Kratzer, 1998) and (Larson & Segal, 1995) are both more ex-
plicitly oriented toward integrating truth-conditional semantics into a Chomskyan
framework.
(Blackburn & Bos, 2005) is the first textbook devoted to computational semantics, and
provides an excellent introduction to the area. It expands on many of the topics covered
in this chapter, including underspecification of quantifier scope ambiguity, first-order
inference, and discourse processing.
To gain an overview of more advanced contemporary approaches to semantics, in-
cluding treatments of tense and generalized quantifiers, try consulting (Lappin, 1996)
or (van Benthem & ter Meulen, 1997).
10.8  Exercises
1.○ Translate the following sentences into propositional logic and verify that they
parse with 
LogicParser
. Provide a key that shows how the propositional variables
in your translation correspond to expressions of English.
a.If Angus sings, it is not the case that Bertie sulks.
b.Cyril runs and barks.
c.It will snow if it doesn’t rain.
d.It’s not the case that Irene will be happy if Olive or Tofu comes.
e.Pat didn’t cough or sneeze.
f.If you don’t come if I call, I won’t come if you call.
2.○ Translate the following sentences into predicate-argument formulas of first-order
logic.
a.Angus likes Cyril and Irene hates Cyril.
b.Tofu is taller than Bertie.
c.Bruce loves himself and Pat does too.
d.Cyril saw Bertie, but Angus didn’t.
e.Cyril is a four-legged friend.
f.Tofu and Olive are near each other.
3.○ Translate the following sentences into quantified formulas of first-order logic.
a.Angus likes someone and someone likes Julia.
404 | | Chapter 10: Analyzing the Meaning of Sentences
C# Word - Word Conversion in C#.NET
Word documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Word to PDF Conversion.
acrobat reader merge pdf files; pdf mail merge plug in
VB.NET PDF: How to Create Watermark on PDF Document within
Watermark Creator, users need no external application plugin, like Adobe Acrobat. profession imaging controls, PDF document, image to pdf files and components
best pdf merger; build pdf from multiple files
b.Angus loves a dog who loves him.
c.Nobody smiles at Pat.
d.Somebody coughs and sneezes.
e.Nobody coughed or sneezed.
f.Bruce loves somebody other than Bruce.
g.Nobody other than Matthew loves Pat.
h.Cyril likes everyone except for Irene.
i.Exactly one person is asleep.
4.○ Translate the following verb phrases using λ-abstracts and quantified formulas
of first-order logic.
a.feed Cyril and give a capuccino to Angus
b.be given ‘War and Peace’ by Pat
c.be loved by everyone
d.be loved or detested by everyone
e.be loved by everyone and detested by no-one
5.○ Consider the following statements:
>>> lp = nltk.LogicParser()
>>> e2 = lp.parse('pat')
>>> e3 = nltk.ApplicationExpression(e1, e2)
>>> print e3.simplify()
exists y.love(pat, y)
Clearly something is missing here, namely a declaration of the value of 
e1
. In order
for 
ApplicationExpression(e1, e2)
to be β-convertible to 
exists y.love(pat, y)
,
e1
must be a λ-abstract which can take 
pat
as an argument. Your task is to construct
such an abstract, bind it to 
e1
, and satisfy yourself that these statements are all
satisfied (up to alphabetic variance). In addition, provide an informal English
translation of 
e3.simplify()
.
Now carry on doing this same task for the further cases of 
e3.simplify()
shown
here:
>>> print e3.simplify()
exists y.(love(pat,y) | love(y,pat))
>>> print e3.simplify()
exists y.(love(pat,y) | love(y,pat))
>>> print e3.simplify()
walk(fido)
6.○ As in the preceding exercise, find a λ-abstract 
e1
that yields results equivalent to
those shown here:
>>> e2 = lp.parse('chase')
>>> e3 = nltk.ApplicationExpression(e1, e2)
10.8  Exercises s | | 405
>>> print e3.simplify()
\x.all y.(dog(y) -> chase(x,pat))
>>> e2 = lp.parse('chase')
>>> e3 = nltk.ApplicationExpression(e1, e2)
>>> print e3.simplify()
\x.exists y.(dog(y) & chase(pat,x))
>>> e2 = lp.parse('give')
>>> e3 = nltk.ApplicationExpression(e1, e2)
>>> print e3.simplify()
\x0 x1.exists y.(present(y) & give(x1,y,x0))
7.○ As in the preceding exercise, find a λ-abstract 
e1
that yields results equivalent to
those shown here:
>>> e2 = lp.parse('bark')
>>> e3 = nltk.ApplicationExpression(e1, e2)
>>> print e3.simplify()
exists y.(dog(x) & bark(x))
>>> e2 = lp.parse('bark')
>>> e3 = nltk.ApplicationExpression(e1, e2)
>>> print e3.simplify()
bark(fido)
>>> e2 = lp.parse('\\P. all x. (dog(x) -> P(x))')
>>> e3 = nltk.ApplicationExpression(e1, e2)
>>> print e3.simplify()
all x.(dog(x) -> bark(x))
8.◑ Develop a method for translating English sentences into formulas with binary
generalized quantifiers. In such an approach, given a generalized quantifier 
Q
, a
quantified formula is of the form 
Q(A, B)
, where both 
A
and 
B
are expressions of
type 〈e, t〉. Then, for example, 
all(A, B)
is true iff 
A
denotes a subset of what 
B
denotes.
9.◑ Extend the approach in the preceding exercise so that the truth conditions for
quantifiers such as most and exactly three can be computed in a model.
10.◑ Modify the 
sem.evaluate
code so that it will give a helpful error message if an
expression is not in the domain of a model’s valuation function.
11.● Select three or four contiguous sentences from a book for children. A possible
source of examples are the collections of stories in 
nltk.corpus.gutenberg
bryant-
stories.txt
burgess-busterbrown.txt
, and 
edgeworth-parents.txt
. Develop a
grammar that will allow your sentences to be translated into first-order logic, and
build a model that will allow those translations to be checked for truth or falsity.
12.● Carry out the preceding exercise, but use DRT as the meaning representation.
13.● Taking (Warren & Pereira, 1982) as a starting point, develop a technique for
converting a natural language query into a form that can be evaluated more effi-
ciently in a model. For example, given a query of the form 
(P(x) & Q(x))
, convert
it to 
(Q(x) & P(x))
if the extension of 
Q
is smaller than the extension of 
P
.
406 | | Chapter 10: Analyzing the Meaning of Sentences
CHAPTER 11
Managing Linguistic Data
Structured collections of annotated linguistic data are essential in most areas of NLP;
however, we still face many obstacles in using them. The goal of this chapter is to answer
the following questions:
1.How do we design a new language resource and ensure that its coverage, balance,
and documentation support a wide range of uses?
2.When existing data is in the wrong format for some analysis tool, how can we
convert it to a suitable format?
3.What is a good way to document the existence of a resource we have created so
that others can easily find it?
Along the way, we will study the design of existing corpora, the typical workflow for
creating a corpus, and the life cycle of a corpus. As in other chapters, there will be many
examples drawn from practical experience managing linguistic data, including data
that has been collected in the course of linguistic fieldwork, laboratory work, and web
crawling.
11.1  Corpus Structure: A Case Study
The TIMIT Corpus was the first annotated speech database to be widely distributed,
and it has an especially clear organization. TIMIT was developed by a consortium in-
cluding Texas Instruments and MIT, from which it derives its name. It was designed
to provide data for the acquisition of acoustic-phonetic knowledge and to support the
development and evaluation of automatic speech recognition systems.
The Structure of TIMIT
Like the Brown Corpus, which displays a balanced selection of text genres and sources,
TIMIT includes a balanced selection of dialects, speakers, and materials. For each of
eight dialect regions, 50 male and female speakers having a range of ages and educa-
tional backgrounds each read 10 carefully chosen sentences. Two sentences, read by
all speakers, were designed to bring out dialect variation:
407
(1) a.she had your dark suit in greasy wash water all year
b.don’t ask me to carry an oily rag like that
The remaining sentences were chosen to be phonetically rich, involving all phones
(sounds) and a comprehensive range of diphones (phone bigrams). Additionally, the
design strikes a balance between multiple speakers saying the same sentence in order
to permit comparison across speakers, and having a large range of sentences covered
by the corpus to get maximal coverage of diphones. Five of the sentences read by each
speaker are also read by six other speakers (for comparability). The remaining three
sentences read by each speaker were unique to that speaker (for coverage).
NLTK includes a sample from the TIMIT Corpus. You can access its documentation
in the usual way, using 
help(nltk.corpus.timit)
. Print 
nltk.corpus.timit.fileids()
to see a list of the 160 recorded utterances in the corpus sample. Each filename has
internal structure, as shown in Figure 11-1.
Figure 11-1. Structure of a TIMIT identifier: Each recording is labeled using a string made up of the
speaker’s dialect region, gender, speaker identifier, sentence type, and sentence identifier.
Each item has a phonetic transcription which can be accessed using the 
phones()
meth-
od. We can access the corresponding word tokens in the customary way. Both access
methods permit an optional argument 
offset=True
, which includes the start and end
offsets of the corresponding span in the audio file.
>>> phonetic = nltk.corpus.timit.phones('dr1-fvmh0/sa1')
>>> phonetic
408 | | Chapter 11: Managing Linguistic Data
Documents you may be interested
Documents you may be interested