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.