From daeaa0f1144b8f7852d0ef52a6a70870bcdc27bb Mon Sep 17 00:00:00 2001 From: aarne Date: Thu, 16 Aug 2007 21:35:11 +0000 Subject: [PATCH] section on agreement --- doc/tutorial/gf-book.txt | 214 ++++++++++++++++++++++------ examples/tutorial/foods/Foods.gf | 8 +- examples/tutorial/foods/FoodsEng.gf | 18 +-- examples/tutorial/foods/FoodsIta.gf | 5 +- 4 files changed, 187 insertions(+), 58 deletions(-) diff --git a/doc/tutorial/gf-book.txt b/doc/tutorial/gf-book.txt index 9363e16f3..11dbe92ac 100644 --- a/doc/tutorial/gf-book.txt +++ b/doc/tutorial/gf-book.txt @@ -1268,7 +1268,7 @@ concise than GF proper, but also more restricted in expressive power. -==Using resource modules== +==Using operations and resource modules== ===The golden rule of functional programming=== @@ -1731,54 +1731,160 @@ comprise morphology. This will permit a more radical variation between languages (e.g. English and Italian) then just the use of different words. In general, parameters and linearization types are different in -different languages - but this does not prevent the -use of a common abstract syntax. +different languages - but this has no effect on +the common abstract syntax. + +We consider a grammar ``Foods``, which is similar to +``Food``, with the addition of two plural determiners, +``` + fun These, Those : Kind -> Item ; +``` +and a noun which in Italian has the feminine case; all noun in +``Food`` were carefully chosen to be masculine! +``` + fun Pizza : Kind ; +``` + %--! -===Parametric vs. inherent features, agreement=== +===Agreement=== -The rule of subject-verb agreement in English says that the verb -phrase must be inflected in the number of the subject. This -means that a noun phrase (functioning as a subject), inherently -has a number, which it passes to the verb. The verb does not -//have// a number, but must be able to //receive// whatever number the -subject has. This distinction is nicely represented by the -different linearization types of **noun phrases** and **verb phrases**: +In the English ``Foods`` grammar, we need just one type of parameters: +``Number`` as defined above. The phrase-forming rule ``` - lincat NP = {s : Str ; n : Number} ; - lincat VP = {s : Number => Str} ; + Is : Item -> Quality -> Phr ; ``` -We say that the number of ``NP`` is an **inherent feature**, -whereas the number of ``NP`` is a **variable feature** (or a -**parametric feature**). - -The agreement rule itself is expressed in the linearization rule of -the predication function: +is affected by the number because of **subject-verb agreement**. +In English, agreement says that the verb of a sentence +must be inflected in the number of the subject. Thus we will linearize ``` - lin PredVP np vp = {s = np.s ++ vp.s ! np.n} ; + Is (This Pizza) Warm >> "this pizza is warm" + Is (These Pizza) Warm >> "these pizzas are warm" ``` -The following section will present -``FoodsEng``, assuming the abstract syntax ``Foods`` -that is similar to ``Food`` but also has the -plural determiners ``These`` and ``Those``. -The reader is invited to inspect the way in which agreement works in -the formation of sentences. - - -%--! -===English concrete syntax with parameters=== - -The grammar uses both -[``Prelude`` ../../lib/prelude/Prelude.gf] and -[``MorphoEng`` resource/MorphoEng]. -We will later see how to make the grammar even -more high-level by using a resource grammar library -and parametrized modules. +It is the **copula**, i.e. the verb //be// that is affected. We can define +the copula as the operation +``` + oper copula : Number => Str = + table { + Sg => "is" ; + Pl => "are" + } ; +``` +The form of the copula depends on the subject of the sentence, i.e. the item +that is qualified. This means that an item must have such a number to provide. +In other words, the linearization of an ``Item`` must provide a number. The +simplest way to guarantee this is by putting a number as a field in +the linearization type: +``` + lincat Item = {s : Str ; n : Number} ; +``` +Now we can write precisely the ``Is`` rule that expresses agreement: +``` + lin Is item qual = {s = item.s ++ copula ! item.n ++ qual.s} ; ``` ---# -path=.:resource:prelude -concrete FoodsEng of Foods = open Prelude, MorphoEng in { +===Government=== + +Let us turn to ``Item`` subjects and see how they receive their +numbers. The two rules +``` + fun This, These : Kind -> Item ; +``` +require different numbers of their ``Kind`` arguments: ``This`` +requires the singular (//this pizza//) and ``These`` the plural +(//these pizzas//). The ``Kind`` is the same in both cases: ``Pizza``. +Thus we must require that a ``Kind`` has both singular and plural forms. +The simplest way to express this is by using a table: +``` + lincat Kind = {s : Number => Str} ; +``` +The linearization rules for ``This`` and ``These`` can now be written +``` + lin This kind = { + s = "this" ++ kind.s ! Sg ; + n = Sg + } ; + + lin These kind = { + s = "these" ++ kind.s ! Pl ; + n = Pl + } ; +``` +The grammatical relation between the determiner and the noun is similar to +agreement, but yet different; it is usually called **government**. +Since the same pattern is used four times in the ``FoodsEng`` grammar, +we codify it as an operation, +``` + oper det : Str -> Number -> {s : Number => Str} -> {s : Str ; n : Number} = + \det,n,kind -> { + s = det ++ kind.s ! n ; + n = n + } ; +``` +In a more linguistically motivated grammar, determiners will be made to a +category of their own and have a number. + + +===Parametric vs. inherent features=== + +``Kind``s, as in general common nouns in English, have both singular +and plural forms; what form is chosen is determined by the construction +in which the noun is used. We say that the number is a +**parametric feature** of nouns. In GF, parametric features +appear as argument types to tables in linearization types. + +``Item``s, as in general noun phrases functioning as subjects, don't +have variation in number. The number is rather an **inherent feature**, +which the noun phrase passes to the verb. In GF, inherent features +appear as record fields in linearization types. + +A category can have both parametric and inherent features. As we will see +in the Italian ``Foods`` grammar, nouns have parametric number and +inherent gender: +``` + lincat Kind = {s : Number => Str ; g : Gender} ; +``` +Formally, nothing prevents the same parameter type from appearing both +as parametric and inherent feature, or the appearance of several inherent +features of the same type, etc. Determining the linearization types +of categories is one of the most crucial steps in the design of a GF +grammar. Two conditions must be in balance: +- existence: what forms are possible to build by morphological and + other means? +- need: what features are expected via agreement or government? + + +Grammar books and dictionaries give good advice on existence; for instance, +an Italian dictionary has entries such as + +**uomo**, pl. //uomini//, n.m. "man" + +which tells that //uomo// is a masculine noun with the plural form //uomini//. +From this alone, or with a couple more examples, we can generalize to the type +for all nouns in Italian: they have both singular and plural forms and thus +a parametric number, and they have an inherent gender. + +Sometimes the puzzle of making agreement and government work in a grammar has +several solutions. For instance, //precedence// in programming languages can +be equivalently described by a parametric or an inherent feature (see below). +However, in natural language applications using the resource grammar library, +all parameters are hidden from the user, who thereby does not need to bother +about them. + + +==An English concrete syntax for Foods with parameters== + +We repeat some of the rules above by showing the entire +module ``FoodsEng``, equipped with parameters. The parameters and +operations are, for the sake of brevity, included in the same module +and not in a separate ``resource``. However, some string operations +from the library [``Prelude`` ../../lib/prelude/Prelude.gf] +are used. +``` + --# -path=.:prelude + + concrete FoodsEng of Foods = open Prelude in { lincat S, Quality = SS ; @@ -1786,8 +1892,7 @@ concrete FoodsEng of Foods = open Prelude, MorphoEng in { Item = {s : Str ; n : Number} ; lin - Is item quality = - ss (item.s ++ (mkVerb "are" "is").s ! item.n ++ quality.s) ; + Is item quality = ss (item.s ++ copula item.n ++ quality.s) ; This = det Sg "this" ; That = det Sg "that" ; These = det Pl "these" ; @@ -1795,7 +1900,8 @@ concrete FoodsEng of Foods = open Prelude, MorphoEng in { QKind quality kind = {s = \\n => quality.s ++ kind.s ! n} ; Wine = regNoun "wine" ; Cheese = regNoun "cheese" ; - Fish = mkNoun "fish" "fish" ; + Fish = noun "fish" "fish" ; + Pizza = regNoun "pizza" ; Very = prefixSS "very" ; Fresh = ss "fresh" ; Warm = ss "warm" ; @@ -1804,13 +1910,29 @@ concrete FoodsEng of Foods = open Prelude, MorphoEng in { Delicious = ss "delicious" ; Boring = ss "boring" ; + param + Number = Sg | Pl ; + oper - det : Number -> Str -> Noun -> {s : Str ; n : Number} = + det : Number -> Str -> {s : Number => Str} -> {s : Str ; n : Number} = \n,d,cn -> { s = d ++ cn.s ! n ; n = n + } ; + noun : Str -> Str -> {s : Number => Str} = + \man,men -> {s = table { + Sg => man ; + Pl => men + } + } ; + regNoun : Str -> {s : Number => Str} = + \car -> noun car (car + "s") ; + copula : Number -> Str = + \n -> case n of { + Sg => "is" ; + Pl => "are" } ; -} + } ``` @@ -1844,6 +1966,10 @@ Thus we could rewrite the above rule ``` lin Fish = {s = \\_ => "fish"} ; ``` +An example binding a variable was shown in ``FoodEng``: +``` + lin QKind quality kind = {s = \\n => quality.s ++ kind.s ! n} ; +``` Finally, the ``case`` expressions common in functional programming languages are syntactic sugar for table selections: ``` diff --git a/examples/tutorial/foods/Foods.gf b/examples/tutorial/foods/Foods.gf index 9337e234a..210db69d4 100644 --- a/examples/tutorial/foods/Foods.gf +++ b/examples/tutorial/foods/Foods.gf @@ -1,14 +1,16 @@ abstract Foods = { + flags startcat=Phr ; + cat - S ; Item ; Kind ; Quality ; + Phr ; Item ; Kind ; Quality ; fun - Is : Item -> Quality -> S ; + Is : Item -> Quality -> Phr ; This, That, These, Those : Kind -> Item ; QKind : Quality -> Kind -> Kind ; Wine, Cheese, Fish, Pizza : Kind ; Very : Quality -> Quality ; Fresh, Warm, Italian, Expensive, Delicious, Boring : Quality ; -} \ No newline at end of file +} diff --git a/examples/tutorial/foods/FoodsEng.gf b/examples/tutorial/foods/FoodsEng.gf index ba3502b39..8ea5e6079 100644 --- a/examples/tutorial/foods/FoodsEng.gf +++ b/examples/tutorial/foods/FoodsEng.gf @@ -1,23 +1,23 @@ ---# -path=.:resource:prelude +--# -path=.:prelude concrete FoodsEng of Foods = open Prelude in { lincat - S, Quality = SS ; + Phr, Quality = SS ; Kind = {s : Number => Str} ; Item = {s : Str ; n : Number} ; lin - Is item quality = ss (item.s ++ copula item.n ++ quality.s) ; + Is item quality = ss (item.s ++ copula ! item.n ++ quality.s) ; This = det Sg "this" ; That = det Sg "that" ; These = det Pl "these" ; Those = det Pl "those" ; QKind quality kind = {s = \\n => quality.s ++ kind.s ! n} ; - Wine = noun "wine" "wines" ; - Cheese = noun "cheese" "cheeses" ; + Wine = regNoun "wine" ; + Cheese = regNoun "cheese" ; Fish = noun "fish" "fish" ; - Pizza = noun "pizza" "pizzas" ; + Pizza = regNoun "pizza" ; Very = prefixSS "very" ; Fresh = ss "fresh" ; Warm = ss "warm" ; @@ -41,8 +41,10 @@ concrete FoodsEng of Foods = open Prelude in { Pl => men } } ; - copula : Number -> Str = - \n -> case n of { + regNoun : Str -> {s : Number => Str} = + \car -> noun car (car + "s") ; + copula : Number => Str = + table { Sg => "is" ; Pl => "are" } ; diff --git a/examples/tutorial/foods/FoodsIta.gf b/examples/tutorial/foods/FoodsIta.gf index 89635eab4..d46bf469d 100644 --- a/examples/tutorial/foods/FoodsIta.gf +++ b/examples/tutorial/foods/FoodsIta.gf @@ -1,9 +1,9 @@ ---# -path=.:resource:prelude +--# -path=.:prelude concrete FoodsIta of Foods = open Prelude in { lincat - S = SS ; + Phr = SS ; Quality = {s : Gender => Number => Str} ; Kind = {s : Number => Str ; g : Gender} ; Item = {s : Str ; g : Gender ; n : Number} ; @@ -74,4 +74,3 @@ concrete FoodsIta of Foods = open Prelude in { Pl => "sono" } ; } -