The paper introduces GF, Grammatical Framework, as a tool for implementing controlled languages. GF provides a high-level grammar formalism and a resource grammar library that make it easy to write grammars that cover similar fragments in several natural languages at the same time. Authoring help tools and automatic translation are provided for all grammars. As an example, a grammar of Attempto Controlled English is implemented and then ported to French, German, and Swedish.
Controlled languages are fragments of natural languages. They are designed to be clear and unambiguous. If they are mechanically processable, they have the benefits of formal languages; moreover, since they look like natural languages, humans can understand them without training. However, writing controlled language can be a problem, since the author has to remain within a fragment whose limits she has to learn. Moreover, implementing a controlled language on a computer requires a considerable effort, since the syntax of even small fragments of natural languages is much more complex than the syntax of formal languages.
This paper addresses both the writing and the implementation problem, by using
GF
Writing grammars in GF is helped by the resource grammar library (Ranta 2007), a set of wide-coverage grammars currently implemented for 12 languages: Bulgarian, Catalan, Danish, English, Finnish, French, German, Italian, Norwegian, Russian, Spanish, and Swedish. The library takes care of linguistic details (inflection, agreement, word order), allowing the grammarian to concentrate on the content.
Starting with experiments
In this paper, we will present a GF grammar for Attempto Controlled English (
Our implementation of Attempto in GF follows the document "ACE 6.0 Construction
Rules" (
Following standard computer science concepts, GF distinguishes between abstract syntax and concrete syntax. The abstract syntax is a system of trees, which encode the structures of the language. It is up to the grammarian to decide if the tree structure is semantic or syntactic, or something in between. As we followed the Attempto construction rules, we ended up with structures with a rather syntactic flavour. In the resulting grammar, the English sentence every rich customer is important receives the tree (vpS (everyNP (adjCN (positAP rich_A) customer_CN)) (apVP (positAP important_A))) Trees in GF are like Lisp terms: a tree is a function applied to zero or more trees; unlike Lisp, GF trees are statically typed. The outermost function in the example tree is vpS : NP -> VP -> S which takes a noun phrase (NP) and a verb phrase (VP) to a sentence (S). An abstract syntax in GF is a set of such functions and categories (basic types, such as NP); our Attempto implementation has 28 categories and 120 (non-lexical) functions.
A concrete syntax defines the linearizations of trees into strings and, more generally, feature structures. Features are used for phenomena such as agreement and word order. What features are needed depends heavily on language; the crucial property of GF (as opposed to most grammar formalisms) is that the features are treated separately in each concrete syntax, which enables a language-independent abstract syntax.
Getting all details right in concrete syntax is highly non-trivial. This is where the GF Resource Grammar Library comes in. When using the library, concrete syntax is not written by using strings and features explicitly, but by calling functions in the library. Thus the linearization of the predication rule of Attempto is simply
lin vpS np vp = mkS presTense posPol (mkCl np vp) The function mkCl takes a noun phrase and a verb phrase and builds a clause, whose tense and polarity are not yet fixed. The function mkS is used to make it a present-tense sentence with positive polarity. The grammar also uses mkS with the argument negPol to express Attempto’s negative predication.
The abstract syntax rules in the library are exactly the same for all 12 languages. The Attempto syntax can therefore be implemented by using a shared parametrized module (Ranta 2007). For example the German version is implemented as: concrete AttemptoGer of Attempto = SymbolsC ** AttemptoI with (Syntax = SyntaxGer), (Symbolic = SymbolicGer), (LexAttempto = LexAttemptoGer) ; Here the main implementation module is AttemptoI. It provides the main functionality but leaves some grammatical details unspecified. In fact in the implementation it uses interfaces like Syntax and Symbolic as black boxes which are supposed to deal with low-level details like the word order or the agreement in the target language. When concrete language is selected (German in this case) the real implementations are specified with the with clause. In this case the implementations for SyntaxGer and SymbolicGer come from the resource library.
This is not the case for the lexicon. Each language in the library has its own module of inflection paradigms, since different pieces of information are needed to define the inflection tables of words. To give an example, our Attempto lexicon has the abstract syntax constant customer_N, which is linearized as follows: mkN "customer" - English mkN "client" - French mkN "Kunde" "Kunden" masculine - German mkN "kund" "kunder" - Swedish Now we can map the example tree to English, French, German, and Swedish: every rich customer is important chaque client riche est important jeder reiche Kunde ist wichtig varje rik kund är viktig
If syntactic combinations are implemented with a parametrized module, as in the case of our Attempto grammar, adding a new language to a multilingual GF system typically requires only a new implementation of the lexicon.
In some cases, however, some changes are needed. It may happen that the new language uses two different words in different contexts to express something that was a single word before, just because it happened to be linearized in the same way in the language that was the model of the first abstract syntax. This problem can mostly be avoided when the development is guided by some language independent ontology, instead of a particular language; this approach seems to be used in Attempto applications as well.
Another case in which more work is needed than just a new lexicon is when the new target language uses different syntactic structures to express a certain combination than those defined in the parametrized module. This problem is unavoidable, but can be solved by simply overriding the parametrized solution in the language in question. In our Attempto grammars, we didn’t use this possibility, but retained the same constructions in all languages. 3
Most controlled language systems provide some kinds of authoring tools which guides
the user how to stay within the scope of the grammar. The following picture shows a
translator client using a GF web server. It has a completion parser, which here shows
grammatically correct completions of the letter B in the middle of a German sentence.
The system uses the parsing algorithm described in
Usually tools like this work with context-free grammar and top-down incremental parser. The problem with this is that the context-free grammars cannot represent well all naturall languages. Even if this somehow works for English, it becomes hopeless for languages with more complicated structure. The parser that we use works directly with full GF and can therefore successfully handle long distance relations and discontinuous phrases. 4
Writing the GF implementation was quick and mostly smooth. The main problem was that some ACE structures are not quite correct in standard English, and therefore not covered by the library. One example is negated noun phrases, especially in the object position: John meets not every customer. Porting the grammar to other languages was made in the simplest possible way, by using a parametrized module. The result is mostly acceptable: grammatically correct but sometimes strange, especially for constructs like not every. This could be improved by making the concrete syntaxes more unlike Attempto English than we did. On the other hand, since Attempto French, German, and Swedish are artificial languages anyway, such artificialities might well be tolerable in them, as long as they can be understood without training.
The Attempto project has a system for parsing Attempto English, interpreting it semantically, and generating it from formal descriptions such as ontologies. Similar facilities can been defined in GF as well. However, in the case of Attempto this is not necessary: we can quite as well rely on Attempto tools and use GF just as a translation and authoring tool. Then we can communicate with Attempto tools by using Attempto English (which is unambiguous): translate Attempto French, German, and Swedish to English by using GF, and continue processing with Attempto tools. In the other direction, we can generate Attempto English from logical descriptions using Attempto tools, and then translate the results to French, German, and Swedish with GF.