A Computational Model of Language Generation Applied to English Wh-questions
Jason Ginsburg
Center for Language Research
University of Aizu
Aizuwakamatsu, Japanjginsbur@gmail.com

Abstract—This paper presents a computational model of language generation, based on Phase Theory, that automaticallyconstructs sentences from underlying numerations. This model
incorporates explicit algorithms that determine selection andmerger of Lexical Items from a subnumeration, determine thelabels of Merged syntactic elements, account for movement ofelements within a derivation, and account for when phrases
are sent to Spell-Out. This paper shows how this model automatically produces the derivation of an English wh-question.
Keywords-Phase Theory; wh-questions, computer modeling

I. I NTRODUCTION
In this paper, I describe an attempt to create a precise andunambiguous computational model of sentence generation
based on Phase Theory ([1], [2], [3], [4]). The goal of thiswork is to model a version of Phase Theory on a computerand in the process create a more accurate theory of how thehuman mind generates sentences.
In Phase Theory, a sentence is constructed via a bottomup process in which Lexical Items (LIs) are selected froma numeration, which consists of subnumerations, and are
Merged together. A derivation is broken up into phases forwhich v* (transitive v) and C (also possibly D) are phaseheads. A derivation is subject to the Phase Impenetrability
Condition (PIC), which determines when phrases are sent toSpell-Out (or to Transfer). The PIC has been formulated in
at least two ways (cf. [5]). According to one version ([1],[2]), in (1), when the phase head v* or C is Merged, thecomplement of the phase head, VP or TP, is sent to SpellOut. According to the other version [3], in (1), when C is
Merged, VP, which is the complement of v*, is sent to SpellOut.
(1) [CP C [T P T [vP ∗ v* [V P V . . . ]]Once a phrase is sent to Spell-Out, its contents are nolonger accessible to higher operations. Within Phase Theory,a head with an uninterpretable feature functions as a probethat Agrees with a goal (if present) that has a matchinginterpretable feature. Crucially, a probe cannot agree with agoal that is within a phrase that has been sent to Spell-Out.
There are some issues with Phase Theory that the researchpresented in this paper attempts to clarify. First, it is generally assumed that an LI selects for another LI; e.g., v* selectsfor V and V selects for DP, but it is not entirely clear how
this selection process works. Also, issues arise with respect
to the relationship between phases, subnumerations, and thetiming of Spell-Out. A subnumeration can consist of LIs thatform a phase, or it can consist of LIs that form a subject or
adjunct, which must be formed outside the main spine of a
derivation (see [6] for discussion of why this is the case).
Under the PIC, a phase edge remains visible to a higher
phase and a complement of a phase head is sent to SpellOut. Thus, there is a lack of a one-to-one correspondence
between sending an element off to Spell-Out and ‘phasehood’. Furthermore, the PIC creates problems for notionsof movement. In cases of long distance movement in whquestions, EPP features are required to bring a wh-phrase
to its scope position. In the question ‘What did you thinkthat Bob ate?’, ‘what’ must move through all intervening
phase edges to arrive in its scope position, as shown in (2).
To account for this fact, [1] suggests that a phase head canoptionally have an EPP feature that attracts a wh-phrase.
However, if a derivation proceeds in phases, and a lower
phase is not ‘aware’ of the contents of a higher phase, thenit is not clear how an intervening phase head can know thatit requires an EPP feature (cf. [7]).
(2) [CP What C[EP P | did [v∗P twhat v*[EP P | you think [CPtwhat that[EP P | Bob [v∗P twhat v*[EP P | tBob ate twhat ]]]]
This paper describes a computational model of language
generation that attempts to shed light on some of the complex issues and problems with Phase Theory. This model isnovel in that it is, to my knowledge, the first attempt to create
a computer program that, from the perspective of Phase
Theory, automatically constructs interrogative constructions
from underlying numerations. In the following sections,
I describe the basic algorithms that this model uses andI demonstrate how the model successfully constructs thederivation of an English wh-question from a numeration.
II. H OW THE MODEL WORKS
I created a computer program, implemented in the Python
programming language, that is fed a numeration, from which
it automatically constructs the derivation of a sentence. In
this section, I explain the basic algorithms of this model.

The model incorporates a bare phrase structure (cf. [8])view of a syntactic tree. A tree is formed from iterative
Merge of two elements at a time, and the label of the tree isthe label of one of the Merged elements; e.g., a phrase has
the label D instead of DP.
A derivation begins with a numeration such as (3), whichcontains the LIs X and Y as well as another subnumerationthat contains the LIs Z and W, and so on.
(3) {X, Y, {Z, W, {P, {Z, W}, Q}}}
Once fed a numeration, the model searches for the mostembedded subnumeration by recursively applying (4).
(4) Choose Subnumeration: For each element in S (a subnumeration), if S is a set S’ (another subnumeration), selectS’.
Given the numeration (3), the Selector (the elementof the model that selects elements from a numeration/subnumeration) will, via iterative application of (3),initially select the most embedded subnumeration {Z, W}.
Once a subnumeration is selected, LIs are selected andMerged. The features that LIs contain play an important rolein this process.
As shown in Table 1, there is one type of unvalued feature(a), and there are two types of valued features (b-c). The ‘: ’in (a) represents an unvalued feature. An unvalued feature
(a)
(b)
(c)

FeatureUnvalued
ValuedValuedDescription
Feat:+Feat:X
Feat:X

Table IF EATURESof type (a) in Table 1 must be valued by a matching valued
feature. For example, T has unvalued phi-features ‘Phi: ’that obtain a phi-feature value from a valued ‘Phi:X’. Thismodel also utilizes unvalued label features that are valuedby the label of a Merged element. For example, an unvalued‘N: ’ feature contained on a D is valued by the ‘N’ labelof a noun complement. A valued feature of type (b) must
undergo a feature checking relation in which the valued
feature assigns an unvalued feature a value. The ‘+’ in the‘+Feat:X’ signifies that the feature must be assigned. This
type of feature functions as a probe that searches for amatching unvalued feature. For example, (structural) case isa feature of this type; a ‘+Case:X’ feature that must assign avalue to a matching unvalued ‘Case: ’ feature. On the other
hand, the valued feature in (c) need not, but can, undergo afeature checking relation. In this model, an N comes withvalued phi-features of type (c). These phi-features can value
matching unvalued phi-features on T. However, there is noinherent need of the phi-features on N (unlike a case featureon T) to value a matching unvalued feature.
Following [9], features are also specified for interpretability. Interpretable features remain throughout a derivation anduninterpretable features must be eliminated for a derivation
to converge. For example, phi-features on N are interpretable, represented as ‘iPhi:X’ (‘i’ signifies interpretable),and unvalued phi-features on T are uninterpretable, represented as ‘uPhi: ’ (‘u’ signifies uninterpretable), and must
be valued and eliminated. It is possible for there to bevalued and unvalued features that are interpretable or uninterpretable. However, when two features undergo an Agreerelation, either one feature is interpretable (e.g., valued phifeatures on a nominal) and the other is uninterpretable(e.g., unvalued phi-features on T), or both features areunintepretable (e.g., a valued uninterpretable case feature
on T, ‘u+Case:Nom’, and an unvalued uninterpretable casefeature on a nominal, ‘uCase: ’).
This model assumes that an EPP feature is a subfeature ofa feature, along the lines of [10]. Specifically, a ‘+Feat:X’feature (feature b in Table 1) can have an EPP subfeaturethat forces an element with a matching unvalued feature to
Merge directly with the element containing the ‘+Feat:X’;
the EPP subfeature is only satisfied if the LI with a matching unvalued feature is Merged locally. For example, theEnglish finite T contains a ‘u+Case EPP:Nom’ feature. The
EPP subfeature forces a subject, with an unvalued ‘Case: ’feature, to undergo movement from the v* edge, assumingthat it is base generated in v*; the subject leaves a copy inits base position and is re-Merged with T, thus eliminating
the EPP subfeature on T and valuing the Case feature on
the subject. The checked Case features are then eliminatedbecause they are uninterpretable.
The Selector utilizes the following algorithm to choose an
LI to select from the working subnumeration.
(5) Select LI:(a) If nothing is selected, select an N (or a predicate).
(b) Search for an LI that has an unvalued feature thatmatches the label of the tree. (Select the LI that has
the fewest number of unvalued features first.)(c) A subnumeration must be emptied.
According to (5a), initially, an LI with the label N is
selected.1 Once an LI is selected, the selection process proceeds via application of (5b-c). The tree in the derivational
working space has a label. Thus, in accord with (5b), there
is a search in the current subnumeration for an LI with anunvalued label feature (e.g., ‘N: ’) that matches the label ofthe tree (e.g., ‘N’). Note that the algorithim searches for LIs
with the fewest number of unvalued features first, in accord
with (5b). This is crucial to avoid indeterminancy in theselection process. For example, assume that the label of thetree is D and both V and v* are in the subnumeration. Both V
and v* have ‘uD: ’ features, since V selects a D complement
and v* selects a D subject. In this model, V has 2 unvalued
features ‘[uTNS: , uD: ]’, where the unvalued ‘uTNS: ’requires valuation from a matching valued feature on T. The
1 In the absence of N, a predicate, such as a predicate adjective is selected.

v* has the 3 unvalued features ‘[ uPhi: , uD: , uV: ]’, where‘uPhi: ’ represents unvalued uninterpretable phi-features and‘uV: ’ is an uninterpretable unvalued V feature (v* selectsfor V). The v* has more unvalued features (3 versus 2 forV) because it selects for both a V and a D. Thus, V is
Selected from the subnumeration. Lastly, (5c) requires that
if no LI is selected from a subnumeration ((5a-b) fail), andthere is only one LI remaining, that remaining LI is selected.
In this manner, this model incorporates an explicit method
for selecting LIs from a subnumeration.
After the selection process, there is a process of Merge
that proceeds as follows.
(6) Merge:(a) If there is no tree for a selected LI to Merge with, thenrepeat the selection process.
(b) Otherwise, Merge the selected LI with the tree.
(c) The LI that initially has an unvalued label feature gives
the tree its label.
(d) Otherwise, the label is the label of the tree.
(e) An unvalued label feature is valued by the label of thesister LI.
At the initial stage of a derivation, once an element isselected, the selection process must be repeated to selectone more element (6a), so that there will be two elementsthat can Merge. If there is already a tree in the derivational
workspace, then the selected element is Merged with thetree. The label of a Merged syntactic object is determinedaccording to (6c-d). Following (6c), if a tree with label Y
Merges with an LI X, if X has an unvalued label feature‘Y: ’, then the label becomes that of X, producing a structureof the form [X X Y] (a head-complement structure). In thiscase, the unvalued label feature of X is valued by the label ofY, in accord with (6e). If the label Y of a tree has an unvalued
label feature ‘X: ’, then when Y Merges with X, the label
remains Y, also in accord with (6c), resulting in [Y X Y] (aspec-head structure), and the unvalued label feature of Y isvalued by the label of X. According to (6d), if the label Yof a tree and the selected LI X both lack any unvalued label
features, then the label remains that of Y (an adjunction
structure), resulting in [Y X Y].
After Merge, there is a feature checking operation (7).
(7) Check Features:(a) An unvalued ‘Feat: ’ feature is valued by a matchingvalued feature.
(b) If a probe (e.g., ‘+Feat EPP:X’) contains an EPP
subfeature, feature checking requires local Merge.
Feature checking results from a probe-goal relation, wherea probe must be contained within the label LI of a tree.
A probe is either a ‘Feat: ’ or a ‘+Feat:X’ feature, which
searches for an LI in the Merged structure that contains
a matching feature. An LI with a ‘Feat: ’ searches for amatching valued feature, and an LI with a ‘+Feat:X’ featuresearches for a matching unvalued feature. If an LI with amatching feature is found within the accessible portion of atree (a portion that has not been sent to Spell-Out), there
is a feature valuation relation (7a), resulting in checkedfeatures. During the feature checking process, if a probe‘+Feat:X’ contains an EPP subfeature, then the elementwith the matching unvalued feature must be Merged locally(7b). If the externally Merged LI does not have a matching
feature, then the EPP subfeature can force internal Merge.
For example, a ‘+Case EPP:Nom’ on T forces a subject toleave a copy in its base position and be re-Merged to T.
This process of Selection, Merge, and feature checking
is repeated until a subnumeration is emptied. Then, if the
Merged structure does not have a phase label v* or C*,
which is the case for adjuncts and subjects, it is reinserted
into the higher subnumeration (8), after which it functions
as any other LI and can be selected and re-Merged.
(8) Reinsert a complete non-phase into a higher subnumeration.
Otherwise, these processes of Selection, Merge, and featurechecking continue until Spell-Out, which applies in thefollowing two conditions: a) Spell-Out applies to a lower
phase when the head of a higher phase is Merged (in(9), when C* is Merged, the lower v* phrase is sent toSpell-Out), and b) Spell-Out applies when a numeration is
emptied. I use * to indicate a phase head - thus v* and C*
are phase heads.
(9) [C∗ C* [T T [v∗ v* [v∗ V. . . ]]Note that an entire phase, not just the complement of a phasehead, is sent to Spell-Out at once (the entire v* phase in (9)is sent to Spell-Out when C* is Merged). Thus, there is a
one-to-one correspondence between phase-hood and SpellOut.
Once a phrase is sent to Spell-Out, there is first a Last
Resort Check2 operation (10) whereby an element that iscontained within a phrase that is about to be sent to SpellOut is reinserted into a higher subnumeration as a Last
Resort, thus saving a derivation from crashing.
(10) Last Resort Check: If an LI with an unvalued feature iscontained within a phrase that is about to be sent to SpellOut, reinsert this LI into the current working subnumeration.
In (11), when C* is Merged, the lower v* will be sent toSpell-Out. If α contains an unvalued feature, then when C*
is Merged, α is reinserted into the higher subnumeration
headed by C*. The renumerated LI α then functions as anyother LI - it can be selected and re-Merged into a derivation.
(11) [C∗ C* T [v∗ v* V α[F eat: ] ]]This operation crucially does away with the need to posit
EPP features that exist solely for the purpose of bringing anelement to a Phase Edge (see section I).
Once the Last Resort Check operation is completed, there
is a Crash Check operation (12).
2 I thank Sandiway Fong, with whom I developed this view of Last Resort.
Any problems with this view are my own.

(12) Crash Check: If there are any unvalued features ‘Feat: ’or any unassigned valued features ‘+Feat:X’, the derivation
will crash.
If the derivation does not crash, then the relevant phrase(an unordered set that contains LIs and other sets of LIs) islinearized via recursive application of the algorithm in (13).
(13) Linearization:(a) Find the most embedded phrase.
(b) A label LI is Merged to the left when the label LI
Merges for the first time.
(c) A non-label LI Merges to the left when the label LI has
previously undergone Merge.
(d) Reinsert the linearized element into the higher phrase.
The Selector chooses the most embedded phrase (a set ofMerged LIs), linearizes it and then reinserts it into the larger
phrase that it is embedded in (if present). For English, whena label LI Merges with another LI, and nothing has Mergedwith the label before (first Merge), then, in accord with(13b), the label is Merged to the left (a head precedes its
complement). Following (13c), Merge of another element
to the label (second Merge) is also to the left (a specifier
or adjunct precedes a head).3 Once a phrase is linearized,
phonological rules apply; for example, T may be pronounced
as a form of ‘do’, etc. Since a derivation is built in a bottom
up fashion, a successfully linearized phrase that is contained
within a larger phrase is not actually pronounced until thederivation is complete.
Lastly, this model incorporates a model of wh-phrases
that follows work by Cable [11]. Cable, based primarily
on evidence from Tlingit, proposes that in a wh-question,a question particle ‘Qu’4 Merges with a wh-phrase, andfurthermore, C attracts Qu rather than a wh-phrase. In a
wh-movement language (such as English), a wh-phrase is
the complement of Qu, and thus when Qu moves, it brings
its complement wh-phrase with it. In this computationalmodel, an English wh-phrase is is the complement of Qu. I
demonstrate how this works in the following section.
III. D ERIVATIONIn this section, I demonstrate how this model successfully
produces the derivation of the ‘simple’ English wh-question(14). The computer model is fed the underlying numeration(15), where ‘C Int’ refers to an interrogative C and ‘PAST’is a past tense T.5(14) What did John eat?
(15) {C Int, PAST, {v*,{D, John}, Qu, D, what, eat}}
Crucially, the numeration and embedded subnumerations of(15) are sets. The computer program automatically constructs a detailed step-by-step derivation of (15).
3 The linearization order may require some variation with respect tocertain adjuncts. I leave this issue for futher research.
4 Cable used ‘Q’.
5 I assume that in English if there is an N, there there must be a D.

The model utilizes a ‘lexicon’ to automatically rendereach LI into a list consisting of the label, the form, and thefeatures that are relevant for the derivation. For example,
the LI ‘John’ has the representation ‘[N, John, [iPhi:X]]’
in which its label is ‘N’, its form is ‘John’, and it has
interpretable and valued phi-features ‘iPhi:X’.
Initially, the Selector finds the most embedded subnumeration, in accord with (4), and thus finds the subnumeration
containing the subject, which requires its own subnumeration(see section I). In (16), the LIs in the subnumeration are
represented as lists containing the label, form, and features.6(16) {[D, [uN: , uCase: ]], [N, John, [iPhi:X]]}
Since no LIs have been selected (as this is the initialstage of the derivation), the N ‘John’ is selected, in accord
with (5a). As only one element has been selected at thispoint, the selection process is repeated, following (6a). The
D is then selected in accord with (5b) because it contains
an unvalued label feature ‘uN: ’ that matches the label ofthe already selected N. The two LIs Merge and, following(6c), since D initially contains an unvalued label feature‘uN: ’, the label of the newly formed syntactic object is
D. At this point, the unvalued label feature ‘uN: ’ of D
is valued by the N label of ‘John’, in accord with (6e).
Since this label feature is uninterpretable, it is eliminated.
The resulting Merged structure (a set that lacks linear order)
is shown in (17). The Merged LIs are enclosed in brackets
containing the label, form, and features, and the head of the
Merged structure is the non-bracketed D. The ‘Chkd’ (for‘checked’) in ‘ChkdN:X ’ refers to an uninterpretable featurethat has been deleted.
(17) {D, [D, [ChkdN:X, uCase: ]], [N, John, [iPhi:X]]}
Since the subnumeration is emptied and this syntactic object
with the label D is a non-phase, following (8), there is aprocess of renumeration - the D phrase is reinserted into thehigher v* subnumeration.
The Selector then moves on to the next higher v* subnumeration (18), which contains the renumerated subject (aset with the label D).
(18) {[V, eat, [uTNS: , uD: ]], [N, what, [iPhi:X,
iWH:X]], [D, Qu, [uTyp:Int, iScp: , uCase: , uN: ]], [v*,[u+Case:Acc, uPhi: , uD: , uV: ]], {D, [D, [ChkdN:X,
uCase: ]], [N, John, [iPhi:X]]}}At this point, the N ‘what’ is selected, following (5a).7 Since
there is only one selected element, the selection process isrepeated (6a) and a Q-particle ‘Qu’ is selected, in accord
with (5b), since it contains an unvalued label feature ‘uN: ’.
I assume, for the sake of simplicity, that Qu is a D.8
The process of Merge and feature checking apply, thereby
resulting in the Merged structure in (19), with the label D,
due to D’s initial unvalued label feature ‘uN: ’ (6c).
6 I assume that an unvalued case feature ‘uCase: ’ occurs on D rather
than N. This issue though requires further examination.
7 The ‘iWH:X’ feature represents a valued interpretable wh-feature.
8 One possibility is that a D head Merges wth Qu.

(19) {D, [D, Qu, [uTyp:Int, iScp: , uCase: , ChkdN:X]], [N,what, [iPhi:X, iWH:X]]}
Qu contains a ‘uTyp:Int’, which is an uninterpretable clausal
typing feature ‘uTyp’ with the value ‘Int’ for interrogative.
Qu also contains an unvalued ‘iScp: ’ feature, that whenvalued, gives a wh-phrase scope. In this model, the interrogative C* contains an unvalued ‘iTyp: ’ feature and avalued ‘uScp:X’ feature. When C and Qu undergo a feature
valuation relation (at the final stage of this derivation), the‘uTyp:Int’ of Qu values the ‘iTyp: ’ of C, thereby giving
the clause an interrogative interpretation, and the valued‘uScp:X’ of C values the ‘iScp: ’ of Qu, giving the whphrase scope.9
The remainder of the v* phrase is constructed as follows.
There is again a search within the subnumeration for anelement that ‘selects’ a D, which is the label of the tree.
Although both V and v* have ‘uD: ’ features, V is selectedin accord with (5b), since it has fewer unvalued features
than v*. After Merge, the label of the tree is V, since V
initially contains an unvalued label feature (6c). Anothersearch within the subnumeration results in selection of v*,
since it contains a ‘uV: ’ feature (5b) that matches the Vlabel of the tree. After Merge, the label is v* since v*
contains an unvalued label feature (6c). Feature checking
applies and the unvalued phi-features ‘uPhi: ’ on v* function
as a probe that Agrees with and is valued by the valued phifeatures ‘iPhi:X’ on the N ‘what’. The ‘u+Case:Acc’ on v*
also acts as a probe that Agrees with and values the unvalued‘uCase: ’ feature on D. Since case is uninterpretable on
both v* and D, the accusative case features are eliminatedfrom the derivation. At this point, the subnumeration only
contains one element - the renumerated subject. In accord
with the requirement that a subnumeration be emptied (5c),the renumerated subject is Selected and Merged. Since thetree label v* initially contains an unvalued label feature ‘uD’
- the label remains v* (6c).
The v* subnumeration has been emptied, and so theSelector works on the next higher subnumeration (20).
(20) {[C*, [iTyp: , uT: , i+Force EPP:X, u+Scp EPP:X]],[T, PAST, [u+Case EPP:Nom, uPhi: , i+TNS:PST, uv*: ,uForce: ]]}The Selector chooses T in accord with (5b), since T contains
an unvalued ‘uv*: ’ feature. After Merge, the label is T due
to T’s unvalued label feature (6c). Next, there is a feature
valuation relation (7a) in which T’s unvalued ‘uPhi: ’ featurefunctions as a probe and Agrees with, and is valued by, thevalued ‘iPhi:X’ of the subject ‘John’. T also contains thefeature ‘u+Case EPP:Nom’, which is a ‘+Feat:X’ feature
with an EPP subfeature. The EPP subfeature prevents an
Agree relation alone from allowing this feature to value
a matching unvalued Case feature. In accord with (7b),9 The notion that Qu is responsible for clausal typing is discussed in [12],[13], among others. I posit the existence of a scope feature in C based on
the fact that CP is a projection where clauses obtain scope [14].

the EPP subfeature forces the subject, which contains amatching unvalued ‘Case: ’ feature, to leave a copy in its
base position and re-Merge with T. The label remains T,
in accord with (6d), since neither T nor the subject D
contains an unvalued label feature. Next, the phase head
C* is selected from the subnumeration, since it contains a‘uT: ’ feature (5b).
When C* is Merged, the lower v* phase must be sent
to Spell-Out, assuming that when a higher phase head is
Merged a lower phase is sent to Spell-Out (see section
II). Initially, there is a Last Resort Check operation (10);there is a search for an element in the lower v* phrasethat has an unvalued feature. Since Qu contains an unvalued‘iScp: ’ feature, Qu (along with its complement wh-phrase)is reinserted into the current subnumeration and a copy is left
in the base position. Next, there is a Crash Check operation(12) whereby there is a search for unvalued or unassigned
features. In this case, none are found (copies are not visible
to this operation) and the v* phrase is linearized. Each set
contained within v*, beginning with the most embeddedset, is linearized according to the algorithm in (13). First
Merge between a label LI and another LI results in thelabel occuring on the left, and any further Mergers (second
Merge) to the label result in the label occuring on theright. Phonological rules apply and the tree in Figure 1 is
produced, which is automatically drawn by the computer
program. Note that this tree contains linearized copies ofboth the subject ‘John’ and wh-phrase ‘what’. The line
through the v* edge signifies that the v* phrase has been
sent to Spell-Out. Uninterpretable features that have been
eliminated are preceded by the prefix ‘Chkd’.

Figure 1.

Linearized v* Phrase

The linearization process for the v* phrase is complete
and the derivation continues. The interrogative C* (see (20))
contains two ‘+Feat:X’ features that each contain an EPP
subfeature; a ‘i+Force EPP:X’ feature and a ‘u+Scp EPP:X’feature. The ‘+Force:X’ feature, a modified version of Force
proposed by [15], is associated with determining whether or
not a clause is matrix or embedded by matching an unvalued
feature in T, and the ‘+Scp’ feature of C* is associatedwith giving an element scope by valuing a matching Scopefeature, in this case on Qu. Initially, the ‘i+Force EPP:X’feature agrees with an unvalued matching ‘uForce ’ feature
on T and the EPP subfeature forces the matching LI, in thiscase T, to leave a copy in its base position and to re-Merge
with C*, following (7b), thus successfully modeling T to C
movement in English matrix interrogatives. This re-Merge
operation results in feature-checking of the Force featureand elimination of the EPP subfeature.10 Remember thatthe subnumeration now contains the Qu/wh-phrase ‘what’,
which was renumerated as a Last Resort. This LI is the only
element left in the subnumeration, and thus it is selected,
in accord with (5c). The label remains the same, C*, sinceneither of the Merged elements has an unvalued label feature(6d). After selection and Merge, feature checking results inthe ‘iScp: ’ feature of Qu being valued by the ‘uScp:X’ of
C*, thereby giving the Qu/wh-element scope. In addition,the ‘iTyp: ’ feature on C is valued by the ‘uTyp:Int’ on Qu,
thereby typing the clause as an interrogative.
The entire numeration is emptied and the Spell-Out operations (10-13) apply, followed by application of phonologicalrules, which result in T on C being pronounced as ‘did’, asshown in the final tree in Figure 2.

progress towards clarifying how Phase Theory works, andmakes progress towards discovering precisely how thehuman mind generates sentences.
ACKNOWLEDGMENT
I would like to thank Sandiway Fong, Simin Karimi, andthe three anonymous reviewers. All errors are my own.
R EFERENCES[1] N. Chomsky, Derivation by phase. MIT Working Papers in
Linguistics: MIT Occasional Papers in Linguistics Number
18, 1999.
[2] ——, “Minimalist inquiries: The framework,” in Step by step,R. Martin, D. Michaels, and J. Uriagereka, Eds. Cambridge,
MA: MIT Press, 2000, pp. 89–155.
[3] ——, “Beyond explanatory adequacy,” in Structures andbeyond: The cartography of syntactic structures, volume 3,
A. Belletti, Ed. Oxford, UK: Oxford University Press, 2004,
pp. 104–131.
[4] ——, “On phases,” in Foundational issues in linguistic theory; essays in honor of Jean-Roger Vergnaud, R. Freidin,
C. Otero, and M.-L. Zubizaretta, Eds. Cambridge, MA: MIT
Press, 2006, pp. 133–166.
[5] G. Grewendorf and J. Kremers, “Phases and cyclicity: Some
problems with phase theory,” The Linguistic Review, vol. 26,
pp. 385–430, 2009.
[6] K. Johnson, “Towards an etiology of adjunct islands,” Ms.,
University of Massachusetts at Amherst, 2002.
[7] C. Felser, “Wh-copying, phases, and successive cyclicity,”
Lingua, vol. 114, pp. 543–574, 2004.

Figure 2.

Linearized C* Phrase

IV. C ONCLUSION
I have demonstrated how this computational model
succesfully derives the syntactic representation of the
English wh-question (14). I leave for future work in depth
discussion of the many details of this model, as well as
its application to a variety of other examples in English
and other languages. Crucially, there are several ways inwhich this model helps to clarify our understanding of
how language is generated, from the perspective of Phase
Theory. This model a) provides a specific algorithm forselecting elements from a numeration/subnumeration, b)
provides a specific algorithm for determining the label ofa Merged syntactic object, c) incorporates a one-to-one
correspondence between phase-hood and the timing of
Spell-Out, and d) eliminates the need for superfluous EPP
features - via a Last Resort process. This model thus make10 I assume that the interrogative C* contains a ‘[+Scp EPP:X]’ withan EPP subfeature in order to account for local movement of subject whphrases, which due to their close proximity to C*, cannot result from theLast Resort process.

[8] N. Chomsky, “Bare phrase structure,” in Evolution and revolution in linguistic theory, H. Campos and P. Kempchinsky,
Eds. Washington, D.C.: Georgetown University Press, 1995,
pp. 51–109.
[9] ——, The Minimalist Program. Cambridge, MA: MIT Press,
1995.
[10] D. Pesetsky and E. Torrego, “T-to-C movement: Causes andconsequences,” in Ken Hale: A life in language, M. Kenstowicz, Ed. Cambridge, MA: MIT Press, 2001, pp. 355–426.
[11] S. Cable, “The grammar of Q: Q-particles and the natureof Wh-fronting, as revealed by the wh-questions of Tlingit,”
Ph.D. dissertation, Massachusetts Institute of Technology,
2007.
[12] J. Katz and P. Postal, An integrated theory of linguistic
descriptions. Cambridge, MA: MIT Press, 1964.
[13] J. Aoun and Y. Li, “Wh-elements in situ: Syntax or LF,”
Linguistic Inquiry, vol. 24, pp. 199–238, 1993.
[14] R. May, Logical Form.

Cambridge, MA: MIT Press, 1985.

[15] L. Rizzi, “The fine structure of the left periphery,” in Elementsof grammar, L. Haegeman, Ed. Dordrecht: Kluwer, 1997,
pp. 281–337.