Minimalist Machine Derivations

Minimalist Machine Derivations

Files: grammar.pl / m12.pl / Back to homepage

Examples:

Examples from A New Approach to Tough-Constructions (Fong & Ginsburg, 2014).
Doubling Constituent (DC) approach. collapse

Example	Instruction stream (clickable)	Notes
(1) John is easy to please	[john, d, pro, please, 'v*', ['PRO', d0], 'Tinf', c, easy, v_be, 'T', c]	Doubling Constituent (DC) pro-John. At the Local Extent (LE) boundary, the embedded CP, John (with unvalued uCase) is re-stacked. T picks up TOS John.
(2) The violin is easy to play the sonata on	[violin, the, pro, on, [sonata, the], play, 'v*', ['PRO', d0], 'Tinf', c, easy, v_be, 'T', c]	DC pro-the-violin. At the LE boundary, the embedded CP, the violin (with unvalued uCase) is re-stacked. Matrix T picks up TOS the violin.
(3) *What sonata is the violin easy to play on?	[violin, the, pro, on, [sonata, what:d], play, 'v*', ['PRO', d0], 'Tinf', c, easy, v_be, 'T', c_Q]	Does not converge. DC pro-the-violin. what sonata is stacked (uScope). At the LE boundary, the embedded CP, what sonata (unvalued uScope) and the violin (unvalued uCase) are re-stacked. Matrix T fails to agree with TOS what sonata: nom Case clashes with acc Case assigned by embedded v*.
(4) The sonata is easy to play on this violin	[violin, this, on, [sonata, the, pro], play, 'v*', ['PRO', d0], 'Tinf', c, easy, v_be, 'T', c]	DC pro-the-sonata. At the LE boundary, the embedded CP, the sonata (unvalued uCase) is restacked. Matrix T picks up TOS the sonata.
(5) What violin is the sonata easy to play on?	[violin, what:d, on, [sonata, the, pro], play, 'v*', ['PRO', d0], 'Tinf', c, easy, v_be, 'T', c_Q]	DC pro-the-sonata. what violin is stacked (uScope). At the LE boundary, the embedded CP, the sonata (unvalued uCase) and what violin (unvalued uScope) are restacked. Matrix T picks up TOS the sonata. c_Q finds iWh what violin.
(6) Linguists are tough to please	[linguists, d, pro, please, 'v*', ['PRO', d0], 'Tinf', c, tough, v_be, 'T', c]	(Same as (1).) DC pro-linguists. At the LE boundary, the embedded CP, linguists (with unvalued uCase) is re-stacked. T picks up TOS linguists.
(7) It is tough to please linguists	[linguists, d, please,'v*', ['PRO', d0], 'Tinf', c, tough, v_be, it, 'T', c]	v* assigns Case to linguists. (No restacking is done at the LE boundary, the embedded CP.) Expletive it merge to the edge of v_be. Agree(matrix T,it) obtains.
(8) The book is easy to put on the table	[table, the, on, [book, the, pro], put, 'v*', ['PRO', d0], 'Tinf', c, easy, 'v_be', 'T', c]	(Same as (4).) DC pro-the-book. At the LE boundary, the embedded CP, the book (unvalued uCase) is restacked. Matrix T picks up TOS the book.
(9) What table is the book easy to put on?	[table, what:d, on, [book, the, pro], put, 'v*', ['PRO', d0], 'Tinf', c, easy, 'v_be', 'T', c_Q]	(Same as (5).) what table is stacked (uScope). DC pro-the-book. At the LE boundary, the embedded CP, the book (unvalued uCase) and what table (unvalued uScope) are restacked. Matrix T picks up TOS the book. c_Q finds iWh what table.

Machine Parameters: expand

Animation:
(7) It is tough to please linguists

Derivation:
(7) It is tough to please linguists

Stream:	[[linguists!D],[d!case!N],[please],[v*!phi],[[PRO!D],[d0!case!N]],[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):
SO:	[]

Step 1.

Head of stream [linguists!D] is the initial SO

Stream:	[[d!case!N],[please],[v*!phi],[[PRO!D],[d0!case!N]],[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):
SO:	[linguists!D]

Step 2.

Merge [d!case!N] and [linguists!D]

Label from [d!case!N] (head with an unvalued uF)

Inherit interpretable feature(s) [f(phi,[3,pl,n])] from [linguists!D]

[d!case!N] values D on [linguists!D]

[linguists] values N on [d!case!N]

Stream:	[[please],[v*!phi],[[PRO!D],[d0!case!N]],[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):
SO:	[d!case[d][linguists]]

Step 3.

Merge [please] and [d!case[d][linguists]]

Label from [please] (head merging with a non-head)

Theta-mark [d!case[d][linguists]]

Push [d!case[d][linguists]] (unvalued uF) onto stack

Stream:	[[v*!phi],[[PRO!D],[d0!case!N]],[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d!case[d][linguists]]
SO:	[please[please][d!case[d][linguists]]]

Step 4.

Merge [v*!phi] and [please[please][d!case[d..][linguists..]]]

Label from [v*!phi] (head merging with a non-head)

[d!case[d][linguists]] values uPhi on [v*!phi]

[v*] values acc case on [d!case[d][linguists]]

Stream:	[[[PRO!D],[d0!case!N]],[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d[d][linguists]]
SO:	[v[v][please[please][d[d][linguists]]]]

Step 5.

Begin substream

Stream:	[[PRO!D],[d0!case!N]]
Stack (⥥):
SO:	[]

Step 6.

Head of stream [PRO!D] is the initial SO

Stream:	[[d0!case!N]]
Stack (⥥):
SO:	[PRO!D]

Step 7.

Merge [d0!case!N] and [PRO!D]

Label from [d0!case!N] (head with an unvalued uF)

Inherit interpretable feature(s) [f(phi,[3,sg,n])] from [PRO!D]

[d0!case!N] values D on [PRO!D]

[PRO] values N on [d0!case!N]

Stream:	[]
Stack (⥥):
SO:	[d0!case[d0][PRO]]

End substream, SO [d0!case[d0][PRO]] re-inserted into main stream

Step 8.

Stream:	[[d0!case[d0][PRO]],[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d[d][linguists]]
SO:	[v[v][please[please][d[d][linguists]]]]

Step 9.

Merge [v*[v*][please[please..][d..]]] and [d0!case[d0][PRO]]

Label from [v*[v*][please[please..][d..]]] (edge feature)

Theta-mark [d0!case[d0][PRO]]

Push [d0!case[d0][PRO]] (unvalued uF) onto stack

Stream:	[[Tinf!phi],[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d0!case[d0][PRO]] [d[d][linguists]]
SO:	[v[d0!case[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]

Step 10.

Merge [Tinf!phi] and [v*[d0!case[d0..][PRO..]][v*[v*..][please..]]]

Label from [Tinf!phi] (head merging with a non-head)

[d0!case[d0][PRO]] values uPhi on [Tinf!phi]

[Tinf] values nullCase case on [d0[d0][PRO]]

Stream:	[[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d0[d0][PRO]] [d[d][linguists]]
SO:	[Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]

Step 11.

Internal merge selected

Merge [Tinf[Tinf][v*[d0..][v*..]]] and [d0[d0][PRO]]

Label from [Tinf[Tinf][v*[d0..][v*..]]] (edge feature)

Stream:	[[c],[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d0[d0][PRO]] [d[d][linguists]]
SO:	[Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]

Step 12.

Merge [c] and [Tinf[d0[d0..][PRO..]][Tinf[Tinf..][v*..]]]

Label from [c] (head merging with a non-head)

Stream:	[[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	[d0[d0][PRO]] [d[d][linguists]]
SO:	[c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]

Step 13.

Local Extent boundary at [c[c][Tinf[d0..][Tinf..]]]

New boundary (b) marker stacked

Stream:	[[tough],[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	b [d0[d0][PRO]] [d[d][linguists]]
SO:	[c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]

Step 14.

Merge [tough] and [c[c][Tinf[d0..][Tinf..]]]

Label from [tough] (head merging with a non-head)

Stream:	[[v_be],[it!case],[T!phi],[c]]
Stack (⥥):	b [d0[d0][PRO]] [d[d][linguists]]
SO:	[tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]

Step 15.

Merge [v_be] and [tough[tough][c[c..][Tinf..]]]

Label from [v_be] (head merging with a non-head)

Stream:	[[it!case],[T!phi],[c]]
Stack (⥥):	b [d0[d0][PRO]] [d[d][linguists]]
SO:	[v_be[v_be][tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]]

Step 16.

Merge [v_be[v_be][tough[tough..][c..]]] and [it!case]

Label from [v_be[v_be][tough[tough..][c..]]] (edge feature)

Push [it!case] (unvalued uF) onto stack

Stream:	[[T!phi],[c]]
Stack (⥥):	[it!case] b [d0[d0][PRO]] [d[d][linguists]]
SO:	[v_be[it!case][v_be[v_be][tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]]]

Step 17.

Merge [T!phi] and [v_be[it!case][v_be[v_be..][tough..]]]

Label from [T!phi] (head merging with a non-head)

[it!case] values uPhi on [T!phi]

[T] values nom case on [it!case]

Stream:	[[c]]
Stack (⥥):	[it] b [d0[d0][PRO]] [d[d][linguists]]
SO:	[T[T][v_be[it][v_be[v_be][tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]]]]

Step 18.

Internal merge selected

Merge [T[T][v_be[it..][v_be..]]] and [it]

Label from [T[T][v_be[it..][v_be..]]] (edge feature)

Stream:	[[c]]
Stack (⥥):	[it] b [d0[d0][PRO]] [d[d][linguists]]
SO:	[T[it][T[T][v_be[it][v_be[v_be][tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]]]]]

Step 19.

Merge [c] and [T[it][T[T..][v_be..]]]

Label from [c] (head merging with a non-head)

Stream:	[]
Stack (⥥):	[it] b [d0[d0][PRO]] [d[d][linguists]]
SO:	[c[c][T[it][T[T][v_be[it][v_be[v_be][tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]]]]]]

Step 20.

Local Extent boundary at [c[c][T[it..][T..]]]

New boundary (b) marker stacked

Stream:	[]
Stack (⥥):	b [it] b [d0[d0][PRO]] [d[d][linguists]]
SO:	[c[c][T[it][T[T][v_be[it][v_be[v_be][tough[tough][c[c][Tinf[d0[d0][PRO]][Tinf[Tinf][v[d0[d0][PRO]][v[v*][please[please][d[d][linguists]]]]]]]]]]]]]]

Parse:

Spell-out:

it -s be tough to please -acc linguists (after morpheme realization)

it be -s tough to please linguists -acc (after affix-hop)

it be -s tough to please linguists -acc (after morpheme realization, stage 2)

it is tough to please linguists

One derivation found.

Computational Cost:

Merge: 14, Agree: 10, Unify: 0, Push: 3, Boundaries: 2, Inject: 0

Non-TOS access: 0, Pop: 0, Depth cost: 26

Step:	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
Stack depth:	0	0	0	1	1	0	0	0	1	2	2	2	2	3	3	3	4	4	4	4	5