Kluge: The Haphazard Construction of the Human Mind (Houghton Mifflin; 2008)

But, as we have seen time and again, what is natural for computers isn't always natural for the human brain: building a tree would require a precision in memory that humans just don't appear to have. Building a tree structure with postal-code memory is trivial, something that the world's computer programmers do many times a day. But building a tree structure out of contextual memory is a totally different story, a kluge that kind of works and kind of doesn't.

Working with simple sentences, we're usually fine, but our capacity to understand sentences can easily be compromised. Take, for example, this short sentence I mentioned in the opening chapter:

People people left left.

Here's a slightly easier variant:

Farmers monkeys fear slept.

Four words each, but enough to boggle most people's mind. Yet both sentences are perfectly grammatical. The first means that some set of people who were abandoned by a second group of people themselves departed; the second one means, roughly, "There is a set of farmers that the monkeys fear, and that set of farmers slept; the farmers that the monkeys were afraid of slept." These kinds of sentences

— known in the trade as "center embeddings" (because they bury one clause directly in the middle of another) — are difficult, I submit, precisely because evolution never stumbled on proper tree structure.*

* Recursion can actually be divided into two forms, one that requires a stack and one that doesn't. The one that doesn't is easy. For example, we have no trouble with sentences like This is the cat that bit the rat that chased the mouse, which are complex but (for technical reasons) can be parsed without a stack.

Here's the thing: in order to interpret sentences like these and fully represent recursion (another classic is The rat the cat the mouse chased bit died), we would need to keep track of each noun and each verb, and at the same time hold in mind the connections between them and the clauses they form. Which is just what grammatical trees are supposed to do.

The trouble is, to do that would require an exact memory for the structures and words that have just been said (or read). And that's something our postal-code-free memories just aren't set up to do. If I were to read this book aloud and suddenly, without notice, stop and ask you to repeat the last sentence you heard — you probably couldn't. You'd likely remember the gist of what I had said, but the exact wording would almost surely elude you.*

As a result, efforts to keep track of the structure of sentences becomes a bit like efforts to reconstruct the chronology of a long-ago sequence of events: clumsy, unreliable, but better than nothing. Consider, for example, a sentence like It was the banker that praised the barber that alienated his wife that climbed the mountain. Now, quick: was the mountain climbed by the banker, the barber, or his wife? A computer-based parser would have no trouble answering this question; each noun and each verb would be slotted into its proper place in a tree. But many human listeners end up confused. Lacking any hint of memory organized by location, the best we can do is approximate trees, clumsily kluging them together out of contextual memory. If we receive enough distinctive clues, it's not a problem, but when the individual components of sentences are similar enough to confuse, the whole edifice comes tumbling down.f

Perhaps the biggest problem with grammar is not the trouble we have in constructing trees, but the trouble we have in producing sentences

*Perhaps the most extreme version of remembering only the gist was Woody Allen's five-word summary of War and Peace: "It was about some Russians."

·jThe problem with trees is much the same as the problem with keeping tracking of our goals. You may recall, from the chapter on memory, the example of what some

that are certain to be parsed as we intend them to be. Since our sentences are clear to us, we assume they are clear to our listeners. But often they're not; as engineers discovered when they started trying to build machines to understand language, a significant fraction of what we say is quietly ambiguous.*