A fundamental property of human languages
is that they allow their sentences to exhibit
something called “recursion”. And that’s
related to what we already saw: that sentences
are made up of constituents that themselves
can contain smaller constituents. The crucial
point that makes syntax recursive is that
constituents can be of different types and
that a constituent can contain another constituent
of the same type. And it’s actually that
that gives language the amazing property that
you can make an infinite number of sentences
from a finite number of words and a finite
number of ways of combining them. And that’s
something that we’ll see in more detail
later. But just to illustrate, supposing you
take a sentence like “John regrets that
fact.” Now in this case you’ve got the
verb ‘regret’, and it’s followed by
a noun phrase (‘that fact’). But ‘regret’
is a verb that allows the possibility of not
having a noun phrase following it, but having
a whole sentence following it. So, you could
also say “John regrets that Mary was not
invited.”. So now we’ve got the same word
‘regrets’. It’s followed by the sentence
“Mary was not invited”, introduced itself
by this word ‘that’, a function word that
we’ll also talk about later. But this means
that we have a sentence (“John regrets that
Mary was not invited.”), which contains
a smaller sentence (“Mary was not invited.”).
This is an instance of recursion. You’ve
got a constituent containing a constituent
of the same type. And what happens of course
when you have that is that process can happen
again. In this case, the sentence contained
inside the larger one was “Mary was not
invited”, but it might contain a verb like
‘think’. ‘Think’ can also be followed
by a sentence, so you can say “Mary thinks
that John was wrong.”, so “John was wrong”
is a sentence, and as with ‘regret’, ‘think’
can be followed by that sentence, so “Mary
think that John was wrong.”. But now we
could take that structure and embed it after
‘regret’. So then we’ll wind up with
something like “John regrets something”…
what does he regret? “John regrets that
Mary thinks that John was wrong.”. So now
we’ve got an even larger sentence: an overarching
sentence which contains another sentence which
contains another sentence. And as you can
see, it wouldn’t take much to repeat that
whole process again. So that’s the property
of recursion.
Of course, in practice, sentences always finish.
And indeed, there’s a limit to how long
sentences can go on. People have finite memory.
People have finite breath. You have to stop
at some point. But the system itself doesn’t
impose a limit. So the constraints on how
much recursion you can do, how many times
you can embed a sentence, those seem to be
constraints which come from outside the language.
They’re not part of the linguistic system
itself. So syntax allows you to build sentences
that are infinitely long. There are lots of
constraints which prevent you from actually
doing it, but not the nature of the system
itself.
We’ve just seen recursion involving sentences
inside other sentences, but we find recursion
of other phrases which might be smaller than
sentences. For example, we can take a noun
phrase like “the dog in the car”. That
noun phrase is built around “the dog”,
but it includes also a prepositional phrase
that modifies dog (“in the car”). “In
the car” is a prepositional phrase: it consists
of a preposition (“in”), followed by a
noun phrase (“the car”). So when we put
those together we find that “the dog in
the car” is a noun phrase which, within
it, contains another noun phrase. So, “the
dog in the car” contains the prepositional
phrase “in the car” which itself contains
the noun phrase “the car”. This process,
as before, can happen more than once. So,
that same noun phrase might an additional
noun phrase in it, because we might add another
prepositional phrase. So, we might have the
noun phrase “the dog in the car in the street”.
So now we have a noun phrase containing another
noun phrase containing another noun phrase.
So this is just one other example of how we
have recursive structure in the syntax of
languages. I’ve illustrated it for English,
but you’ll find this in other languages
as well.
