What's the difference between recursion and embedding?

Question

1. Chains of relative clauses and strings of attributive adjectives are both examples of recursion--Correct?

2. Chains of relative clauses have each non-initial relative clause embedded within the previous one:

   [the cat [that killed the bird [that ate the rat [that ate the cheese]]]]

3. As far as I know, in a string of attributive adjectives, all the adjectives modify the same noun(s); there's no embedding:

   solitary, poor, nasty, brutish, and short lives

4. I'm hoping that the experts on the list can give me a clearer idea of the difference between recursion and embedding. For example, is all embedding an example of recursion?

Answer 1

Recursion in phrase structure grammar is where an expression of some type contains an expression of that same type. Under this definition, chains of relative clauses count as an instance of recursion. We can see this more clearly by drawing a (simplified) Phrase Structure Tree of your example (note i'm abstracting away from irrelevant details, e.g. the syntax of relative clauses. The 't' in the subject position of each relative clause stands in for an empty category - every theory of relativisation has to assume something like this):

(1) [S [NP [NP the cat] [CP [C that] [S [NP t] [VP [Vt killed] [NP [NP the bird] [CP [C that] [S [NP t] [VP [Vt ate] [NP [NP the rat] [CP [C that] [S [N{ t] [VP [Vt ate] [NP the cheese]]]]]]]]]]]]] [VP [Vi left]] ]

The tree can be characterised by the following set of rewrite rules:

S -> NP VP
VP -> Vi
VP -> Vt NP
NP -> NP CP
CP -> C S
Vt -> killed/ate
Vi -> left
NP -> the cat/the bird/the rat/the cheese/t
C -> that

It's easy to see that as a consequence of these rewrite rules, we can build PS-trees with an in principle infinite number of recursively embedded CPs, since S is one of the outputs of CP, NP is one of the outputs of S, and CP is one of the outputs of NP, so by transitivity, CP can contain CP.

Now let's consider your example involving a string of attributive adjectives. Under standard assumptions, adjectives are adjoined to the Noun Phrase - this captures the fact that an NP modified by any number of adjectives still behaves as an NP externally. Consider the following simple example + PS-tree:

(2) [S [NP [AP [A tall]] [NP [AP [A blonde]] [NP [AP [A beautiful]] [NP [N women]]]]] [PredP [Pred are] [AP [A intimidating]]]]

We can characterise the tree via the following set of rewrite rules:

S -> NP PredP
NP -> AP NP
NP -> N
AP -> A
PredP -> Pred AP
N -> women
A -> tall/blonde/beautiful/intimidating
Pred -> are

It's easy to see just from inspecting the tree that we aren't dealing here with recursively embedded APs, since in no instance does an AP contain an expression of the type AP. Rather, what we have here is an instance of recursively embedded NPs, since an expression of type NP can contain an expression of type NP. There is a rewrite rule which has NP as its input and NP as its output.

I hope this clarifies the distinction between recursion and embedding. Recursion crucially involves embedding an expression of some type within an expression of the same type. If the types are distinct, we aren't dealing with recursion (in the narrow, linguistic sense).

Answer 2

Things are rendered a bit murky by the fact that the notion of 'category' began to get a bit fuzzy with the introduction of features into trees with Aspects of the Theory of Syntax (1965) and especially Remarks on Nominalization (1971), where NP, VP etc were treated as [+N, +'double bar'], [+V, +'double bar'], etc, and people were also treating case, etc as features on NPs. So how many features do we pay attention to? The minimalist doctrine says 'ignore all of them', but there could also be a 'maximalist doctrine' that says 'pay attention to all of them', in which case many instances of recursion would go away due to feature differences between the levels of the embedding. So for example 'John's picture of Mary' would not be recursive if you supposed that 'of' assigned a kind of abstract genitive case to Mary that was not present on John.

In practice, most linguists (eg Carnie in his textbook) seem to have assumed that standard PS category features count for recursion and others don't, but there is no satisfactory delineation of what the category features are, so the Minimalist view is probably the most coherent one out there.

Answer 3

(my slightly incoherent ramblings on recursion, Merge, and embedding)

Recursion as self-embedding

In some generative theories of syntax, recursion is usually understood as self-embedding, in the sense of putting an object inside another of the same type (Fitch 2010, Kinsella 2010, Tallerman 2012). However, Tallerman 2012 argues that HFC 2002 used recursion in the sense of phrase-building or the formation of hierarchical structure generally (p. 451).

Recursion is not Merge

cf. Berwick 1998's observation that recursive generative capacity is an inherent property of Merge (p. 332). They are both concatenative (or combinatorial) operations; however, Merge involves hierarchy.

Merge vs. iteration

Chomsky says that Merge is putting alpha and beta together. If you want to add gamma to it, then you add gamma to a object [alpha+beta]. The issue here is that for [alpha+beta] to be different from a mere sum of alpha and beta, some new property must arise, otherwise we’ll end up with iteration. What is this new property?

Nevins et al. argue that Merge is recursive because it can combine “lexical items and phrases” of any type (p. 367, n.11), cf. Zwart 2011 “[t]he operation Merge is standardly taken to be recursive in that the output of Merge may be subject to further operations Merge” (p. 116).

When alpha and beta are Merged, either alpha or beta projects its property (N, D, V, v, T, C etc.) onto this whole new phrase. This is what Horsntein 2010 calls Label (and Chomskyan Merge is Concatenate under his proposal; also notice that some generativists don’t do labels, like Chris Collins). However, this information about the head isn’t necessarily preserved through several instances of Merge, e.g. V selects a DP and we end up with a VP. What makes Merge truly recursive is that “the output of one derivation functions as a single item in the next derivation” (Zwart 2011, p. 116). I think this is very important, otherwise Merging gamma with [alpha+beta] will lead to simple iteration. [alpha+beta] must be treated as a single unit when it is Merged with gamma.