Constructive Dynamic Syntax

Abstract

This paper explores the integration of constructive type theory in the tradition of Martin Löf into Dynamic Syntax.

1. Introduction

Dynamic Syntax (DS) is a parsing oriented framework where syntax can be seen as the progressive growth of transparent semantic representations (Cann et al., 2005; Kempson et al., 2001). DS has been used in a variety of ways and has proven itself versatile enough to handle issues as diverse as morphosyntactic puzzles (Bouzouita, 2008; Chatzikyriakidis, 2010; Chatzikyriakidis & Kempson, 2011) and language variation all the way to ellipsis (Eshghi et al., 2015; Gregoromichelaki et al., 2011; Kempson et al., 2015, 2018) and full-blown dialogue modeling (Eshghi et al., 2012; Gregoromichelaki et al., 2011; Howes & Eshghi, 2017; Kempson et al., 2016; Purver et al., 2010). The original DS system had the ability to produce semantic representations in a logical language, which was based, in a number of ways, on Montagovian Semantics (Gallin, 2011; Montague, 1970), albeit with a twist. DS kept the simple-typed system found in Montague, included an extra type for situations (no intensional types are used in DS), but, most importantly, used the epsilon calculus for quantification (Cann et al., 2005; Kempson et al., 2001), a conscious move that enables all arguments to have lower types. The semantic bone of DS is totally orthogonal to the actual ACTION calculus, i.e., the mechanism that builds and populates binary trees, moves or halts the parsing process, checks the triggering points of lexical entries and accordingly allows these to be fired or not. In this sense, one can very well envision DS versions that encode different types of semantics. Indeed, this has already been tried out with both Cooper’s Type Theory with Records Cooper (2005, 2012); Eshghi et al. (2012); Purver et al. (2010); Ranta and Cooper (2004), as well as vector-based semantics Purver et al. (2021); Sadrzadeh et al. (2018).

In this paper, I attempt an integration of constructive, dependent type semantics in DS. I will present some potential benefits including type many-sortedness and the use of dependent typing, discussing two main test cases, quantification and modification. With regard to the first, I will present an account where existential quantification is captured using $\mathrm{\Sigma }$ types, where the first projection coercion of the construction allows us to keep the lower type e, while for universal quantification using $\mathrm{\Pi }$, the quantifier is seen as a polymorphic functor over A predicates. Lastly, I discuss modification in DS, showing that some first steps towards a more general account of modification in DS can be proposed.

2. Why Martin-Löf’s Type Theories?

I argue that there are at least two good reasons that one would choose Martin-Löf type theories (MLTT) over mainstream Montagovian semantics:

• Expressivity;
• Solid proof-theoretic underpinnings.

The former refers to the rigidity of simple type theory mainly used in mainstream semantics. There, two basic types are introduced (three in case one takes the intentional type to be a basic type) along with their function types (Gallin, 2011; Montague, 1970). MLTTs are multi-sorted type systems and also include additional and more elaborate typing constructors like, for example, dependent types. We will not delve deeper into the discussion on the need for richer typing, but it suffices to say that there are at least some phenomena that are impossible to capture in a system equipped with basic types and no extra constructors. As Chatzikyriakidis et al. (2025) argue, the semantics of copredication and counting cannot be fully captured in a simple type theoretic framework, and they argue for richer type semantics.

The second reason concerns the proof-theoretic nature of MLTTs and thus their ability to be used as effective reasoners. Indeed, variants of MLTT are implemented by computer scientists in proof-assistants, notably in Coq, Lean and Agda, and these assistants, besides being used to formalize mathematics and other types of formal verification, have also been used to encode various aspects of NL semantics (Ranta & Cooper, 2004).

In what follows, we attempt the integration of MLTT-style semantics, specifically the version that Luo and colleagues call MTT-semantics, in Dynamic Syntax. I will show how such integration can proceed, in order to incorporate the rich features of MLTT-semantics into the DS action calculus, in effect giving DS an MLTT backbone.

But before we proceed with this endeavor, we first need an introduction to MLTT-semantics that highlights its most important aspects.

3. MLTT-Semantics: Preliminaries

MLTTs belong to a class of type theories based on Martin-Löf (Martin-Löf, 1975, 1984) that have dependent types and inductive types, among others. In MLTT-semantics, interpreting various linguistic categories can deviate from standard Montagovian assumption as shown below in Table 1:

Table 1. Examples in formal semantics.

	Example	Montague Semantics	MLTT-Based Semantics
CN	man, human	$man,human:e\to t$	$man,human:Type$
IV	talk	$talk:e\to t$	$talk:human\to Prop$
ADJ	handsome	$handsome:(e\to t)\to (e\to t)$	$handsome:man\to Prop$
MCN	handsome man	$handsome\left(man\right):e\to t$	$\mathrm{\Sigma }m:man.handsome\left(m\right):Type$
S	A man talks	$\exists m:e.man\left(m\right)\&talk\left(m\right):t$	$\exists m:man.talk\left(m\right):Prop$

In MTT-based semantics, the basic ways to interpret various linguistic categories are as follows:

• Sentences (S) are interpreted as propositions of type Prop.
• Common nouns (CN) may be interpreted as types.
• Verbs (IV) may be interpreted as predicates over the type D that interprets the domain of the verb (i.e., a function of type D → Prop).
• Adjectives (ADJ) may be interpreted as predicates over the type that interprets the domain of the adjective (i.e., a function of type D → Prop).
• Modified common nouns (MCNs) may be interpreted by means of $\mathrm{\Sigma }$-types.

3.1. Common Nouns as Types and Type Many-Sortedness

MLTT-based formal semantics differs fundamentally from Montague semantics in how common nouns (CNs) can be interpreted. This difference arises from MLTTs being essentially ‘many-sorted’ logical systems.

Montague semantics Montague (1970) employs Church’s simple type theory (Church, 1940), which operates as a ‘single-sorted’ system. Only one type e exists for all entities. Types such as t for truth values and function types constructed from e and t do not denote entity types. Hence, no fine-grained distinctions exist between type e elements, and all individuals use identical type interpretation. John and Mary, for example, both have type e in simple type theories. MLTTs, however, being ‘many-sorted’ logical systems, can contain numerous types. MLTT-based semantics can therefore distinguish between individuals and employ different types to interpret individual subclasses. For instance, we may have $John:man$ and $Mary:woman$, where $man$ and $woman$ are distinct types. Thus, a significant characteristic of MLTT-based semantics is their ability to interpret common nouns (CNs) as types Ranta (1994) rather than sets or predicates (i.e., objects of type $e\to t$) as in Montague semantics. The CNs man, human, table and book are interpreted as types $man$, $human$, $table$ and $book$, respectively. Individuals are then interpreted as belonging to one of the types used to interpret CNs.

Modified common nouns (MCNs in Table 1) receive interpretation through $\mathrm{\Sigma }$-types, which are types of dependent pairs. For instance, ‘handsome man’ receives interpretation as the type $\mathrm{\Sigma }$$m:man.handsome\left(m\right)$, the type of pairs consisting of a man and proof that the man is handsome.

This many-sortedness (i.e., the existence of numerous types in an MLTT) produces the welcome result that semantically infelicitous sentences like, e.g., the ham sandwich walks, which are syntactically well-formed, receive easy explanation. A verb like walks will be specified as having type $Animal\to Prop$, while the type for ham sandwich will be $food$ or $sandwich$, which is incompatible with the typing for walks:1

(1)	a. the ham sandwich: food
	b. walk : human → Prop

The interpretation of CNs as types rather than predicates has significant methodological implications: this approach is compatible with various subtyping relations one may consider in formal semantics. For instance, in modeling certain linguistic phenomena semantically, one may introduce various subtyping relations by postulating a collection of subtypes (physical objects, informational objects, eventualities, etc.) of the entity type Asher and Luo (2012). Now, if CNs receive interpretation as predicates as in the traditional Montagovian setting, introducing such subtyping relations would cause difficult problems: even basic semantic interpretations would fail, and dealing with some linguistic phenomena such as copredication satisfactorily becomes very difficult (Sutton, 2022). Instead, if CNs receive interpretation as types, as in type-theoretical semantics based on MTTs, copredication receives straightforward and satisfactory treatment (Chatzikyriakidis & Luo, 2020).

Coercive Subtyping and Local Coercions

Coercive subtyping is an elaborate subtyping mechanism for MLTT, according to which A is a (proper) subtype of B ($A\le B$) if there is a unique implicit coercion c from type A to type B, and, if so, an object a of type A can be used in any context ${\mathfrak{C}}_B[\_]$ that expects an object of type B: ${\mathfrak{C}}_B\left[a\right]$ to be legal (well-typed) and equal to ${\mathfrak{C}}_B\left[c\left(a\right)\right]$.

To give an example, assume that both $man$ and $human$ are base types. One may then introduce the following as a basic subtyping relation:

(2)	$man\le human$

Now, coercive subtping in combination with the notion of context in MLTT can be used to introduce local subtyping relations when needed. This mechanism is used in the case of classic meaning transfer cases like the ham sandwich shouts. There, the idea is that one can introduce subtyping relations that are only valid in a local context. The context can furthermore be extended to involve subtyping declarations of the following form:

(3)	$\dots ,\mathrm{ham}\mathrm{sandwich}<\mathrm{human},\dots$

In the above, the type ham is coerced into type human in this particular setting via subtyping. The range of coercions we can perform can get more-fine grained as it has been exemplified, for example, in the work of Asher and Luo (2012). Note that this notion of logical coercion via subtyping is different than the usual notion of coercion as we find it in the linguistic semantics literature. In what follows, when we use the term, we mean this logical version of coercion that is tied to the subtyping mechanism.

3.2. $\Sigma$-Types, $\mathsf{\Pi }$-Types and Universes

3.2.1. Dependent $\mathrm{\Sigma }$-Types

A fundamental feature of MTTs is the employment of dependent types. A dependent type constitutes a family of types that depend on certain values.

The constructor/operator $\mathrm{\Sigma }$ constitutes a generalization of the Cartesian product of two sets that allows the second set to depend on values of the first. For instance, if $human$ is a type and $male:human\to Prop$, then the $\mathrm{\Sigma }$-type $\mathrm{\Sigma }h:human.male\left(h\right)$ is intuitively the type of humans who are male.

More formally, if A is a type and B is an A-indexed family of types, then $\mathrm{\Sigma }(A,B)$, sometimes written as $\mathrm{\Sigma }x:A.B\left(x\right)$, is a type, consisting of pairs $(a,b)$ such that a is of type A and b is of type $B\left(a\right)$. When $B\left(x\right)$ is a constant type (i.e., always the same type no matter what x is), the $\mathrm{\Sigma }$-type degenerates into product type $A\times B$ of non-dependent pairs. $\mathrm{\Sigma }$-types (and product types) are associated with projection operations ${\pi }_1$ and ${\pi }_2$ so that ${\pi }_1(a,b)=a$ and ${\pi }_2(a,b)=b$, for every $(a,b)$ of type $\mathrm{\Sigma }(A,B)$ or $A\times B$.

The linguistic relevance of $\mathrm{\Sigma }$-types can be directly appreciated once we understand that in its dependent case, $\mathrm{\Sigma }$-types can be used to interpret linguistic phenomena of central importance, like adjectival modification (Ranta, 1994). For example, handsome man is interpreted as $\mathrm{\Sigma }$-type ((4)), the type of handsome men (or more precisely, the type of those men together with proofs that they are handsome):

(4)	$\mathrm{\Sigma }m:man.handsome\left(m\right)$

where $handsome\left(m\right)$ is a family of propositions/types that depends on the type man(m).

The use of $\mathrm{\Sigma }$-types for dealing with adjectival modification will be further explained later on, when our proposal regarding the different classes of adjectives is going to be discussed.

3.2.2. Dependent $\mathrm{\Pi }$-Types

$\mathrm{\Pi }$-types function as a generalization of the standard function space where the second type constitutes a family of types that might depend on the first type’s values. In the non-dependent case, $\mathrm{\Pi }$ reduces to the function type $A\to B$.

More precisely, when A is a type and P is a predicate over A, $\mathrm{\Pi }x:A.P\left(x\right)$ is the dependent function type that, in the embedded logic, represents the universally quantified proposition $\forall x:A.P\left(x\right)$.

$\mathrm{\Pi }$ proves very useful in formulating typings for numerous linguistic categories like VP adverbs or quantifiers. The concept is that adverbs and quantifiers range over the universe of (the interpretations of) CNs. $\mathrm{\Pi }$ is thus employed, universally quantifying over the universe $cn$. ((5-a)) shows the type for VP adverbs2 while ((5-b)) shows the type for quantifiers:

(5)	a.	ΠA : CN.(A → Prop) → (A → Prop)
	b.	ΠA : CN.(A → Prop) → Prop

To better understand these typings, a few words about the notion of a universe are given as follows: informally, a universe constitutes a collection of (the names of) types assembled into a type (Martin-Löf, 1984). For example, one may wish to collect all the names of the types that interpret common nouns into a universe $\mathrm{CN}:Type$. The concept is that for each type A that interprets a common noun, there exists a name $\overline{A}$ in $\mathrm{CN}$. For example,

$$\overline{man}:\mathrm{CN}\mathrm{and}{T}_{\mathrm{CN}}\left(\overline{man}\right)=man.$$

In practice, we do not distinguish a type in $\mathrm{CN}$ and its name by omitting the overlines and the operator $T_{\mathrm{CN}}$ by simply writing, for instance, $man:\mathrm{CN}$. Thus, the universe includes the collection of the names that interpret common nouns. For example, in $\mathrm{CN}$, one can find the following types:

(6)	a.	man, woman, book, …;
	b.	Σm : man.handsome(m);
	c.	ER + EF;

where the $\mathrm{\Sigma }$-type in ((6-b)) is the proposed interpretation of ‘handsome man’ and the disjoint union type in ((6-c)) is the type election.3

The typings in ((5-a)) and ((5-b)) can now be explained. The type in ((5-b)) states that for all elements A of type $\mathrm{CN}$, we obtain a function type $(A\to Prop)\to Prop$. The concept is that the element A is now the type used. To illustrate how this operates, let us consider the case of quantifier some which has the typing in ((5-b)). The first argument we require must be of type $\mathrm{CN}$. Thus, some human is of type $(human\to Prop)\to Prop$ given that the A here is $human:\mathrm{CN}$ (A becomes the type $human$ in $(human\to Prop)\to Prop$). Then, given a predicate like $walk:human\to Prop$, we can apply some human to get $somehuman\left(walk\right):Prop$.

Finally, $\mathrm{\Sigma }$ and $\mathrm{\Pi }$ have been employed to deal with numerous problematic aspects of NL anaphora. Perhaps the most famous case is donkey anaphora. The concept is that we can make use of the projections of the $\mathrm{\Sigma }$ to obtain donkey anaphora. Below is the interpretation of the classic donkey sentence using dependent typing:

(7)	$\mathrm{\Pi }z:(\mathrm{\Sigma }x:man)(\mathrm{\Sigma }y:donkey)\left(own(x,y)\right)\left(beat({\pi }_1\left(z\right),{\pi }_1\left({\pi }_2\left(z\right)\right))\right)$

The dependent sum type $\mathrm{\Sigma }x:man,\mathrm{\Sigma }y:donkey,own(x,y)$ is a triple that corresponds to a man, a donkey and an ownership relation between the two. The dependent type $\mathrm{\Pi }z$ then quantifies over all such triples. Finally, the projections ${\pi }_1\left(z\right)$ and ${\pi }_1\left({\pi }_2\left(z\right)\right)$ extract a man and donkey, respectively.

4. DS-MLTT

4.1. Preliminaries

The main idea behind our MLTT-DS system is to keep the DS ACTION calculus intact and substitute the standard Montagovian-like DS semantics with MLTT-semantics. Let us start. The first thing we can work on is type many-sortedness. DS, as in Montague semantics, uses a pretty much standard simple type system, with the exception being that type e also includes $e_s$ of situation types (situation entities to be more precise). There is also a type called $cn$, which, however, is a shorthand for an $e\to t$ type. Starting with this notational similarity of this type, which will be notated in uppercase, $CN$ will denote the universe of common noun types in our case. With this said, let us move to the parse of simple example in MLTT-DS. Let us tackle the sentence John loves Mary. The lexical entries for these words will be minimally different in the MLTT case, reflecting type many-sortedness:

(8)	Lexical entry for Bill

IF	$?Ty\left(e\right)$
THEN	$put(Ty\left(human\right),Fo\left(Bil{l}^{\prime }\right)$
ELSE	abort

The same minimal changes are needed in the lexical entry for the verb; for example, a verb like $shout$ will project the formula value $Fo(\lambda x:human.shou{t}^{\prime }\left(x\right)$ instead of $Fo(\lambda x:e.shou{t}^{\prime }\left(x\right)$. With this in place, let us move on to see whether we can successfully use dependent typing to deal with quantification.

4.2. $\Sigma$ and $\Pi$ in Action: Existential and Universal Quantification

One of the idiosyncracies of DS is the use of the epsilon calculus in order to handle quantification. DS uses this mechanism, among other reasons, to keep the types of NPs lower (e) and, thus, have a uniform predicate–argument composition in that way (verbal elements are always the functors, NPs are always the arguments). What I want to show here is a way to do existential quantification using $\mathrm{\Sigma }$ types that respect this lower typing that DS wants. Let us start. Say we want to parse the sentence a man walks. We start with the entry for the indefinite:

(9)	Lexical entry for a

IF	$?Ty\left(object\right)$
THEN	make($⟨{\downarrow }_0⟩$); go($⟨{\downarrow }_0⟩$); put($?Ty\left(CN\right)$);
	go($⟨{\uparrow }_0⟩$); make($⟨{\downarrow }_1⟩$); go($⟨{\downarrow }_1⟩$);
	put(Ty($CN\to object$), Fo($\lambda A:CN.\mathrm{\Sigma }x:A.\top$)), go($⟨{\uparrow }_1⟩$)($⟨{\downarrow }_0⟩$)
ELSE	abort

The idea here is that the indefinite creates the CN node and the CN →object node. The type $object$ is the top type in the CN universe, meaning that all other types in the universe are its subtypes. In that node, the formula value $Fo(\lambda A.\mathrm{\Sigma }x:A.\top )$ is added. This basically creates a function requiring an A argument to create a dependent pair, where the first projection is the proof that x is an A and the second component is just the true proposition. Note that A is of type CN, the universe of common nouns. The next step is the entry for the common noun man:

(10)	Lexical entry for man

IF	$?Ty\left(CN\right)$
THEN	$put\left(Ty\right(CN),Fo(man\left)\right)$
ELSE	abort

The lexical entry for $man$ just contributes its type in the CN node (in effect, this is $man:CN$). The lexical entry for walks is as follows:

(11)	Lexical entry for walks

IF	$?Ty(\mathrm{\Pi }A:CN.A\to Prop)$
THEN	$put\left(Ty\right(human\to Prop),Fo(walk\left)\right)$
ELSE	abort

The requirement has a more general type that will be compatible with any type in the $CN$ universe. The verb walks then contributes the type $human\to Prop$. Combining the $CN$ and $CN\to object$ nodes will give us the formula $Fo(\mathrm{\Sigma }x:man.\top )$. But this is of type $Object$. Indeed this is true, given that the $\mathrm{\Sigma }$ is a subtype of its first projection, i.e., man, and man is a subtype of object which can thus be used in any environment that requires such a type. The end result is reflected in the tree below, where walks combines with the first projection of the dependent path:

(12)

$CN$ interpretation can also proceed via $\mathrm{\Sigma }$, i.e., instead of being base types, they are more elaborate types like, for example, $\mathrm{\Sigma }$ types. For example, in the case of $man$, we could have $\mathrm{\Sigma }x:human.male\left(x\right)$. In this case, what we would get is

(13)

Note that combining $Fo(\lambda A.\mathrm{\Sigma }x:A.\top )$ and $Fo(\mathrm{\Sigma }x:human.male(x\left)\right)$ gives $Fo(\mathrm{\Sigma }x:(\mathrm{\Sigma }x:human.male\left(x\right).\top )$ that simplifies to $Fo(\mathrm{\Sigma }x:human.male(x\left)\right)$. Also in both interpretations of CN, the end result is the same formula. However, in the second case, one can recover the fact that x is male via the second projection that says that there is proof p that x is male, while in the first case the second projection is just the truth placeholder.

The nice thing about the use of $\mathrm{\Sigma }$ is that we can still keep the DS intuition that NPs are of a lower type. In DS, this is maintained by using the epsilon calculus $ϵ$ and $\tau$ operators for existential and universal quantification. In the case of existential quantification, this is possible with $\mathrm{\Sigma }$-types in our case as well. However, when we move to universal quantification using $\mathrm{\Pi }$, this lower typing cannot be maintained. In MLTT-semantics, the universal quantifier is a polymorphic type with the following type:

(14)

$$\mathrm{\Pi }x:A:CN,(A\to Prop)\to Prop$$

(1)

Based on this, we assume the following lexical entry for every:

(15)	Lexical entry for every

IF	$?Ty\left(object\right)$
THEN	make($⟨{\downarrow }_1⟩$); go($⟨{\downarrow }_1⟩$); put($?Ty\left(CN\right)$);
	go($⟨{\uparrow }_1⟩$); make($⟨{\downarrow }_0⟩$); go($⟨{\downarrow }_0⟩$);
	put(Ty($\mathrm{\Pi }A:CN.(A\to Prop)\to Prop$), Fo($\lambda A:CN.\lambda P:(A\to Prop).\mathrm{\Pi }x:A.P\left(x\right)$))
ELSE	abort

The crucial difference is in both the type and formula value: instead of $Ty(CN\to object)$ and $Fo(\lambda A:CN.\mathrm{\Sigma }x:A.\top )$, respectively, what we have is $Ty(\mathrm{\Pi }A:CN.(A\to Prop)\to Prop)$ and $Fo(\lambda A:CN.\lambda P:(A\to Prop).\mathrm{\Pi }x:A.P(x\left)\right)$. In effect, what we get is a polymorphic function that takes a CN argument of type A and returns a generalized quantifier of type $(A\to Prop)\to Prop$. Now, when every applies to man, we get the following:

• The CN node contributes $Fo\left(man\right)$
• The $\mathrm{\Pi }A:CN.(A\to Prop)\to Prop$ node contributes $Fo(\lambda A:CN.\lambda P:(A\to Prop).\mathrm{\Pi }x:A.P(x\left)\right)$
• Applying the function: $(\lambda A:CN.\lambda P:(A\to Prop).\mathrm{\Pi }x:A.P(x\left)\right)\left(man\right)=\lambda P:(man\to Prop).\mathrm{\Pi }x:man.P\left(x\right)$

This creates a generalized quantifier of type $(man\to Prop)\to Prop$, which can then take walk as its argument.

(16)

Let us now see cases involving two quantifiers. Take the sentence every doctor examined a patient. We first process every doctor using $\mathrm{\Pi }$, followed by examined and the indefinite as a $\mathrm{\Sigma }$. The indefinite, as we have said, is parsed as a $\mathrm{\Sigma }$ allowing a lower type to be used because of its first projection. Then, the combination of the predicate and the existential is fed to the universal as an argument, giving the following as the end result:4

(17)

Scopal statements can be handled in the usual DS way shown in Cann et al. (2005) using scopal statements at the top node. For example, parsing every doctor examined will project a statement of scope on the top node:

(18)

When a patient is processed, the indefinite creates an underspecified scope statement $Scope(S_i,U<p)$ where the metavariable U can be resolved to different terms depending on whether narrow or wide scope is chosen. The indefinite also projects a scope requirement $?SC\left(p\right)$ that must be satisfied:

(19)

For the narrow scope reading, the metavariable U is resolved to the universal term already present in the structure, giving $U=\mathrm{universal}$. This results in the scope statement $Scope(S_i<\mathrm{universal}<p)$, meaning the indefinite takes narrow scope relative to the universal quantifier. Function application then yields the final semantic result $\mathrm{\Pi }d:doctor.\mathrm{\Sigma }p:patient.examine(d,p)$:

(20)

Alternatively, for the wide scope reading, the metavariable U is resolved to $S_i$ immediately upon processing the indefinite, giving $U=S_i$. This results in the scope statement $Scope(S_i<p<\mathrm{universal})$, meaning the indefinite takes wide scope over the universal quantifier. The same tree structure applies, but the scope statement determines that the final semantic result is $\mathrm{\Sigma }p:patient.\mathrm{\Pi }d:doctor.Examine(d,p)$:

(21)

What we did so far is as follows: in a way, we kept the intuition for lower typing for the case of existentials (as in the epsilon use for indefinites in the original DS treatment) and a higher-order typing for universals using $\mathrm{\Pi }$ types. To my knowledge, this is the first digression into a use where quantifiers are functors rather than arguments in DS (even though this is the standard in mostly all other formal semantics treatments). What we did here has further connections with the way existentials and universals have been shown to work. For example, going back to Reinhart (1997), choice functions and similar mechanisms (e.g., skolem functions) show that existentials take scope in different ways than universals. Here, I have shown a minimal account of scope in the traditional DS way of accounting for scope. However, the $\mathrm{\Sigma }$, $\mathrm{\Pi }$ assymetry of typing and the use of associated projections of $\mathrm{\Sigma }$ might give rise to similar uses. Indeed, the connection between $\mathrm{\Sigma }$ and choice/skolem functions is intriguing. For example $Fo(\mathrm{\Sigma }p:patient.\top )$ acts like a choice function that picks a witness from the domain of patients. In the same sense, when $\mathrm{\Sigma }p:patient.\mathrm{\Pi }d:doctor.examine(d,p))$, the $\mathrm{\Sigma }$ behaves like a skolem constant. These are intriguing connections and we aspire to further elaborate on these in future work.

4.3. MLTT Contexts and Rerunning DS Actions

One of the powerful features of DS is its incremental, real-time, left-to-right processing that allows transparent semantic representations to be unfolded as a by-product of incremental parsing. DS has been shown to be very suitable for phenomena that go beyond the level of the sentence, notably ellipsis and dialogue phenomena. One very prominent feature of DS is the availability to rerun previous actions again. To give an example, consider the elliptical case of John loves Mary. George does too. The classic DS account of such elliptical cases involves the parser building a complete semantic tree for the first sentence, simultaneously recording all the parsing actions used in a dynamic DAG. When George does too is processed, the auxiliary projects a metavariable of type e → t that triggers a backwards search through the DAG. The sequence of actions that gave rise to the predicate loves Mary from the first sentence are identified and rerun this time at the elliptical sentence, and with George as the new subject. This rerun mechanism produces the desired interpretation George loves Mary without requiring any special ellipsis-specific machinery.

What I want to discuss here is the use of type-theoretic contexts as a means to record the history of parsing actions. In effect, TT contexts will be used to record the actions taken during the parsing process that drive incremental semantic growth. Ideally, we need a record of things like the lexical and computational actions used, the tree-building operations performed (node creation, pointer movement, type and formula decoration), and also, metavariable projections and resolutions/substitutions.

In Martin-Löf Type Theory (MLTT), contextsare finite sequences of variable declarations with their types, written as follows:

(22)	$\mathrm{\Gamma }=x_1:A_1,x_2:A_2\left(x_1\right),x_3:A_3(x_1,x_2),\dots ,x_n:A_n(x_1,\dots ,x_{n-1})$

Contexts serve several crucial functions:

• Variable Binding: Each variable $x_i$ is bound with its type $A_i$, which may depend on previously declared variables.
• Dependency Structure: Later types can refer to earlier variables, creating dependent types like $\mathrm{\Pi }x:A.B\left(x\right)$ and $\mathrm{\Sigma }x:A.B\left(x\right)$.
• Typing Judgments: All type-theoretic judgments are made relative to a context:
• Context Extension: New assumptions are added via context extension $\mathrm{\Gamma },x:A$ (provided $\mathrm{\Gamma }⊢A:Type$).
• Substitution: When we have $\mathrm{\Gamma },x:A,\Delta ⊢J$ and $\mathrm{\Gamma }⊢t:A$, we can substitute to get $\mathrm{\Gamma },[t/x]\Delta ⊢[t/x]J$.

Contexts thus provide the foundational infrastructure for dependent typing, ensuring that all type dependencies are properly tracked and that substitution operations preserve well-typedness.

In this paper, we extend the standard MLTT notion of contexts to record not just semantic assumptions but the complete derivational history of DS parsing. Our DS-MLTT contexts take the following form:

(23)

$${\mathrm{\Gamma }}_{\mathrm{DS}}={\mathrm{sem}}_1:T_1,{\mathrm{action}}_1:\mathrm{DSAction},{\mathrm{sem}}_2:T_2,{\mathrm{action}}_2:\mathrm{DSAction},\dots$$

where semantic assumptions are interleaved with action assumptions that record the parsing steps used to derive each semantic judgment. This allows us to treat action rerun as a formal operation on TT contexts, where we can extract and re-use action sequences. Let us exemplify the mechanism using the VP ellipsis example. But first, we need to define the basic Action types needed:

(24)	Basic Types:
$\mathrm{DSAction}:Type,\mathrm{TreeState}:Type,\mathrm{Address}:Type$ $\mathrm{Context}:Type=\mathrm{List}(\mathrm{DSAction}\times \mathrm{TreeState})$
(25)	DSAction as a Disjoint Union Type:5 $$\begin{array}{cc}\hfill \mathrm{DSAction}=& \mathrm{make}(\mathrm{addr}:\mathrm{Address},\mathrm{reqs}:\mathrm{List}(\mathrm{Requirement}\left)\right)\hfill \\ \hfill & \left|\mathrm{go}\right(\mathrm{addr}:\mathrm{Address})\hfill \\ \hfill & \left|\mathrm{put}\right(\mathrm{content}:\mathrm{NodeContent})\hfill \\ \hfill & \left|\mathrm{THINNING}\right(\mathrm{req}:\mathrm{Requirement})\hfill \\ \hfill & \left|\mathrm{COMPLETION}\right(\mathrm{addr}:\mathrm{Address})\hfill \\ \hfill & \left|\mathrm{ANTICIPATION}\right(\mathrm{addr}:\mathrm{Address})\hfill \\ \hfill & \left|\mathrm{ELIMINATION}\right(\mathrm{rule}:\mathrm{CompRule})\hfill \\ \hfill & \left|\mathrm{LexEntry}\right(\mathrm{word}:\mathrm{String},\mathrm{macro}:\mathrm{LexMacro})\hfill \end{array}$$
	To give an example, consider the parse of the simple sentence John loves Mary. We start with the initial ?Ty(Prop) context:

(26)	Initial Context:

$${\mathrm{\Gamma }}_0:\mathrm{Context}=\left[\right]$$

After parsing the sentence, we end up with the following context:

(27)	Full DS-MLTT Context ${\mathrm{\Gamma }}_{\mathrm{final}}$:

$${\mathrm{\Gamma }}_{\mathrm{final}}=\left\{\begin{array}{c}{\mathrm{make}}_0:\mathrm{make}(⟨{\downarrow }_0⟩,[?Ty\left(object\right)]),\hfill \\ {\mathrm{make}}_1:\mathrm{make}(⟨{\downarrow }_1⟩,[?Ty(object\to Prop)]),\hfill \\ {\mathrm{go}}_0:\mathrm{go}\left(⟨{\downarrow }_0⟩\right),\hfill \\ {\mathrm{lex}}_1:\mathrm{LexEntry}(john,?Ty\left(object\right)\mapsto Ty\left(object\right),Fo\left(john\right)),\hfill \\ {\mathrm{thin}}_1:\mathrm{THINNING}(?Ty\left(object\right)),\hfill \\ {\mathrm{comp}}_1:\mathrm{COMPLETION}\left(⟨{\uparrow }_0⟩\right),\hfill \\ {\mathrm{ant}}_1:\mathrm{ANTICIPATION}\left(⟨{\downarrow }_1⟩\right),\hfill \\ {\mathrm{lex}}_2:\mathrm{LexEntry}(loves,\mathrm{VerbMacro}),\hfill \\ {\mathrm{make}}_2:\mathrm{make}(⟨{\downarrow }_0⟩,[?Ty\left(human\right)]),\hfill \\ {\mathrm{make}}_3:\mathrm{make}(⟨{\downarrow }_1⟩,\left[\right]),\hfill \\ {\mathrm{go}}_2:\mathrm{go}\left(⟨{\downarrow }_0⟩\right),\hfill \\ {\mathrm{lex}}_3:\mathrm{LexEntry}(mary,?Ty\left(human\right)\mapsto Ty\left(human\right),Fo\left(mary\right)),\hfill \\ {\mathrm{thin}}_2:\mathrm{THINNING}(?Ty\left(human\right)),\hfill \\ {\mathrm{comp}}_2:\mathrm{COMPLETION}\left(⟨{\uparrow }_0⟩\right),\hfill \\ {\mathrm{elim}}_1:\mathrm{ELIMINATION}(love,mary),\hfill \\ {\mathrm{comp}}_3:\mathrm{COMPLETION}\left(⟨{\uparrow }_1⟩\right),\hfill \\ {\mathrm{elim}}_2:\mathrm{ELIMINATION}(love\left(mary\right),john),\hfill \\ {\mathrm{thin}}_3:\mathrm{THINNING}(?Ty\left(Prop\right))\hfill \end{array}\right.$$

When the sentence is followed by George does too, the following happens. We start with INTRO and PREDICTION and parsing of George, and the pointer at the predicate node, then does comes into parse, projecting a predicate formula metavariable U:

(28)	Parsing does

$$\mathrm{put}\left(Ty\right(human\to Prop),Fo(U\left)\right)$$

This metavariable acts as a placeholder signaling that predicate content must be recovered from the prior discourse context ${\mathrm{\Gamma }}_{\mathrm{final}}$.

At this point, too comes into parse and triggers a context rerun, filtering out the subject as follows:

(29)	Lexical entry for too (simplified):

IF	$Fo\left(U\right),Ty(human\to Prop)$
THEN	Run(${\mathrm{\Gamma }}_{\mathrm{final}}$, $ExcludeTreeNode(⟨{\downarrow }_0⟩$))
ELSE	abort

The filtering operation works as follows: we exclude all actions associated with building and populating the left daughter node at address $⟨{\downarrow }_0⟩$ (the subject position). Specifically, this removes actions from ${\mathrm{make}}_0$ through ${\mathrm{comp}}_1$ in ${\mathrm{\Gamma }}_{\mathrm{final}}$. The filtered context ${\mathrm{\Gamma }}_{\mathrm{filtered}}$ retains only the actions that constructed the predicate:

$${\mathrm{\Gamma }}_{\mathrm{filtered}}=\left\{\begin{array}{c}{\mathrm{ant}}_1:\mathrm{ANTICIPATION}\left(⟨{\downarrow }_1⟩\right),\hfill \\ {\mathrm{lex}}_2:\mathrm{LexEntry}(loves,\mathrm{VerbMacro}),\hfill \\ {\mathrm{make}}_2:\mathrm{make}(⟨{\downarrow }_0⟩,[?Ty\left(human\right)]),\hfill \\ ⋮\hfill \\ {\mathrm{elim}}_1:\mathrm{ELIMINATION}(love,mary)\hfill \end{array}\right.$$

These remaining actions are rerun in the current tree where George occupies the subject position. The rerun rebuilds the predicate structure: loves projects its argument structure, Mary fills the object slot, and function application produces $\lambda h.love\left(mary\right)\left(h\right)$. The U metavariable is then substituted with this recovered predicate value, and COMPLETION plus ELIMINATION yield the final result $love\left(mary\right)\left(george\right):Prop$.

4.4. Adjectives and Adverbs

In this last section, I want to discuss two issues that have not received enough attention in the DS literature: adjectives and adverbs. There is some work on adjectives as part of an analysis of polydefinites in Chatzikyriakidis (2015); Chatzikyriakidis and Spathas (2025), and also some general notes on adjectives and adverbs in Chatzikyriakidis (2017), but no attempt at a generalized account of these exist. What I will propose here is a way to use standard DS mechanisms with dependent typing in order to get a basic account of aspects of the syntax/semantics of adjectives and adverbs.

4.5. Adjectives

I am going to propose two mechanisms for adjectives: one that does not use LINK and projects adjectival semantics in the CN node, and one that uses LINK. Various adjectival constructions cross-linguistically seem to be requiring both as I will argue, e.g, regular adjectival modification vs polydefinites in Greek and stage- vs. individual-level readings in English. Let us start with a classic intersective adjective like black. The standard assumption in MLTT-semantics is that something like black dog involves a $\mathrm{\Sigma }$ in effect, a dependent pair with the first projection being proof that an object is a dog, along with proof that it is black (given that it is a dog). Based on this, one can envision the following lexical entry for black in English:

(30)	Lexical Entry for black:

IF	$?Ty\left(CN\right)$
THEN	make($⟨{\downarrow }_0⟩$); go($⟨{\downarrow }_0⟩$); put($?Ty\left(CN\right)$);
	go($⟨{\uparrow }_0⟩$); make($⟨{\downarrow }_1⟩$); go($⟨{\downarrow }_1⟩$);
	put($Ty(CN\to CN)$, $Fo(\lambda P:CN.\mathrm{\Sigma }x:P.black(x\left)\right)$)
ELSE	abort

Parsing black will give us

(31)	Parsing black

Then, dog is parsed, providing the noun type and combining with the polymorphic $\mathrm{\Sigma }$ type to return $\mathrm{\Sigma }x:dog.Black\left(x\right)$. The ?Object node gets a type and a formula:

(32)	After parsing dog

Walks comes into parse, combines with the subject node, and the parse is complete:

(33)	After a black dog walks

Note that in the above, the ending formula is $\mathrm{\Sigma }x:(\mathrm{\Sigma }y:dog.black\left(y\right)).walk\left({\pi }_{1}x\right))$, since the first projection of the $\mathrm{\Sigma }$ is a coercion (basically, we drop the ⊤ from the formula). In TTs where this does not hold, one needs to find a way to grab the first projection content. Of course, we need to repeat here that this exact mechanism is also the one that allows us to keep a lower type with $\mathrm{\Sigma }$ types.

The other way to deal with adjectives and, in general, modifiers is via LINK. The difference here is that the adjective, instead of projecting its semantics into the main tree, initiates a LINK relation from the type ?CN node.

(34)	After parsing black on a LINKed tree

After LINK evaluation gives us $Fo(\mathrm{\Sigma }y:dog.black(y\left)\right)$ at the CN node, then ELIMINATION combines it with the determiner:

(35)

$$\begin{array}{cc}\hfill & (\lambda A:CN.\mathrm{\Sigma }x:A.\top )(\mathrm{\Sigma }y:dog.black(y\left)\right)\hfill \\ \hfill & \to \mathrm{\Sigma }x:\left(\mathrm{\Sigma }y:dog.black\left(y\right)\right).\top \hfill \end{array}$$

The verb comes into parse and everything works as expected from there on:

(36)

One thing that these two different ways of encoding adjectives offer us is that we can deal with some well-known differences in adjectival syntax cross-linguistically. For example, take the case of individual- vs. stage-level readings in English, i.e., the difference between the responsible people and the people responsible. In the first case, the property of being responsible is tightly knit into that specific subset of people, whereas in the second, it is situation-dependent. One can envision where the prenominal adjectives give the semantics we just discussed, and the postnominal is derived by LINK via a LINK evaluation rule that ties the semantics to a situation variable. Similar considerations apply to Greek polydefinites, recasting the account by Chatzikyriakidis and Spathas (2025) with MLTT-semantics.

Let me now say a few words on how adverbs can be incorporated in DS-MLTT. In terms of their semantics, the semantics of various types of adverbs have been dealt with in Chatzikyriakidis and Luo (2017) and the assumption that adverbs involve LINK relations.

(37)	Lexical Entry for quickly:

IF	$?Ty(A\to Prop)$
THEN	make($⟨L⟩$); go($⟨L⟩$);
	put($Ty(\mathrm{\Pi }A:CN.(A\to Prop)\to (A\to Prop\left)\right)$,
	$Fo(\lambda A:CN.\lambda P:A\to Prop.\lambda x:A.quickly(P\left(x\right)\left)\right)$)
ELSE	abort

Now take the sentence John walks quickly. The first step is parsing the subject and verb:

(38)	After John walks

(39)	After quickly is parsed

The adverb’s typing contains an A argument which is inferred from context. This is not unusual in type systems. In fact, we can assume that the A is an implicit argument, in the same sense one can declare implicit arguments in proof-assistants implementing MLTTs like Coq (The Coq Development Team, 2024). Given this type being implicit, the result of the tree after evaluation is as follows:

(40)	Final tree after ELIMINATION

This is a simple treatment of VP adverbs that does not get into the details of the semantics of each adverb. However, the MLTT paradigm is expressive enough to capture various fine-grained issues in adverbial semantics. To give an example, considering veridicality, if we wanted to encode veridicality for VP (or Prop adverbs), one way is to use the following $\mathrm{\Sigma }$-type based account. According to this, the lexical entry for quickly will be the following:

We use an auxiliary type constructor that associates a modified predicate with a proof of veridicality:

(41)

$$VE{R}_{VP}:\mathrm{\Pi }A:cn.\mathrm{\Pi }v:A\to Prop.\mathrm{\Sigma }p:A\to Prop.\forall x:A.(p\left(x\right)\Rightarrow v\left(x\right))$$

Then, every veridical adverb is of the following definition:

(42)

$$AD{V}_{ver-VP}=\lambda A:cn.\lambda v:A\to Prop.{\pi }_1\left(VE{R}_{VP}(A,v)\right)$$

For quickly, we have the following DS entry:

(43)	Lexical Entry for veridical quickly

IF	$?Ty(A\to Prop)$
THEN	make($⟨L⟩$); go($⟨L⟩$);
	put($Ty(\mathrm{\Pi }A:cn.(A\to Prop)\to (A\to Prop\left)\right)$,
	$Fo(\lambda A:cn.\lambda v:A\to Prop.{\pi }_1\left(QUICKLY(A,v)\right))$)
ELSE	abort

Now, after parsing something like John walks quickly, we get the following:

• Parse gives ${\pi }_1\left(QUICKLY(human,walk)\right)\left(john\right)$.
• This is equal to $quickly\left(walk\right(john\left)\right)$.
• Extract the proof from the second projection: ${\pi }_2\left(QUICKLY(human,walk)\right):\forall x:human.(quickly\left(walk\left(x\right)\right)\Rightarrow walk\left(x\right))$.
• Instantiate with $john$: $quickly\left(walk\right(john\left)\right)\Rightarrow walk\left(john\right)$.
• Modus ponens: $walk\left(john\right)$.

Same considerations apply to sentence-level adverbs. Of course, the semantics, but also syntax, of adverbs are far more complicated, but I will not delve into more fine-grained issues of adverbial semantics here. The interested reader is directed to Maienborn and Schäfer (2019); Morzycki (2016) for a general discussion on the nature and problems of modification in NL semantics and to Chatzikyriakidis and Luo (2017) for a more thorough discussion on treating the semantics of aspects of adjectival and adverbial modification using MLTT-semantics.

5. Conclusions and Future Work

In this paper, I presented a first take on how one can encode MLTT-semantics in Dynamic Syntax. I have shown a couple of use cases, including the incorporation of type many-sortedness, dependent typing for a number of issues like quantifiers, adjectives and adverbs and the use type-theoretic context to help us encode DS context in order to facilitate action rerun and similar core DS mechanisms.

One of the things we did away with was the epsilon calculus.