So let’s talk about strategies. Without some plans about how to work through life’s
challenges and keep your ship floating, you can easily get overwhelmed. But even our favourite
strategies aren’t good all of the time. And the same is true of language: we might
have approaches that we really like using, but sometimes, they lead us to rather unfortunate
places. I’m Moti Lieberman, and this is the Ling Space.
This won’t be a surprise if you’ve been watching us for a while, but language moves
really fast, hundreds of words a minute zinging across the ‘verse into your ears or eyes.
And we’ve talked before about some of the ways we cope with that immense speed, like,
how we prime all the connections to any word that we happen to encounter. We pull up everything
we can think of that sounds like it, looks like it, has a meaning connected with it.
And then we drop all of the connections we don’t need very rapidly.
But we can’t just stop at words. We have to make something out of those words, combine
them into bigger meanings: we need to build sentences. But if we wait for the person we’re
talking with to finish their whole sentence, and only then look back over This Sentence
Land to decide how to structure and interpret it, then we’ve set ourselves quite the daunting
task. Because… that’s a lot of words to keep track of. That sentence I just spooled
out to describe the problem was 40 words long. 40 is a lot of words to just have kicking
around your mind buffer waiting to be treed up. But you probably didn’t have any trouble interpreting it, right?
That’s because when we go through sentences, we work them out incrementally, slotting words
in and predicting what’s coming up as our partner’s speech washes over us. This process
of syntaxing incoming speech into meaningful phrases is known as parsing.
There are a number of different models that linguists have come up with to try to explain
what exactly we’re doing when we parse sentences, but we’re going to just focus on one for today:
the garden path model.
In the garden path model, the parser goes through the sentence, and makes decisions
about how to build the syntax tree as soon as it possibly can for everything it runs into.
Whenever the parser encounters something it’s not sure about, it chooses the least complicated
of the available options for how to structure the sentence, so whatever takes the lowest
amount of power to compute.
But because the parser doesn’t have all the information about a sentence when it’s
making the decisions, it’s prone to a few particular kinds of mistakes.
Before we get to that, though, it’s worth noting how much your parser gets right. You’re
able to understand pretty much all of the sentences coming your way without even having
to think about it. Really – try to think about how many sentences you hear or read
over the course of a day, and how often you actually get confused about how everything
goes together. Not often at all, right? That fact shows you how well suited your mental
cogs are to taking care of all these linguistic challenges.
But we do get tripped up sometimes, and in those cases, it’s often because of the ways
that the parser cuts through the material. In particular, it has trouble with sentences
that are ambiguous, whether they’re just temporarily weird, or permanently stuck with multiple meanings.
In this model, the parser can’t care too much if there’s more than one possible structure
to consider. It’s just going to take the one that’s the easiest or the simplest. And
if that’s wrong, you can just fix it later.
The ways in which the parser gets tripped up help show us the nature of how it works overall.
So first, let’s take the kind of sentences that give this model its name: garden path
sentences. Here’s one: The ship raced to the dead planet went unnoticed. Okay, so when
you were listening to that, what happened? Did the last two words surprise you? Maybe
they even seemed ungrammatical. Well, that’s just because of how the parser works. It wants
to resolve everything as soon as it possibly can. You get “The ship… raced…” and
you’re like, great! Where did it go? To the dead planet? Awesome. Now my sentence is done.
And while your parser is already looking for the next phrase, suddenly, the extra words
appear, and you’re stuck. The parser led you down the garden path, and now you have
to reanalyze what happened. You have to go back and see that the sentence really had
a relative clause: The ship that was raced to the dead planet went unnoticed. But sometimes,
you get stuck so far down the garden path, you can’t see the way back.
So those interpretations are a product of your parser trying to tie up all the loose
ends in a sentence as soon as it possibly can. But there are other things that can happen,
too. Take, for example, a sentence like this one: “Alliance officers are proud to explain
what they are doing to people.” That’s… probably not the meaning you wanted, right?
The intended meaning is probably explaining to people what they are doing, not what they
are doing to people. So why do you get this other, strange reading?
The answer here is that the parser wants to stick the words it most recently heard into
whatever syntactic phrase it’s currently working on… even if that leads to implausible results.
This is a strategy known as Late Closure. It’s basically a recency effect, and it
explains weird interpretations of actual headlines, like “2 Sisters Reunited after 18 Years in Checkout Counter."
But in more normal discourse, the Late Closure effect is what makes you feel weird about
sentences like “Simon promised that he will treat everyone last week.” Late Closure
makes you lump together “last week” with the embedded sentence… until you realize
that it can’t both be that he will do it AND last week. And then you have to go back
and switch it to refer to the promising.
The last of the strategies we’ll talk about today plays off a different desire on the
part of the parser, and that’s to build the sentence with the least complexity that
it can. So let’s think about this for a second. Take a sentence that starts with “Kaylee
understands the engines.” Now, you could continue this sentence with “… very well,”
like she has a very strong grip on her mechanical charge. On the other hand, you could finish
it with “need fixing”, as in, someone’s explained to her that there needs to be some
repairs done. Both are grammatical, both are easily understandable.
So when you go into the sentence, you can’t know what you have to build. But your parser
wants to build the one with the simplest syntactic tree, or one with minimal attachments, which
is the name of this strategy. Minimal Attachment is what leads you to take “the engines”
as the object that is being understood, rather than the start of a new clause. But as soon
as you get to the “need”, you know that it can’t work anymore, and you have to go
back and fix it. Your parser may grumble a little, as it has to go stick a whole embedded
sentence down in there after “understands”, but it’ll do it. And sometimes, it’ll
grumble a lot: Minimal Attachment is a big part of the problem with the terrible garden
path sentence we saw earlier.
But Minimal Attachment can also play a role in what we do in approaching sentences that
are totally ambiguous: it pushes us towards the interpretation that’s simpler.
So take a sentence like, “Zoe told the captain that everyone trusted the story.” This sentence
really is ambiguous, but you probably got one interpretation way more easily, right?
You probably pulled the interpretation where Zoe reported to her superior officer that
the story went over well. But there’s a second interpretation, too: basically, that
Zoe told the story to the well-regarded captain. But that second reading doesn’t pop out
at you the same way. Why not?
Well, let’s look at the different trees here. For the first interpretation, the structure
is pretty straightforward. The thing is, to use the verb “tell,” you need three things:
someone doing the telling, someone getting told, and something to tell. And in this tree,
everything goes smoothly: Zoe does the telling, the captain gets told, and the idea that everyone
trusts the story gets communicated. Very nice and clean.
But in the other interpretation, the thing that’s getting told is the story itself,
which means that that noun phrase has to sit off at the end. And it also means that “the
captain” is actually at the front of its own relative clause, “that everyone trusted.”
And in relative clauses, you have to do an extra movement. So this is a more unwieldy,
complex tree, with dangly bits here and swooshing movements there and all sorts of issues. Clearly,
if you want to build nice, shiny trees, you just want the first one. And so you don’t
really get the second interpretation, unless you’re pushed.
Really, though, we shouldn’t be too hard on our parser. It does a whole lot for us,
and it only rarely leads us down the garden path and leaves us with weird interpretations.
For the most part, the way our brains approach breaking up the sentences coming our way is
smooth as a quiet ride through space. And it’s all thanks to our usually brilliant strategies.
So we’ve reached the end of the Ling Space for this week. If your parser didn’t crash,
you learned that we start processing the sentences we listen to before we even finish hearing them;
that according to the Garden Path model, we always try to build the simplest structures possible;
and that because of the strategies we use, like Late Closure and Minimal Attachment,
sometimes we end up with weird or missing interpretations.
The Ling Space is produced by me, Moti Lieberman. It’s directed by Adèle-Elise Prévost,
and it’s written by both of us. Our editor is Georges Coulombe, our production assistant
is Stephan Hurtubise, our music is by Shane Turner, and our graphics team is atelierMUSE.
We’re down in the comments below, or you can bring the discussion back over to our
website, where we have some extra material on this topic. Also, try dropping by our store,
where we have a bunch of cool linguistics stuff. Check us out on Tumblr, Twitter and
Facebook, and if you want to keep expanding your own personal Ling Space, please subscribe.
And we’ll see you next Wednesday. Selamat!