3
The base grammar
The general point of view this thesis takes is that the expressions of a language are generated by rules that operate on a finite collection of atomic expressions in order to build other, more complex expressions. This chapter is about ex-plicating what expressions are and how they are combined. We will start by specifying expressions to be form-meaning pairs, with forms being the phono-logical representation and meaning being the semantic representation of the expression. Then we will define a simple operation for combining two form-meaning pairs into another form-form-meaning pair. It will be based on common assumptions of generative grammar and cover simple cases not yet involving displacement and operator scope. In the end of the chapter, we will have carved out a mechanism to mediate between form and meaning with a smooth interface that ensures that they are build in accordance with each other.
Let us start with the building blocks of our grammar: expressions. As already mentioned, expressions are defined as simple form-meaning pairs (and not as trees, for example). We will extend this definition in the next chapter.
Expression::= (Form,Meaning)
Throughout the thesis I will use Backus-Naur-Form (BNF) when stating definitions. I write non-terminal symbols in bold face and terminal symbols in normal font or italics. For example, the BNF rule A ::= b | B | cD expresses that a non-terminal A can be rewritten as either a terminal b or a
40 The base grammar 3 non-terminal B or a terminalc followed by a non-terminal D. The definition of expressions above, thus expresses that an expression is a pair of whatever FormandMeaningrewrite to (what this is, we will see in a minute). The set of all expressions is thus defined as the set of all pairs that we can build from any form and any meaning.
Forms are usually assumed to be sequences of sound making up a linguistic utterance, possibly together with some syntactic information. We will represent sequences of sounds as strings for ease of exposition. This is way too rough from a phonological perspective, but it will suffice for our purposes. So for us, form comprises a string together with necessary syntactic information such as a category. Meaning, on the other hand, uniquely determines the denotation of the expression. For us, it will be an expression of a lambda calculus. The next two sections will specify form and meaning further.
By defining expressions as form-meaning pairs, we take a stand with respect to how form and meaning are linked. We follow the conception that the meaning of an expression is constructed in parallel to the construction of the form.
According to this view, expressions are two-dimensional objects that encode syntactic as well as semantic information. Other frameworks instantiating this view are, for example, Head-Driven Phrase Structure Grammar [87].
The opposed view consists in assuming that the meaning of an expression is assembled only after the construction of its form is finished. Transformational grammar theories such as Government and Binding theory exemplify this view.
There, the syntactic structure is constructed prior to semantic interpretation.
So a form is paired with a meaning only after all syntactic operations have applied. And in most cases, syntax is where all combinatorial action happens;
phonology and semantics only interpret the finished syntactic structure. Sound and meaning are therefore derived from syntactic structure. An operation like Quantifier Raising fits very well with this picture: Syntax starts by building the surface structure of an expression, which is then interpreted by phonology.
After that, the structure building process continues and produces a logical form that can then be input to semantics.
This is different from Montague’s approach to grammar, where the steps for building a surface string are interspersed with the steps for building a log-ical form. This integration brings about that every expression that can be constructed receives an interpretation. That is, the syntactic and semantic well-formedness of an expression is defined simultaneously at each level of con-stituency. This is what we have in mind when devising an algorithm that com-putes the syntactic and semantic representation of an expression in tandem.
This procedural view, in fact, also underlies recent work in transformational grammar. Many approaches in the Minimalist Program assume a step-wise procedure for the generation of utterances along with their meanings. The introduction of phases (c.f. Chomsky [21],[22]), for example, already chunks the syntactic structure that is built before being input to interpretation, and Epstein & Seely [37] later proposed to even let every step of the syntactic
com-3.1 Form 41 putation be input to the semantic computation. The incremental view on the generation of expressions fits very naturally with the computational perspective we are taking. Therefore it should not be surprising to find our explorations in this general line of thinking.
Now let us move to explicating forms and meanings. In doing so, we will disregard all dependencies that are not relevant for the purpose of the thesis, that is case assignment, agreement, and the like.
3.1 Form
Our starting point is rather naive. Forms simply correspond to strings and syn-tactic operations combine those strings into other strings. The main conceptual goal will be to minimize the amount of structure generated by the grammar.
Operations therefore do not build any hierarchical constituent structure un-less necessary. (And it will be necessary only next chapter, when we consider displacement.) This approach is in the spirit of all syntax theories that take syntactic operations to be local and not have access to anything in the past or future of a derivation.
For combining strings we use string concatenation, i.e. a function that maps two input strings to the juxtaposition of both. We refer to it as ++. For example,mighty++Gilgameshyields the string mighty Gilgamesh.
Next, we need to restrict string combination because we do not want to allow the concatenation of every string with every other string. For instance, we do not want to allow the concatenation of the stringmightywith the stringit rains.
In order to restrict the possibilities to those which are actually grammatical, we classify strings according to their ability to combine with other strings, like categorial grammars do. The sets of strings that share combinatorial behavior are named by types. Types thus encode with which kind of other strings a string can combine, and which kind of string this combination yields.
Types are defined as being either basic types, that specify the syntactic category of an expression (noun phrases, verb phrases, and so on), or as being functional types, that specify with strings of which type (and in which order) a certain string can combine.
Definition 1. The set of syntactic types is given by:
Cat ::= NP (noun phrases)
| N (common nouns)
| VP (verb phrases)
| CP (sentences)
| Cat→Cat (functional types)
42 The base grammar 3 I will use the terms ‘syntactic type’, ‘category’ and ‘syntactic category’
interchangeably.
Now forms can be defined to be typed strings, with :: standing for ‘is of type’. I will print types in grey font for better readability. (Also this definition will be extended in the next chapter.)
Form::=String::Cat
Here are some examples of forms:
Gilgamesh:: NP people:: N
the:: N→NP
tyrannizes:: NP→(NP→VP)
Let me first mention that there is no principled reason here for using NP instead of DP as category for noun phrases. We could as well specify the type ofGilgameshas DP, the type of the determiner as N→DP (or even NP→DP), and the type of the verb as DP→(DP→VP).
Now we want to combine these example strings according to their categories, e.g. like specified in the following derivation tree:
Gilgamesh tyrannizes the people:: VP
tyrannizes the people:: NP→VP
tyrannizes:: NP→(NP→VP) the people:: NP the:: N→NP people:: N
Gilgamesh:: NP
In order to do so, we need an operation that concatenates strings according to their types. We will call this functionmerge. It basically combines a stringa of typec1→c2with a stringbof typec1and yields a new stringa++bof type c2. We say thatasubcategorizes for b, or thatb is subcategorized bya. So we can, for example, combine the string the:: N→NPwith the stringpeople:: N in order to form the new string the++people:: NP. Furthermore, I will follow the notions of generative grammar and call a subcategorizing string head and a string that is subcategorized acomplement.
3.2 Meaning 43