This is the final part of my comments on lecture 3.

The first three parts are (

here,

here
and

here).
I depart from explication mode in these last comments and turn instead to a
critical evaluation of what I take to be Chomsky’s main line of argument (and
it is NOT empirical).

His approach to
labels emerges directly from his conception of the basic operation Merge. How
so? Well, there are only two “places” that MPish approaches can look to in
order to ground linguistic processes, the computational system (CS) or the
interface conditions (Bare Output Conditions (BOC)).

Given Chomsky’s conceptually spare
understanding of Merge, it is not surprising that labeling must be understood
as a BOC. I here endorse this logic and conclude that Chomsky’s

*modus ponens* is my

*modus tolens*. If correct, this requires us to rethink the basic
operation. Here’s what I believe we should be aiming for: a conception that
traces the kind of recursion we find in FL to labeling. In other words, labeling
is not a BOC but intrinsic to CS; indeed the very operation that allows for the
construction of SLOs. Thus, just as Merge now (though not in MPs early days)
includes both phrase building and movement, the basic operation,

*when properly conceptualized*, should
also include labeling.

To motivate you to aim for such a conception, it’s worth
recalling that in early MP it was considered conceptually obvious that Move and
Merge were different kinds of things and that the latter was more basic and
that the former was an “imperfection.” Some (including me and Chris Collins)
did not buy this dichotomy suggesting that whatever process produced phrase
structure (now E-Merge) should also suffice to give one move (now I-merge). In
other words, that FL when it arose came fully equipped with *both* merge and move neither being more
basic than the other. On this view, Move is not an “imperfection” at all.
Chomsky’s later work endorsed this conception. He derived the same conclusion
form other (arguably (though I’m not sure *I*
would so argue) simpler) premises. I derive one moral from this little history:
what looks to be conceptually obvious is a lot clearer after the fact than ex
ante. Here’s a good place to mention the owl of Minerva, but I will refrain. Thus,
here’s a project: rethink the basic operation in CS so that labels are
intrinsic consequences. I will suggest one way of doing this below, but it is
only a suggestion. What I think there are arguments for is that Chomsky’s way
of including labels in FL is very problematic (this is as close as I come to
saying that it’s *wrong!*) and
misdiagnoses the relevant issues. The logic is terrific, it just starts from
the wrong place. Here goes.

1. The
logic revisited and another perspective on “merge”

There are probably other issues to address if one wants to
pursue Chomsky’s proposal. IMO, right now his basic idea, though suggestive, is
not that well articulated. There are many technical and empirical issues that
need to be ironed out. However, I doubt that this will deter those convinced by
Chomsky’s conceptual arguments. So before ending I want to discuss them. And I
want to make two points: first that I think that there is something *right* about his argument. What I mean is
that *if* you buy Chomsky’s conception
of Merge, then adding something like a labeling algorithm in CS is conceptually
inelegant, if not worse. In other words, Chomsky is right in thinking that
adding labeling *to* his conception of
Merge is not a good theoretical move conceptually. And second, I want to suggest
that Chomsky’s idea that projection is effectively an interface requirement, a
BOC in older terminology, has things backwards.
The interfaces do not require labeled structures to do what they do. At
least CI doesn’t, so far as I can tell. The syntax needs them. The interfaces
do not. The two points together point to the conclusion that we need to
re-think Merge. I will very briefly suggest how we might do this.

Let’s start. First,
Chomsky is making exactly the right kind of argument. As noted at the outset,
Chomsky is right to question labeling as part of CS given his view that Merge
is the minimal syntactic operation. His version of Merge provides unboundedly
many SLOs (plus movement) all by itself. One can add projection (i.e. labeling)
considerations to the rule but this addition will necessarily go *beyond the conceptual minimum*. Thus,
Merge cannot have a labeling sub-part (as earlier versions of Merge did). In fact, the *only* theoretical place for labels is the interface as the only
place for anything in an MP-style account is as an interface BOC or the CS. But
as labels cannot be part of CS, they must be traced to properties of the CI/SM
interface. And given Chomsky’s view that the CI interface is really where all
the action is, this means that labeling is primarily required for CI
interpretation. That’s the logic and it
strikes me as a very very nice argument.

Let me also add, before I pick at some of the premises of
Chomsky’s argument, that lecture 3 once again illustrates what minimalist theorizing
*should aim for*: the derivation of
deep properties of FL from simple assumptions.
Lecture 3 continues the agenda from lecture 2 by aiming to explain three
prominent effects: successive cyclicity, FSCs and EPP effects. As I have stressed before in other places,
these discovered effects are the glory of GG and we should evaluate any
theoretical proposal by how well and how many it can explain. Indeed, that’s
what theory does in any scientific discipline. In linguistics theory should explain
the myriad effects we have discovered over the last 60 years of GG research. In
sum, not surprisingly, and even though I am going to disagree with Chomsky’s
proposal, I think that lecture 3 offers an excellent model of what theorists
should be doing.

So which premise don’t I like?

I am very unconvinced that labels reflect
BOCs. I do not see why CI, for example, needs labeled structures to interpret
SLOs.

What is needed is structured
objects (to provide compositional structure) but I don’t see that it needs

*labeled* SLOs.

The primitives in standard accounts of
semantic interpretation are things like arguments, predicates, events,
proposition, operator, variable, scope, etc. Not agreeing phrases, VPs or vPs
or Question Ps etc.

Thus, for example,
though we need to identify the Q operator in questions to give the structure a
question “meaning” and we need to determine the scope of this operator
(something like its CC domain), it is not clear to me that we also need to
identify a question phrase or an agreement phrase.

At least in the standard semantic accounts I
am familiar with, be it Heim and Kratzer or Neo-Davidsonian, we don’t really
need to know anything about the labels to interpret SLOs at CI. It’s the
branching that matters, not what labels sit on the nodes.

I know little about SM (I grew up in a philo dept and have
never taken a phonology course (though some of my best friends are
phonologists)), but from what I can gather the same seems true on the SM side.
There are difference between stress in some Ns and Vs but at the higher levels,
the relevant units are XPs not DPs vs VPs vs TP vs CPs etc. Indeed the general
procedure in getting to phrasal phonology involves *erasing* headedness information. In other words, the phonology does
not seem to care about labels beyond the N vs V level (i.e. the level of
phonological atoms).

If this impression is accurate (and Chomsky asserts but does
not illustrate why he thinks that the interfaces should care about labeled
SLOs) then we can treat Chomsky’s proposal as a reductio: He is right about how
the pieces must fit together given his starting assumptions, but they imply
something clearly false (that labels are necessary for interface legibility)
therefore there must be something wrong with Chomsky’s starting point, viz. that
Merge as he understands it is the right basic operation.

I would go further. If labeling is largely irrelevant for
interface interpretation (and so cannot be traced to BOCs) then labeling must
be part of CS and this means that Chomsky’s conception of Merge needs
reconsideration.

So let’s do that.

What follows relies on some work I did (

here).
I apologize for the self-referential nature of what follows, but hey it’s the
end of a very long post.

Here’s the idea: the basic CS operation consists of two
parts, only one of which is language specific. The “unbounded” part is the
product of a capacity for producing unboundedly big *flat* structures that is not peculiarly linguistic or unique to
humans. Call this operation *Iteration*.
Birds (and mice and bats and whales) do it with songs. Ants do it with path
integration. Iteration allows for the
production of “beads on a string” kinds of structures and there is no limit in
principle to how long/big these structures can be.

The distinctive feature of Iteration is that it could care
less about bracketing. Consider an example: Addition can iterate. ((a+b)+c)+d)
is the same as (a+(b+c+d)) which is the same as (a+b+c+d) etc. *Brackets in iterative structures make no
difference*. The same is true in path
integration. What the ant does is add up all the information but the adding up
needs no particular bracketing to succeed. So if the ant goes 2 ft N and then 3
ft W and then 6 feet south and then 4 ft E, it makes no difference to
calculation how these bits of directional information are added together. However
you do this provides the same result. Bracketing does not matter. The same is
true for simple conjunction: ((a&b)&c)&d) is equivalent to (a &
(b & (c&d))) which is the same as (a&b&c&d). Again brackets
don’t matter. Let’s assume then that iterative procedures *do not bracket*. So there are two basic features of Iteration: (i)
there is no upper bound to the objects it can produce (i.e. there is no upper
bound on the length of the beaded string), and (ii) bracketing is irrelevant,
viz. Iteration does not bracket. It’s just like beads on a string.

Here’s a little model. Assume that we treat the basic
Iterative operation as the set union operation. And assume that the capacity to
iterate involves being able to map atoms (but

*only* atoms to their unit sets (e.g. a

--> {a}). Let’s call this

*Select*. Select is an operation whose
domain is the lexical atoms and whose range is the unit set of that atom. Then
given a lexicon we can get arbitrarily big sets using U and Select.

For example: If ‘a’, ‘b’ and ‘c’ are atoms, then we can form {a} U {b} U {c} to
give us {a,b,c}. And so forth. Arbitrarily big unstructured sets.

Clearly, what we have in FL cannot just be Iteration (ie. U
plus Select). After all we get SLOs. Question: what if added to Iteration would
yield SLOs? I suggest the capacity to Select the *outputs* of Iteration. More particularly, let’s assume the little
model above. How might we get structured sets? *By allowing the output to Iteration to be the input to Select*. So,
if {a,b} has been formed (viz. {a} U {b}-> {a,b}) and Select
applies to {a,b} then out comes the structured SLO {{a,b}, c} (viz. {{a,b}} U
{c} -> {{a,b},c}. One can also get an analogue of I-merge: select {{a,b},c} (i.e.
{{{a,b},c}}, select c (i.e. {c}), Union the sets (i.e. {{{a,b},c}}} U {c}) and
out comes {c, {{a,b},c}}. So if we can
extend *the domain* of Select to
include outputs of the union operation then we can get use Iteration to deliver
unboundedly many SLOs.

The important question then is what

*licenses* extending the domain of Select to the outputs of
Union?

Labeling. Labeling is just the
name we give for

*closing* *Iteration in the domain of the lexical atoms*.

In effect, labels are how we create
equivalence classes of expressions based on the basic atomic inventory. Another
way of saying this is that Labeling maps a “complex” set {a,b}to either a or b,
thereby putting it in the equivalence class of ‘a’ or ‘b’. If Labels allow Select
to apply to

*anything in the equivalence
class of ‘a’* (and not just to ‘a’ alone), we can derive SLOs via Iteration.

Ok, on this view, what’s the “miracle”? For Chomsky, the
miracle is Merge. On the view above, the miracle is Label, the operation that
closes Iteration in the domain of the lexical atoms. Label effectively maps any
complex set into the equivalence class of one of its members (creating a
modular structure) and then treats these as syntactically indistinguishable
from the elements that head them (as happens in modular arithmetic (i.e. ‘1’
and ‘13’ and ‘12’ and ‘24’ are computationally identical in clock arithmetic).
Effectively the lexicon serves as the modulus with labels mapping complexes of
atoms to single atoms bringing them within the purview of Select.

Note that this “story” presupposes that Iteration pre-exists
the capacity to generate SLOs. The U(nion) operation is cognitively general as is
Select which allows U to form arbitrarily large unstructured objects. Thus, Iteration
is *not* species specific (which is why
birds, ants and whales can do it). What is species specific is Label, the
operation that closes U in the domain of the lexical atoms and this what leads
to a modular combinatoric system (viz. allows an operation defined over lexical
atoms to also operate over non-atomic structures). Note that *if *this is right, then labels are *intrinsic* to CS; without it there are no
SLOs for without it U, the sole combination operation, cannot derive sets
embedded within sets (i.e. hierarchy).

The toy account above has other pleasant features. For
example, the operation that combines things is the very general U operation.
There are few conceivably simpler operations.

The products of U produce objects that necessarily obey NTC,
Inclusiveness and produce copies under “I-merge.” Indeed, this proposal treats
U as the main combinatoric operation (the operation that constructs sets
containing more than one member). And if combination is effectively U, then
phrases

*must* be sets (i.e. U is a set
theoretic operation so the objects it applies to must be sets). And that’s

*why* the products of this combinatoric
operation respect the NTC, Inclusiveness and produce “copies.”

Let’s now get back to the main point: on this
reconstruction, hierarchical recursion is the product of Iterate plus Label. To
be “mergeable” you need a label for only then are you in the range of Select
and U. So, labels are a big deal and intrinsic
to CS. Moreover, this makes labeling facts CS facts, not BOC facts.

This is not the place to argue that this conception is
superior to Chomsky’s. My only point is that if my reservations above about
treating Labels as BOCs is correct, then we need to find a way of understanding
labels as intrinsic to the syntax, which in turn requires reanalyzing the
minimal basic operation (i.e. rethinking the “miracle”).

IMO, the situation regarding projection is not unlike what
took place when minimalists rethought the Merge/Move distinction central to
early Minimalism (see the “Black Book”).
Movement was taken to be an “imperfection.” Rethinking the basic
operation allowed for the unification of E and I-merge (i.e. Gs with SLOs would
also have displacement). I think we need to do the same thing for Labeling. We
need to find a way to make labels *intrinsic*
features of SLOs, labels being necessary for building structure and displacing
them. Chomsky’s views on projection
don’t do this. They start from the assumption that Labels are BOCs. If this
strikes you as unconvincing as it does me, then we need to rethink the basic
minimal operation.

That’s it. These comments are way too long. But that’s what
happens when you try and think about what Chomsky is up to. Agree or not, it’s
endlessly fascinating.