[A separate glossary of relevant terms, highlighted in
At the core of the Minimalist Machine, we have a mapping from configuration to configuration. We call this map the Actions.
A configuration is a 3-tuple (Heads, SO, ST).
The stack and Heads are implemented as Prolog lists. For computation efficiency, there is no search of either list by default, i.e. with respect to possible actions we only consider the front (or topmost) item. We refer to the topmost item on the stack as TOS. (With respect to the stack, some boundary cases (involving Phases) will involve a brief search.)
Each Action may have pre-conditions that must be satisfied before a commit. Once an Action is selected, the Machine will not consider alternate Actions. The list of Actions currently implemented is ordered as follows.
[Big picture: To improve the theory, we should aim to consolidate and eliminate Actions that are variants of one another.]
(Heads, SO, ST) ⟼ (Heads, SO, ST)
If the TOS or the current SO is a complete Phase, i.e. a phrase headed by a Phase head that does not project further, but not yet marked, we mark the Phase as complete.
([Head|Heads], empty, ST) ⟼ (Heads, Head, ST)
At the start of the derivation, the current SO is empty. The first head of the head list becomes the current SO.
Notation: generally, [X|L] denotes a list with first element X and L the remaining items in the list, e.g. in list [1,2,3], X would be 1 and L would be [2,3].
([D|Heads], N, ST) ⟼ (Heads, {D, N}, ST')
If the current SO is a noun N, and the first head is a determiner
D, we Merge D and N to form the new SO {D, N}. Determiner-noun
feature valuation is also carried out at this point.
N is pushed onto the stack if it has unvalued features after
determiner-noun valuation,
i.e. ST' = [N|ST]. This is used for relative clauses, see
below. Otherwise ST' = ST.
Notation: the Prolog list [X|L] may denote a stack with TOS element X and L the remaining items in the stack, e.g. in stack [top,2nd,3rd], X would be top and L would be [2nd,3rd].
Generally, we suppose D and N have uN (uninterpretable N) and uD
(uninterpretable D) features, respectively.
And normally, D values uD on N, and N values uN on D. However, if D has lexical
feature no_check(d), it cannot value uD on N. Similarly, if N has
feature no_check(n), it cannot value uN on D. We use this
system for our movement analysis of relative clauses, in which a
relative determiner, e.g. who in {who, man} leaves
man with an unvalued uD feature, licensing it to extract to
form {man, {who man, {C, ...}}}. Next, Merge
with the regular determiner the will value uD on man
for {the, {man, {who man, {C,
...}}}}.
[ Ideally, this uD/uN system should be eliminated. Similarly, the N head raising mentioned above should be eliminated as well, as it's unformulable in modern Merge theory.]
If N has an interpretable feature theta, it's also shared with D. Normally, D is the locus of the theta feature in our theory. However, we analyze yesterday as an N possessing an inherent theta role (temporal), which it passes to its D.
Possibly obsolete code: If both D and N have unvalued Case and N features, they are unified, i.e. shared.
([D|Heads], D, ST) ⟼ (Heads, {D, D}, ST')
Currently unused. We can nest determiners if needed. Merged D can be pushed onto the stack if unvalued features are present, i.e. ST' = [{D, D}|ST]. Otherwise ST' = ST.
([N|Heads], SO, ST) ⟼ (Heads, {N, SO}, [inactive(SO)|ST])
We implement Kayne's Doubling Constituent (DC) theory of pronominal coreference, e.g. the pair he-John initially forms a DC {d, {he, {d, John}}}, in which we have two DPs. At the C-I interface, the pair will be read as being coreferential. In Johni thinks hei is smart, the pair he-John initially Merges as the argument of smart, but only he gets Case and a theta role. Subsequently, the junior partner in the DC, i.e. John must raise to its own theta position.
When N has feature dc (doubling constituent), we Merge it with the current SO. SO is pushed onto the stack, but is marked as inactive there, meaning it cannot serve as a goal for probes. This is because SO will be the junior partner in the DC analysis, and SO will only become active when it is later Merged into its theta position.
In LEX, pronouns will host this dc feature and trigger this Action.
% triggers Doubling Constituent (DC) merge features(he,[f('D',_)],[f(phi,[3,sg,m],_)],[dc,occ(_)]). features(she,[f('D',_)],[f(phi,[3,sg,f],_)],[dc,occ(_)]).
Both involve Merge to the Edge of T, but this Action is listed earlier, and preferred to Action 7.
([EXPL|Heads], T, ST) ⟼ (Heads, {EXPL, T}, ST')
In Transitive Expletive Constructions (TEC), an expletive EXPL is externally Merged, i.e. EXPL must be taken from the Heads queue, to the edge of the T-phrase (that is the current SO) in preference to raising the external argument (to edge of T).
EXPL must have interpretable feature expl. It is pushed onto the stack if it has an unvalued feature, i.e. ST' = [EXPL|ST]. Otherwise ST' = ST. The T-phrase must be headed by T and have an available Edge feature, i.e. the T-phrase must have an unused Edge feature and it must not be a head (Merge must have already taken place).
[Note: no Edge iteration is permitted here.]
See also Action 6 above.
(Heads, T, ST) ⟼ (Heads, {X, T}, ST')
T, the current syntactic object (SO), is a T-phrase with an unused Edge feature and it must not be a head (Merge must have already taken place).
X is a term of T from the stack ST in the current Phase. (The stack holds theta-relevant SOs and is accessed instead of searching the current SO, for computational efficiency.) X will be Merged with T, forming {X, T}, the new current SO.
X must also satisfy any restrictions placed on this position by the head of T, e.g. be theta-relevant.
[Deep dive: X from the stack leaves the stack modified. The occurrence of X that remains on the stack will be marked with respect to Spell-out. Technically speaking, ST' is ST but with X's occ feature marked. The feature occ on the stack item is shared with the original term within T, so the original term is not pronounced at Spell-out.]
Heads that are verbs and adjectives may have an internal argument (IA). (See also Action 9 below.)
([X|Heads], IA, ST) ⟼ (Heads, {X, IA}, ST')
X is a verb or adjective head in the Heads queue. The current syntactic object (SO) IA is the internal argument. IA does not project further. External Merge forms the new SO {X, IA}. Furthermore, IA is theta-marked.
IA is pushed onto the stack if it has an unvalued feature, i.e. ST' = [IA|ST]. Otherwise, ST' = ST.
IA can be theta-marked if its head has an interpretable unvalued feature theta. We assume arguments can only be theta-marked once. In the current implementation, the locus of the theta-feature is in D and C, as theta-relevant noun phrases and clauses are headed by D and C, respectively.
In addition to verbs and adjectives, prepositions (P) may also have an internal argument (IA). In the current implementation, P is handled by a separate Action as pied-piping may occur and its IA may be marked with Inherent Case.
([P|Heads], IA, ST) ⟼ (Heads, {P, IA}, ST')
P is a prepositional head in the Heads queue. IA is the internal argument. IA does not project further. External Merge forms the new SO {P, IA}. Furthermore, IA is theta-marked. Additionally, if IA is a complete Phase, it is marked as such before Merge.
If P has ɸ-features, probe-goal is invoked, and P
assigns Oblique Case to IA and IA values the
uninterpretable ɸ-features of P. (This happens via the stack.)
If P
does not possess ɸ-features, P directly assigns Inherent Case
to IA.
If IA is an empty category, pied-piping is disallowed, following (Chomsky, 2001:28). If P is an empty category, we assume there is no pied-piping either. (At any rate, it won't be visible.) Otherwise, pied-piping is free.
Free pied-piping means that there are two possibilities for the stack, and therefore, two possible outcomes for this Action.
A further complication is that if IA is marked with Case, IA may not have any unvalued uninterpretable features remaining. Normally, we require this condition to be met before pushing a phrase onto the stack. However, wh-arguments need to be pushed onto the stack (for possible extraction). Therefore, if IA has interpretable feature wh, it goes onto the stack (even if it has no unvalued features). Similarly, if IA is to be relativized, i.e. it has interpretable feature rel, it is also placed on the stack (as we implement a movement account of relative clause formation).
Possibly obsolete code: we do not make use of P with ɸ-features in the English implementation. This was probably introduced for languages in which pre/post-positions may inflect.
[Needless to say, this should be cleaned up in future code. The pied-piping mechanism is an unclean hack used for English. We should factor this out in future code. However, the conditions for stacking may not be reducible.]
We assume prepositions (and adjectives) may have an external theta position. (See also Action 11 below.) We adopt dyadic prepositions from Pesetsky (1995) for double object constructions (but not the entire formulation). For example, we adopt the dyadic preposition G for the theta-configuration {give, {EA, {G, IA}}} as in I gave him the car, with EA of G = him and IA of G = the car. Relational adjectives, e.g. fond in we are fond of John's dog with structure {be, {we, {fond, John's dog}}}, are also labeled as being dyadic.
([EA|Heads], P, ST) ⟼ (Heads, {EA, P}, ST')
The current syntactic object (SO) P must be a phrase headed by a preposition (or adjective) with an unused edge feature. P must not be a head (Merge must have already taken place). The external argument EA must have been formed in a separate sub-Workspace and inserted into the Heads queue. EA must not (need to) project further and also satisfy any restrictions placed on this position by P, e.g. be theta-relevant. External Merge forms the new SO {EA, P}. Furthermore, EA is theta-marked.
EA is pushed onto the stack if it has an unvalued feature, i.e. ST' = [EA|ST]. Otherwise, ST' = ST.
Possibly obsolete code: EA may be Case-marked by P with Oblique Case if P has feature edge_case. This is not used in the English implementation.
See
We assume prepositions may have an external theta
position. The external argument may come from External Merge, as in
Action 10, or via Internal Merge from the junior partner of a Doubling
Constituent (DC) within the current syntactic object (SO). This latter
case is handled here. Example: I showed John himself in the
mirror is derived from John raising to the external
argument position of G from G's object DC himself-John. This
Action is responsible for building {John, {G,
himself-John}} by Internal Merge.
(Heads, P, ST) ⟼ (Heads, {EA, P}, ST')
The current syntactic object (SO) P must be a phrase headed by a preposition with an unused edge feature. P must not be a head (Merge must have already taken place). The external argument EA must be a term of P in the current Phase. EA does not project (internally) further. Internal Merge then forms the new SO {EA, P}. Furthermore, EA is theta-marked.
Possibly obsolete code: EA is already on the stack, but it is re-pushed (stack fronted), i.e. ST' = [EA|ST]. This was presumably added for cases of Backwards Binding, e.g. Pictures of each other in the tabloid annoy the actors. It is not clear it is needed anymore.
[The fact that we need a custom Action to do Internal Theta Merge is a weakness of the DC analysis.]
We assume 's is a determiner with an external theta position, e.g. as in Mary's mother. This Action is very similar to Action 10, but with a difference in Case assignment.
([EA|Heads], D, ST) ⟼ (Heads, {EA, D}, ST')
The current syntactic object (SO) D must be a phrase headed by a determiner with an unused edge feature. D must not be a head (Merge must have already taken place). The external argument EA must have been formed in a separate sub-Workspace and inserted into the Heads queue. EA must not (internally) project further and also satisfy any restrictions placed on this position by D, e.g. be theta-relevant. External Merge forms the new SO {EA, D}. Furthermore, EA is theta-marked. EA is also marked with Genitive Case.
EA is pushed onto the stack if it has an unvalued feature, i.e. ST' = [EA|ST]. Otherwise, ST' = ST.
See
Functional category v may have an edge feature, e.g. v*, licensing an external argument (EA). The preference is for EA to come from External Merge rather than Internal Merge. The latter case is used in the case of Doubling Constituents (DC).
([EA|Heads], V, ST) ⟼ (Heads, {EA, V}, ST')
The current syntactic object (SO) V must be a phrase headed by a v with an unused edge feature. V must not be a head (Merge must have already taken place). The external argument EA must have been formed in a separate sub-Workspace and inserted into the Heads queue. EA must not (internally) project further and also satisfy any restrictions placed on this position by V, e.g. be theta-relevant. External Merge forms the new SO {EA, V}. Furthermore, EA is theta-marked.
EA is pushed onto the stack if it has an unvalued feature, i.e. ST' = [EA|ST]. Otherwise, ST' = ST.
If no appropriate EA is available in the queue of heads, EA as a term of V may undergo Internal Merge to the external theta position. As mentioned earlier, this only applies in the case of DCs.
(Heads, V, ST) ⟼ (Heads, {EA, V}, ST')
The current syntactic object (SO) V must be a phrase headed by a v with an unused edge feature. V must not be a head (Merge must have already taken place). The external argument EA is a term of V in the current Phase. EA must not (internally) project further and also satisfy any restrictions placed on this position by V, e.g. be theta-relevant. Internal Merge forms the new SO {EA, V}. Furthermore, EA is theta-marked.
EA is already on the stack, but it will be re-pushed, i.e. fronted, to handle cases such as Henrietta found a picture of herself, in which Henrietta is raised from object DC herself-Henrietta.As Henrietta must also undergo raising to edge of T, it is fronted to TOS to be immediately accessible.[As in the case of Action 10, the fact that we need a custom Action to do Internal Theta Merge is a weakness of the DC analysis.]
We implement selection of a phrase headed by lexical V by v.
([V|Heads], SO, ST) ⟼ (Heads, {V,SO}, ST')
The head V at the front of the queue is the functional head v. The current syntactic object SO is a phrase headed by lexical V. As a pre-condition, SO must not (internally) project further, e.g. if V selects for an object, that obligation must be fulfilled before this Merge. External Merge forms the updated SO {V, SO}.
If V is a probe, a search for a matching goal in SO is performed. The probe-goal operation may be iterated in case V has multiple unvalued features.
V itself could be a goal. If it is a goal, ST' = [V|ST]. Otherwise, ST' = ST.
We implement selection of a phrase headed by v by T.
([T|Heads], SO, ST) ⟼ (Heads, {T,SO}, ST)
Tense T is a head at the front of the queue. The current syntactic object SO is a phrase headed by v. Furthermore, SO must not (internally) project further. External Merge forms the updated SO {T, SO}.
If T is a probe, a search for a matching goal in SO is performed. The probe-goal operation may be iterated when T has multiple unvalued features.
We implement movement to the edge of NegP.
(Heads, Neg, ST) ⟼ (Heads, {XP, Neg}, ST)
The current syntactic object (SO) Neg is headed by Neg and has an unused edge feature. XP is the most prominent theta-relevant phrase in Neg. Internal Merge forms the updated SO {XP, Neg}.
Languages will vary according to whether Neg permits movement to its edge or not. This is controlled by the presence of the edge feature in the specification of Neg in the grammar. We also expand this system to Mood heads.
For computational efficency, no search of Neg is performed. Instead, we make use of stacked theta-relevant DPs, i.e. XP is TOS.
This Action iteratively implements Chomsky's general set formation operation FormSet.
([XP|Heads], SO, ST) ⟼ (Heads, SO.append(XP), ST)
XP is a phrase at the head of the queue. The current syntactic object SO is either already a set or a single syntactic object. In the former case, XP is appended to the set SO. In the latter case, SO is first upgraded to a singleton set {SO} and then XP is appended, forming set {SO, XP}.
A pre-condition for set formation is that all the members of the set must satisfy a parallelism requirement. Currently:
All members must be headed by the same head.
All members must also be complete phrases, i.e. not (internally) be capable of projecting further.
[More conditions will be necessary as FormSet will be expanded for unbounded, unstructured coordination.]
We implement selection of a phrase headed by T by the complementizer C.
([C|Heads], T, ST) ⟼ (Heads, {C, T}, ST)
C is a complementizer head at the front of the queue. The current syntactic object SO is a phrase headed by T. Furthermore, T must not (internally) project further, e.g. T's edge feature obligation must be satisfied before this Merge. External Merge forms the updated SO {C, T}.
If C is a probe, a search for a matching goal in T is performed. The probe-goal operation may be iterated when C has multiple unvalued features.
Step 2 in this Action: if C has an edge feature, Internal Merge of a matching goal G in T to the edge of {C, T} obtains, forming {G, {C, T}}.
For example, interrogative C, named CQ here, has an edge feature that attracts a wh-DP to its edge. In what does John see, CQ probes and values uScope on DP what, which raises to the edge of CQ. CQ also has a unvalued T feature, which probes and attracts the head T to raise to C, following Pesetsky and Torrego. Do-support is triggered at Spell-out by T in CQ. To stage this correctly for Spell-out, we stipulate that T to C happens before wh-DP to edge of CQ. As a result, we obtain the structure {what, {T, {CQ, TP}}}.
([XP|Heads], YP, ST) ⟼ (Heads, <XP, YP>, ST)
XP and the current syntactic object (SO) YP are both non-head phrases that do not (internally) project further. The updated SO will be the Pair Merge structure <XP, YP>, XP the adjunct, and YP the continued projection of the current SO.
The adjunct in a Pair Merge structure is no longer accessible to search. There are two special cases handled here.
XP must not be a theta-relevant phrase with an unvalued theta role, as theta role assignment is not possible to an adjunct. Strictly speaking, this is not conceptually necessary as we could let the derivation proceed and catch this at the C-I interface. However, theta-relevant DPs must all be theta-merged. We should not allow other operations to apply, a case of Chomsky's Duality of Semantics.
To handle cases such as the nominal adjunct yesterday in examples such as the letter which Dick wrote yesterday, an XP with unvalued Case will be assigned Oblique Case here to prevent crashing at the C-I interface. This is a hack and should be rethought.
We implement Cechetto and Donati's 2015 account of
relativization. Under this account, the to-be-relativized head noun
raises from the relative clause to head a new noun phrase. For
example, in the man John know, we assume the clause is
{{Drel, man}, {Crel, {John, {T, {John,
{v*, {know, {D, man}}}}}}}} prior to raising
man from the edge of Crel to head a new noun
phrase {man, {Drel, man}, {Crel, {John,
{T, {John, {v*, {know, {D, man}}}}}}}}. We assume
the clause is headed by Crel, a probe that attracts a DP
headed by Drel to its edge, i.e. {Drel, man}.
([D|Heads], CREL, ST) ⟼ ([D|Heads], {N, CREL}, ST)
The current syntactic object (SO) CREL is a phrase headed by Crel. CREL is a complete Phase. The nominal head N is a term of CREL. In particular, we find N at the edge of CREL. Internal Merge forms the updated SO {N, CREL}.
Implemented, but not conceptually necessary: D is the determiner at the head of the queue. We check to see if D agrees with extracted N as a precondition of this Action. D will Merge with the updated SO in the next step.
As in the other cases involving Internal Merge, the search for N in the current SO is made efficient by having N be on the stack. Normally, only theta-relevant phrases may appear on the stack. The core cases are argument DPs. The definition is expanded to include N, although it is not an argument.
[Unfortunately, this is a construction-specific Action designed to facilitate relativization only. That is one reason this Action should be replaced in the future. A second reason is that head raising in unformulable in the latest theory.]
We implement the set counterpart of Action 21 for stacked relatives
such as the student who lives here who studies English who I
know. In this example, each of the Crel-headed
clauses, viz. (i) whorel student lives here, (ii)
whorel student studies English and (iii)
whorel student I know whorel
student are members of a set. Members of such a set (formed
by the FormSet Action above) must obey some parallelism requirement,
e.g. all must be clauses headed by Crel.
Similarly, operations on one member of the set must be possible for
all members. Assuming Action 21 is, in principle, available to sets as
well regular syntactic objects, notice the head student may
be extracted from all members simultaneously to form
{student,
{whorel student lives here,
whorel student studies
English,whorel student I know
whorel student}}.
([D|Heads], {CREL,.., CREL} ST) ⟼ ([D|Heads], {N, {CREL,.., CREL}}, ST)
The current syntactic object (SO) is a set {CREL,.., CREL}. The cardinality of this SO must be greater than one. With respect to set parallelism, the nominal head N must be an identical inscription found in all members of the current SO at the edge of the Phase.
[The critical comment on Action 21 equally applies here.]
Any two nouns with unvalued D features may be compounded. This mean they share unvalued D. A single D then can value them both simultaneously.
([N1|Heads], N2, ST) ⟼ (Heads, {N1, N2}, ST)
N1 is a noun at the head of the queue. Heads is the rest of the queue. The current syntactic object (SO) N1 is a phrase (possibly a head or an already compounded noun). External Merge forms the updated SO {N1, N2}. The D feature of both nouns are merged. The queue of heads is updated to the rest of the heads, viz. Heads.
As implemented, currently, the last Merged noun will be the head of the compound.
[Should noun-noun compounding be part of Narrow Syntax? Perhaps this operation is better placed in LEX.]
This is a last resort Action. When no prior Action applies, we simply permit External Merge (without explicit licensing).
([X|Heads], SO, ST) ⟼ (Heads, {X,SO}, ST')
The head X at the front of the queue is merged with the current syntactic object SO. External Merge forms the updated SO {X,SO}. The queue of heads is updated to be Heads, i.e. the remainder of the queue after X.
If X is a probe, i.e. it is a head that has an unvalued uninterpretable feature, it searches for a matching goal in SO.
SO is pushed onto the stack if it has an unvalued feature, i.e. ST' = [SO|ST]. Otherwise, ST' = ST.