Dynamic Syntax Trees

DYNAMIC SYNTAX 152900093

ASSIGNMENT 1

Submitted By: Darshita Shah (537969)

Submitted To: Hannah Gibson

Due Date: 24/02/2014

Joel helped Miriam, who he knows dislikes syntax.

Dynamic Syntax (DS) claims that humans’ knowledge of language is essentially their

ability to parse spoken language. It is a formal model designed to capture, how a

listener interprets spoken language step by step. DS illustrates the parsing in human

brain, through tree structures and shows how a hearer progressively builds

semantic representation from lexical and contextual information. The tree structure

grows, as each word is parsed. The steps by which, we reach the final output, i.e. the

final tree, are as important as the final tree in DS.

IN DS each derivation begins with an axiom, which represents the goal to build a

tree with propositional content and reflects the hearer’s expectation to derive a

proposition (Cann et al. 2005). The type of expression is its semantic category,

associating an expression with a particular sort of denotation. This is indicated by a

Type label – Ty(x). A proposition is of type t. Thus, tree building begins with a

requirement, indicated by a question mark, to derive an expression of type t. (Cann,

et al. 2005: 35)

(1) Tn(0),?Ty(t), ◊

The pointer (◊) in (1) indicates the current node, which is under development. Tn is

the label for a tree node. It is the mean by which the address of a node is given. The

Tn address gives a node a definite position in the tree. Nodes in a tree may be

identified by a numerical index ranging over 0 and 1 ( Cann et al. 2005: 38). The

address of the current root node is Tn(0). In a DS tree, the daughter on the left hand

side is decorated with an argument formula, and daughter node on the right is

decorated with a functor formula. The value of any argument daughter is ‘0’

appended to the Tn value of its mother. And the value of any functor daughter is ‘1’

appended to the Tn value of its mother. Thus, the address of the root node’s

argument daughter is ‘00’ and its functor daughter is ‘01’.

(2) INTRODUCTION

{…{…? Ty (Y) …◊}…}

{…{…?Ty(Y),? <↓0> Ty(X), ? <↓1> Ty (X → Y),…◊}…}

The Introduction rule, adds requirement for an argument and functor daughter

decorated with expressions of a certain type, which combined can give the

expression required by the original goal. <↑> ,<↓> are basic modalities, <↓>

corresponding to the daughter relation ‘down’ and <↑> corresponding to the

mother relationship ‘up’. In the rule given above, <↓0> indicates an immediately

dominated node on the left-‐hand side, the argument daughter and <↓1> indicates an

immediately dominated note on the right hand side, the functor daughter. After

applying the introduction rule we get:

(3) Tn(0),?Ty(t), ?<↓0>Ty(e),?<↓1> Ty( e → t), ◊

The tree in (3) has not actually grown the daughter nodes, it has merely acquired

requirements to have such nodes. Hence, the tree or the input consists of only one

node. An expression of type e is a term that denotes some entity. The functor type is

expressed as (e → t), which denotes that it is a one-‐place predicate and when

combined with a term e, it yields a proposition type t. Next, the rule of Prediction is

applied, which builds the required nodes and leave the pointer at the argument

node.

(4) PREDICTION

{Tn(n),…,?<↓0>φ,?<↓1>ψ,◊}

{Tn(n),…? <↓0>φ,?<↓1>ψ}, {<↑0>Tn(n),?φ,◊}{<↑1>Tn(n),?ψ}

(4a) Tn(0),?Ty(t),?<↓0>Tye(e), ?<↓1> Ty (e → t)

Tn(00), ?Ty(e), ◊ Tn(01), ?Ty (e → t)

Note that instead of using the modalities <↓0 ,↓1> in the daughter nodes, in (4a), I am

using the Tn to identify a node by its numerical index (Tn(00), Tn(01)). Thus

introduction licenses the introduction of modal requirements and prediction

transforms them into non-‐modal type requirement, by constructing the appropriate

nodes. These rules are the most general rules to unfold tree structure (Cann et al.

2005:43).

Next we need information from the lexicon to continue with the parsing process.

Lexical items provide information about node annotation and give tree building

instructions. Once the hearer encounters Joel, he scans the lexical information

provided by the expression and adds it into the derivation. Lexical entries in DS are

represented as conditional statements (Cann et al. 2005: 45). IF introduces the

requirements. If the requirement is true, further instructions are given by THEN. If

either the IF and THEN are false, than ELSE specifies what to do next. If ELSE gives

the ABORT instruction, then the parse fails and stops there. The consequent of the

initial condition ‘make’ gives instruction to make new nodes, ‘go’ moves the pointer

to the node specified in the value and ‘put’ annotates a node with certain

information (Canne et. al. 2005:45). The lexical entry for Joel is given in (5):

(5) Joel IF ?Ty(e)

THEN put (Ty(e),Fo(Joel’),[↓]⊥)

ELSE ABORT

Proper name in DS are of type (e) and are required to be a current requirement

?Ty(e) at the stage at which lexical entry is scanned. The pointer was left at the

argument node in (4a) which holds a requirement for Ty(e), after we applied

introduction and prediction rules. Therefore, the condition imposed by lexical entry

for Joel is satisfied and the node is decorated with Ty(e),Fo(Joel’) and the bottom

restriction [↓]⊥. The bottom restrictions indicate that the word decorates a terminal

node, which means that the current node has and will have no daughters with any

properties at all (Cann et al. 2005:46). If at the current node, there was no

requirement for a Ty(e), the phrase would have been Aborted. Following is the

resulting tree structure:

(6) Tn(0),?Ty(t), ?<↓0>Ty(e), ? <↓1> Ty(e→t)

Tn(00), ?Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥,◊

In (6) we see that the current node has both the fact and the requirement to fulfill

the fact. Thus, we apply ‘Thinning’ rule, which eliminates the fulfilled requirement

(Cann et. al. 2005:49).

(7) THINNING

{…{…,φ…,?φ,…,◊}…}

{…{…,φ,…,◊}…}

After applying Thinning we get:

(7a) Tn(0),?Ty(t), ?<↓0>Ty(e), ? <↓1> Ty(e→t)

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥,◊

Now the ‘Completion’ rule moves the pointer up to the mother node and annotates it

with the information that it has a daughter of a certain type.

(8) COMPLETION

{Tn(n)…}, {<↑i>Tn(n),…, Ty(X), …,◊ }

{Tn (n),….<↓i>Ty(X),…, ◊}, { }

i ∈ {0,1 *}

When we apply the completion rule, we get the structure in (8a). In the root note,

the decoration <↓0> Ty(e) is added, which shows us that this node has an argument

daughter of type e.

(8a) Tn(0), ?Ty(t), ? <↓0>Ty(e), <↓0> Ty(e),? <↓1> Ty(e→t), ◊

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥

Now the requirement, that there is an argument daughter of Type e is fulfilled. We

again apply the Thinning rule and get the following structure:

(8b) Tn(0), ?Ty(t), ? <↓0>Ty(e),? <↓1> Ty(e→t), ◊

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥

“The Anticipation rule moves the pointer down from a mother node to a daughter

node which has an outstanding requirement.” (Cann et al. 2005:51)

(9) ANTICIPATION

{Tn(n),…,◊},{<↑>Tn(n),…,?φ…}

{Tn(n),…{ <↑>Tn(n),…,?φ…},…,◊}

(9a) Tn(0), ?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t)

Tn(00), Ty (e) Tn(01), ?Ty (e→t), ◊

Ty (e), Fo (Joel’), [↓]⊥

Now that the pointer has been moved by the anticipation rule, to a node decorated

with requirement type (e→t). Thus, now its time to parse helped. Below is the lexical

entry for help.

(10)

help IF ?Ty (e→t)

THEN go(<↑1>?Ty(t)),

put (Tns(PAST)),

go(<↓>?Ty(e→t)),

make (<↓1>),

put (Fo(help’), Ty(e→(e→t), [↓]⊥;

go(<↑1>);

make (<↓0>);

go (<↓0>);

put(?Ty(e))

ELSE ABORT

In (9a) the pointer is at a node decorated with a requirement for Ty (e→t) and thus

the condition imposed by the lexical entry of the verb help is satisfied. As a result,

the pointer is instructed to go up a functor relation to the node which holds a

requirement for an expression of Ty(t) and decorate it with tense. Then the pointer

is instructed to go down the same relation, build a new functor node from there and

annotate it with the specified formula, type values and the bottom restriction. Now

the pointer is instructed to go up that functor relation and build from there a new

argument node, decorated with a requirement for Ty(e). This is where the pointer is

left after parsing helped. Next, this transitive verb builds two nodes, one for a two

place predicate and other node for the internal argument. This is illustrated in the

following tree:

(10a) Tn(0), ?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t),Tns (PAST)

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)

Tn(010)?Ty(e), ◊ Tn(011),Ty (e→(e→t), Fo(help’), [↓]⊥

The pointer is at the argument node, decorated with Ty(e), thus, another proper

name – Miriam, can be parsed. Miriam has the same lexical entry as Joel and the

same instructions are followed. After the lexical entry is parsed, we decorate the

node with the information provided by the lexical entry and next we apply Thinning

again to eliminate the fulfilled requirement.

(11) Miriam IF ?Ty(e)

THEN put (Ty(e),Fo(Miriam’),[↓]⊥)

ELSE ABORT


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)

Tn(010),Ty(e), Tn(011),Ty (e→(e→t), Fo(help’), [↓]⊥

Fo(Miriam’), [↓]⊥,◊

According to our sentence Joel helped Miriam who he knows dislikes syntax, next the

relative pronoun who is encountered. In DS, when the pointer encounters a relative

pronoun, a new tree is constructed and node of the host tree is linked to the root

node of the second tree. This linking is done through a Link relation <L> and its

inverse <L-‐1>, introduced by the rule of Link Adjunction.

(12) LINK ADJUNCTION

{…{Tn(α),Fo(A),Ty(e), ◊}…}

{…{Tn(α),Fo(α),Te(e)}…}, {<L-‐1>Tn(α),?Ty(t), ?<↓*>Fo(α),◊}…}

This rule specifies that the linked node consists of three decorations: < L-‐1>, which

expresses that it is an inverse link relation to the head, which is indicated by the Tn

value; it is annotated with a requirement for propositional content -‐ ?Ty(t);

?<↓*>Fo(α) expresses that within the link structure there should be somewhere

down a copy of the formula that decorates the head node, from which the head

structure is built. Thus, encountering who, makes us build a link node and moves the

pointer to that node.


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)


Fo(Miriam’), [↓]⊥

<L-‐1>Tn(010),Ty(t),? <↓*>For(Miriam’), ◊

Now the *Adjunction rule is applied, which introduces an unfixed node and leaves

the pointer there. The unfixed node cannot remain unfixed, so to find a fixed

position, it is decorated by the requirement ?∃x.Tn(x). We apply this rule right after

building a linked node to reflect the expectation to find a copy of the formula

somewhere within the tree. Following is the *Adjunction rule and (13a) is the

structure, the rule leaves us with.

(13) *ADJUNCTION RULE:

{…{Tn(α),...,?Ty(t), ◊}…}

{…{Tn(α),…,Te(t)}…}, {<↑*>Tn(α),?∃x.Tn(x),…,?Ty(e),◊}…}


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t),? <↓*>Fo(Miriam’)

<↑*><L-‐1>Tn(010), ? ∃x.Tn(x),?Ty(e), ◊

Now we can parse who. And to do so, we first provide the lexical entry for the relative pronoun who.

(14)

whorel IF ?Ty(e),∃x.Tn(x),

<↑*><L-‐1>Fo(x)

THEN IF

THEN

ELSE

↑⊥

ABORT

Put(Fo(x),Ty(e), [↓]⊥

ELSE ABORT

The conditional statement in the lexical entry states that up the unfixed node there

is a LINK relation defined to some node decorated by a formula Fo(x), if however the

pointer is at a fixed node (↑⊥), then the parse fails, if not, then a copy of the formula

needs to be provided for the current node and ty(e) and [↓]⊥ need to be annotated.

Thinning also applies and we get the following tree structure:


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t),? <↓*>Fo(Miriam’)

<↑*><L-‐1>Tn(010), ? ∃x.Tn(x),?Ty(e), Fo(Miriam’)◊

Next Completion, introduction and prediction is applied and we get the following:

(14b) Tn(0), ?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t),Tns (PAST)

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t),? <↓*>Fo(Miriam’)

<↑*><L-‐1>Tn(010), ?Ty(e), ◊ ?Ty(e→t)

? ∃x.Tn(x),?Ty(e),


Next, the pronoun he has to be parsed. DS claims that pronouns are placeholders for

a logical expression constructed within the context of the utterance (Cann et al.

2005:68). A Pronoun’s Fo value is indicated by a metavariable, which is latere

replaced by Substitution with a comparative Fo value from the context (Cann et al.

2005:69).

(15)

he IF ?Ty (e)

THEN put (Ty(e),

Fo(Umale’),

? ∃x.Fo(x),

?<↑0>(Ty(t)∧∃x.Tns(x)),

[↓]⊥)

ELSE ABORT

The lexical rule decorates the node with ? ∃x.Fo(x), a requirement to find the

formula value and ?<↑0>(Ty(t)∧∃x.Tns(x)) to indicate the case condition. After

parsing the decorations as instructed in the lexical entry for he and applying

Thinning we get (15a):


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t),? <↓*>Fo(Miriam’)

<↑*><L-‐1>Tn(010), Ty(e) ?Ty(e→t)

? ∃x.Tn(x),?Ty(e), Fo(Umale’)

Fo(Miriam’), [↓]⊥ ? ∃x.Fo(x),

[↓]⊥,◊

Next, we apply Substitution. The metavariable will be substituted with Joel’ as it is

the only compatible Fo value satisfying male’ presupposition. After substituting the

metavariable, the value of Fo(Joel’) allows the requirement ? ∃x.Fo(x) to be thinned.


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t),? <↓*>Fo(Miriam’)

<↑*><L-‐1>Tn(010), Ty(e) ?Ty(e→t)

? ∃x.Tn(x),?Ty(e), Fo(Joel’),

Fo(Miriam’), [↓]⊥ [↓]⊥,◊

Next the pointer will move to the functor node through Completion and

Anticipation. Thus, we can parse knows. The verb to know can either take an

expression of Ty(e) (Joel knows him/John), or it can take an expression of Ty(t) (Joel

knows she dislikes syntax). For this assignment, the second type (Ty(t)) is the

relevant one, thus only lexical entry for know with expression of Ty(t) will be

provided.

(16)

know IF ?Ty (e→t)

THEN go(<↑1>?Ty(t));

put(Tns(Pres));

go(<↓0>?Ty(e→t));

make(<↓1 >),fo(<↓1>);

put(Ty(t→( e→t)),Fo(know’), [↓]⊥)

go(<↑1>);

make(<↓0>);

go(<↓1>);

put(?Ty(t))

ELSE ABORT

The verb know takes as its object an expression of Ty(t). It builds an argument

daughter of type t and a functor daughter of type (t→( e→t)). When both the

argument daughter and the functor daughter come together, we get an expression of

ty(e→t) . Thus, satisfying the requirement present for the verb know of ty(t). After

parsing know, the pointer is left at the argument daughter holding a requirement

type (t). Then, Introduction and Prediction are applied once again leaving the

pointer at a node with a requirement for type e.


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t), <↓0>Ty(e),? <↓*>Fo(Miriam’), Tns(PRES)

<↑*><L-‐1>Tn(010), Ty(e) ?Ty(e→t)

? ∃x.Tn(x),?Ty(e), Fo(Joel’),

Fo(Miriam’), [↓]⊥ [↓]⊥

?ty(t), Ty(t→( e→t))

?<↓0>Ty(e) Fo(know’), [↓]⊥

? <↓1> ty(e→t),

?Ty(e), ◊ ?Ty(e→t)

The requirement for a Ty(e) at the current node matches the type of the unfixed

node and hence they both can be merged. Thinning is applied after the unification of

two nodes ({<↑*><L-‐1>Tn(010) ? ∃x.Tn(x),?Ty(e)Fo(Miriam’), [↓]⊥, ?Ty(e)}).

Thinning eliminates the type requirement and also removes the requirement, which

was first needed to find a fixed position, as it is currently at a position with defined

position in the tree. The Tree after Merge and Thinning is shown in (17).

(17) Tn(0), ?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t),Tns (PAST)

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)




Ty(e) ?Ty(e→t)

Fo(Joel’), [↓]⊥


?<↓0>Ty(e) Fo(know’), [↓]⊥

? <↓1> Ty(e→t),

<↑*><L-‐1>Tn(010) ?Ty(e→t)

?Ty(e),Fo(Miriam’), [↓]⊥, ◊

Next Completion is applied and the pointer moves up to the mother node and

Annotates the node that it has a daughter of Ty(e). Thinning then removes the

fulfilled requirement and through Anticipation the pointer moves down to the

daughter with an outstanding requirement. Now, dislikes is parsed. Below (18) is the

lexical entry for dislike.

(18)

dislike IF ?Ty (e→t)

THEN go(<↑1>);

put(Tns(Pres));

go(<↓1>);

make(<↓1 >);

put (Fo(know’),(Ty(e→( e→t)), [↓]⊥)

go(<↑1>);

make(<↓0>);

go(<↓0>);

put(?Ty(e))

ELSE ABORT

The pointer is now at a node, that holds a requirement for Ty(e→t). After the lexical

entry for dislike is given, a series of actions take place mentioned in the lexical entry.

A functor daughter is built and annotated with Fo, Ty values and the bottom

restriction. Also and argument daughter is built and decorated with a requirement

for ty(e) where the pointer is left. The tree is illustrated in (18a)


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)




Ty(e) ?Ty(e→t)



<↓0>Ty(e),Tns(Pres) Fo(know’), [↓]⊥

? <↓1> Ty(e→t),

<↑*><L-‐1>Tn(010) ?Ty(e→t)

Ty(e),Fo(Miriam’), [↓]⊥

?Ty(e), ◊ Fo(dislike’), Ty(e→(e→t)), [↓]⊥

Now lexical entry for Syntax is parsed (19). Then information from the lexicon is

added to the tree (19a)and Thinning and Completion apply.

(19) Syntax IF ?Ty(e)

THEN put (Ty(e),Fo(syntax’),[↓]⊥)

ELSE ABORT


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)




Ty(e) ?Ty(e→t)




? <↓1> Ty(e→t),

<↑*><L-‐1>Tn(010) ?Ty(e→t), <↓0>Ty(e), ◊


Ty(e), Fo(syntax’), [↓]⊥ Fo(dislike’), Ty(e→(e→t)), [↓]⊥

Next Elimination takes place. Elimination rule takes the information from the two

daughters of a mother node, performs functional application and annotates the

mother with the result in (20a) (Cann et al. 20005:45).

(20) ELIMINATION

{…<↓0>(Fo(α),Ty(Y)), <↓1>(Fo(β),Ty(Y→X)),…, ◊ }

{...Fo(β(α)),Ty(X), <↓0>(Fo(α),Ty(Y)), <↓0>(Fo(β),Ty(Y→X)),…, ◊ }


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)




Ty(e) ?Ty(e→t)


?Ty(t), Ty(t→( e→t))


? <↓1> Ty(e→t),

<↑*><L-‐1>Tn(010) ?Ty(e→t), Ty(e→t),Fo(dilsike’(syntax)), ◊



In (20a), where the pointer is, at that node the requirement for a Ty (e→t) is

satisfied and Thinning can be applied followed by Completion, Elimination and

Thinning again. Thus we get the following tree in (21) after we go through all the

steps mentioned above, we reach up until the top of the linked tree.

(21) Tn(0), ?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t),Tns (PAST)

Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)



<L-‐1>Tn(010),Ty(t), <↓0>Ty(e), <↓1>Ty(e→t),? <↓*>Fo(Miriam’), Tns(PRES),

Fo (know’(dislike’(syntax’)(Miriam’)(Joel’)), ◊

Ty(e) Ty(e→t),<↓1>Ty( t→( e→t)),< ↓0>Ty(t),

Fo(Joel’), [↓]⊥ Fo(know’(dislike’(syntax’)(Miriam’))

Ty(t), Ty(t→( e→t))


<↓1> Ty(e→t), Fo(dislike’(syntax’)(Miriam’)

<↑*><L-‐1>Tn(010) Ty(e→t), Ty(e→t),Fo(dilsike’(syntax))



Through a revised rule of completion, the pointer can be moved back to the head

node allowing for the host tree to be completed.

(22) COMPLETION (Revised)

{…{Tn(n)…}, {µ-‐1} Tn(n),…,Ty(X),…,◊}…}

{…{Tn(n),…,<µ>Ty(X),…,◊},{< µ-‐1>Tn(n),…,Ty(X),…,}…}

µ-‐1 ∈ {↑0, ↑1, ↑*, L-‐1} µ ∈ { ↓0, ↓1, ↓*, L}


Tn(00), Ty (e) Tn(01), ?Ty (e→t)

Ty (e), Fo (Joel’), [↓]⊥)


Fo(Miriam’), [↓]⊥,◊

<L-‐1>Tn(010),Ty(t), <↓0>Ty(e), <↓1>Ty(e→t),<↓*>Fo(Miriam’), Tns(PRES),

Fo (know’(dislike’(syntax’)(Miriam’)(Joel’))









We again apply Completion, Elimination and Thinning and make our way up to the

root node in (23)

(23) Tn(0),?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t),Tns (PAST),Fo(help’(Miriam’)(Joel’)), ◊

Tn(00), Ty (e) Tn(01), ?Ty (e→t), <↓0>ty(e),Fo(help’(Miriam’))

Ty (e), Fo (Joel’), [↓]⊥)













Next we apply Link Evaluation rule. This rule conjuncts the Fo value of the

propositional tree (Tn(0)) and the Fo value of the propositional structure linked to

the Tn(010) node.

(24) LINK EVALUATION1 (Non-‐restrictive construal)

{…(Tn(α),Fo(φ),Ty(t),◊}},{<L-‐1>MOD(Tn(α)),…Fo(ψ),Ty(t)}

{…{Tn(α),…,Fo(φ ∧ ψ),Ty(t), ◊}}, {< L-‐1>MOD(Tn(α)),…,Fo(ψ),Ty(t)}

MOD ∈ {<↑0>, <↑0>}*

With this final rule, it is now possible to express the content of Joel helped Miriam,

who he knows dislikes syntax as a conjunction of the propositional formulae (25).

(25) Tn(0),?Ty(t), <↓0>Ty(e),? <↓1> Ty(e→t),Tns (PAST),

Fo(help’(Miriam’)(Joel’))∧ know’(dislike’(syntax’)(Miriam’)(Joel’)), ◊

Tn(00), Ty (e) Tn(01), ?Ty (e→t), <↓0>ty(e),Fo(help’(Miriam’))

Ty (e), Fo (Joel’), [↓]⊥)













BIBLIOGRAPHY:

• Cann, R, Kempson, R & Marten, L (2005). The Dynamics of Language. Oxford: Elsevier.

Documents

Dynamic Syntax Trees