Lately I have been thinking of something and have gotten
stuck. Very stuck. This post is a request for help. Here’s the problem. It relates to some
current minimalist technology and how it relates to the bigger framework
assumptions of the enterprise. Here’s
what I don’t quite get: what’s it means to say that rules apply “all at once”
at Spell Out. Let me elaborate.
A recent minimalist innovation is the proposal that
congeries of operations apply simultaneously at Spell Out (SO). The idea of operations applying all at once
is not in and of itself problematic, for it is easy to imagine that many rules
can apply “in parallel.” However, when
rules so apply, they are informationally encapsulated in the sense that the
output of rule A does not condition the application of rule B. ‘Condition’ here
means neither feeds nor bleeds its application. When rules do feed and bleed
one another, then the idea that they all apply “all at once” is hard (at least
for me) to understand, for if the application of B logically requires
information about the output of A then how could they apply “in parallel.” But
if they are not applying “in parallel” what exactly does it mean to say that
the rules apply “all at once”?
One answer to this question is that I am getting entangled
in a preconception, namely my confusion is the consequence of a “derivational”
mindset (DM). The DM picture treats derivations like proofs, each line licensed
by some rule applying to the preceding lines.[1]
The “all at once” idea is rejecting this picture and is suggesting in its place
a more model theoretic idiom in which sets of constraints together vet a given
object for well-formedness. An object is well formed not if derivable from
rules sequentially applied, but no matter how constructed it meets all the
relevant constraints. This should be
familiar to those with GBish or OTish educations, for GB and OT are very much
“freely generate and filter” kinds of models, the filters being the relevant
constraints.[2]
If this is correct, then the current suggestion about simultaneous rule
application at SO is more accurately understood as a proposal to dump the
derivational conception of grammar characteristic of earlier minimalism in
favor of a constraint based approach of the GB variety.
Note, that to get something like this to work, we would need
some way of constructing the objects that the constraints inspect. In GB this was the province of Phrase Structure
Rules and ‘Move alpha.’ These two kinds of rules applied freely and generated
the structures and dependencies that filters like Principle A/B/C, ECP,
Subjacency, etc. vetted. In an MP setting, it is harder to see how this gets
done, at least to me. Recall that in an
MP setting, there is only one “rule,” (i.e. Merge). So, I assume that it would
generate the relevant structures and these would be subsequently vetted. In
effect the operations of the computational system (i.e. Merge, Agree and
anything else, e.g. Feature Transfer, Probing, ???) would apply freely and then
the result would be vetted for adequacy. What would this consist in? Well, I
assume checking the resultant structures for Minimality, Extension,
Inclusiveness, etc. The problem, then,
would be to translate these principles, which are easy enough to picture when
thought of derivationally, into constraints on freely generated structures. I
confess that I am not sure how to do this.
Consider the Extension condition. How is one to state this as a
well-formedness condition on derived structures rather than on the operations
that determine how the structures are derived? Ditto on steroids for
Derivational Economy (aka: Merge over Move) or the idea that shorter
derivations trump longer ones, or determining what constitutes a chain (which
are the copies that form a chain?). Are
there straightforward ways of coding these as output conditions in freely
generated objects? If so, what are they?
There is another subsidiary more conceptual concern. In
early Minimalism output conditions (aka filters) were understood as Bare Output
Conditions (BOCs). BOCs were legibility conditions that interfaces,
particularly CI, imposed on linguistic products. Now, BOCs were not intended to
be linguistic, though they imposed
conditions on linguistic objects. This means that whatever filter one proposes
needs to have a BOC kind of interpretation. This was always my problem with,
for example, the Minimal Link Condition (MLC). Do we really think that chains are
CI objects and that “thoughts” impose locality conditions on their interacting
parts? Maybe, but, I’m dubious. I can see minimality arising naturally as a
computational fact about how derivations proceed. I find it harder to see it as
a reflection of how thoughts are constructed.
However, whatever one thinks of the MLC, understanding Economy or
Extension or Phase Impenetrability or Inclusiveness as BOCs seems, at least to
me, more challenging still.
Things get even hairier, I think, when one considers that
range of operations supposed to happen “all at once.” So, for example, If the
features of T are inherited from C (as currently assumed) and I-merge is
conditioned by Agree, then this suggests that DPs move to Spec T conditional on
C having merged with T. But any such movement must violate Extension. The idea
seems to be that this is not a problem if all the indicated operations apply
simultaneously. But how is this accomplished?
How can I-merge be conditioned (fed) by features that are only available
under operations that require that a certain structure exists (i.e. C and “TP”
have E-merged) but whose existence would preclude Merging the DP (doing so
would violate Extension). One answer:
screw Extension. Is this what is being suggested? If not, what?
So, I throw myself on the mercy of those who have a better
grasp of the current technology. What is involved in doing operations “all at
once”? Are we dumping derivations and returning to a generate-and-filter model?
What do we do with apparent bleeding and feeding relations and the dependencies
that exploit these notions. Which principles are we to retain, and which
dispense with? Extension? Economy? Minimality? How to the rules/operations
work? Sample examples of “derivations” would be nice to see. If anyone knows the answer to all or any of
these questions, please let me know.
