Syntax and Semantics of Fluid Construction Grammar

3 downloads 0 Views 844KB Size Report
A Feature Structure (FS) is an unordered list of units2 and a unit is a list starting with a ..... [6] De Beule, J., Steels, L.: Hierarchy in Fluid Construction Grammar. In.
Syntax and Semantics of Fluid Construction Grammar Pieter Wellens, Vanessa Micelli, Remi van Trijp

1

Introduction

Fluid Construction Grammar’s (FCG) linguistic perspective is in the general line of cognitive linguistics and construction grammar [1, 2] and like many other contemporary theories it is feature structure- and unification-based. It is currently the only computational construction grammar formalism that can handle both parsing and production using the same set of constructions rather than using separate generation and parsing procedures as is done in other formalisms. So far, FCG has mainly been applied in research on the emergence and evolution of grammatical phenomena [3]. This document will detail the syntax and semantics required for writing FCG constructions of varying complexity.1

2

Syntax and Semantics of FCG

The core data structure in FCG is a Coupled Feature Structure (CFS). As the name implies this is a coupling of two feature structures divided by . These two feature structures are also referred to as left-pole and right-pole and in general (but not necessarily) the left-pole contains the semantics of the structure, the right pole the syntax. A Feature Structure (FS) is an unordered list of units2 and a unit is a list starting with a name (which has to be unique in the feature structure) followed by the actual features. A list encloses its elements within parentheses, thus a list of the elements a b and c is written as (a b c). A list can also include sub-lists as for instance the list (e f) instead of the element c which results in the list (a b (e f)). A feature then is a list starting with a name (which has to be unique in the unit, not in the feature structure) followed by its value which can be any sort of (nested) list structure3 . The template for a coupled feature structure looks like this: 1 The interested reader is pointed to www.fcg-net.org to find links to our publications and more information on FCG. 2 For linguists it might be helpful to think of units as constituents. 3 There is one feature, the referent feature, where the value should not be a list but can be a single symbol. But this is an exception to the rule.

1

Babel web interface

Coupled Feature Structure

((unit-1-name (feature-name-1 values) // values should be a list Feature Structure (feature-name-2 Coupled values)) // unique feature-names in the unit ((unit-1-name (unit-2-name //unit-1-name unique unit-names in the FS unit-2-name (feature-name-1 values)values) // values should be afeature-names list (feature-name-2 // non unique in the FS (feature-name-2 values)) // unique feature-names in the unit (feature-name-3 values))) unit-2-name (unit-2-name // unique unit-1-name unit-names in the FS (feature-name-2 values) to//the nonleft-pole) unique feature-names in the FS right-pole (similar feature-name-1 values feature-name-2 values (feature-name-3 values))) subunits (unit-2-name) feature-name-3 values right-pole (similar to the left-pole)

Note that a unit cannot contain another unit (i.e. they cannot be nested) unit-1-name and thus you cannot in this way build a tree-like feature structure. Inunit-2-name FCG a tree structure built byanother using afeature-name-1 special feature of which the values feature-name-2 values Note that a unit cannotis contain unit (i.e.subunits they cannot be nested) and value is a list of unit-names. thus you cannot in this way build a tree-like feature structure. Instead in FCG subunits (unit-2-name) feature-name-3 values 1 2is built by using a special subunits feature of which the value a tree structure is a list of unit-names as shown below. unitunitunitunitunitunitSubunits Example 1 2 2 2 2 2 ((unit-1 (subunits (unit-2 unit-3))) (unit-2 (subunits (unit-4))) (unit-3) (unit-4)) (a) FS in list representation

unit-2

unit-4

unit-1 unit-3 reset

(b) FS graphically

a tree4 Language processing in FCG always starts from an initial coupled feature Feature Structure structure consisting of one Basic unit atCoupled both sides containing either only meaning (in ((top-unit production) or only form (in parsing). This CFS is then gradually modified by (meaning (() applying a sequence of FCG constructions. These constructions are also coupled feature structures but they can contain variables and special FCG operators that guide the unification process. An FCGofvariable is represented as a symbol that FCG constructions are pairings form and meaning, whereby a construcstarts with question ismark. During and unification it canframe-semantic be bound to a information symbol, a tion’sa meaning frame-based incorporates list or another variable, butmeaning of coursefeature only to oneinvalue (check the examples). both directly in its and its semantic categories (more information below).

Unification Examples

(unify ’(a b (c)) ’(a b (c)))Basic // unifies (both lists are equal) FCG Construction (unify ’(a ?x c) ’(a b c)) // unifies and binds variable ?x to b 4 In fact it can be a set of trees, but this capability is currently not used. (unify ’((a (?z)) ?z) // won’t unify because ?z ’((a (b)) c)) // should be bound both to b and c (unify ’(a b) ’(b a)) // won’t unify because the order differs (unify ’(a b c) ’(a b)) // won’t unify because of c

FCG Special Operators

2 The FCG special operators guide the unification process by making it either more flexible or stricter. This section gives an overview of the most important ones. These operators are normally put at the beginning of a list and affect the values of that list.

unit2

Includes Operator (==) functionality The includes operator allows the list to be a sub-list of the other list and the ordering doesn’t matter. example The last two examples from above will work by adding the includes operator. (unify ’(== a b) ’(b a)) (unify ’(== b a) ’(a b c))

Includes Uniquely Operator (==1) Functionality The includes uniquely operator is like the includes operator but doesn’t allow elements from the list to appear more than once in the other list. If the element is a list it only checks the first element of this list. Example (unify ’(==1 a b) ’(a a b)) // won’t unify although == would (unify ’(==1 (a)) ’((a) (a b))) // won’t unify

Includes Not Operator (==0) Functionality The Includes Not operator essentially disallows the elements that follow to appear in the other list. Even if one of them appears, it is enough to block the unification (also the ordering doesn’t matter). Example (unify ’(==0 a b c) ’(x)) // unifies (unify ’(==0 b a c) ’(a)) // does not unify

Permutation Operator (==p) Functionality The permutation operator allows the other list to be a permutation of the list (i.e. the order doesn’t matter). Example (unify ’(==p ?x b) ’(b a)) (unify ’(==p c a) ’(c b a))

// This won’t unify, although == would

The above extensions allow us to write FCG constructions such as the one shown in figure 2. Remark that unification in FCG never adds elements, except when binding variables and thus works differently than HPSG unification [4]. Adding elements is done by another operation called merge. Just like unification, merging requires two feature structures of which only one can contain special operators. We call the feature structure containing the special operators the pattern and the other one the source.4 The merger will look for any extension of the source so that 4 FCG

constructions are thus patterns and the feature structures they apply on the source.

((?top-unit (sem-subunits (?noun-unit)) (meaning ((det ?ref [THE]))) (footprint (==0 det-noun))) (?noun-unit (referent ?ref))) ((?top-unit (form ((string ?det-unit "the") (meets ?det-unit ?noun-unit))) (syn-subunits (?noun-unit)) (footprint (==0 det-noun))) (?noun-unit (syn-cat (==1 (pos noun))))) ((?top-unit (sem-subunits (== ?noun-unit)) (meaning ((det ?ref [THE]))) (footprint (==0 det-noun))) Babel web interface (?noun-unit (referent ?ref))) the+noun, g154314

((?top-unit (form (== (string ?det-unit "the") (meets ?det-unit ?noun-unit))) (syn-subunits (?noun-unit)) http://localhost:8000/ (footprint (==0 det-noun))) (?noun-unit (syn-cat (==1 (pos noun)))))

(c) FCG construction in list representation.

Remark that unification in FCG never adds elements, except when binding variables and thus works differently than HPSG unification [ref]. Adding ele?top-unit-139 ?top-unit-139 ments another operation called merge. Just like unification, merging form ?noun-is done by ?noun-unit-105 meaning sem synonly ((string unit-105 two feature requires one can?det-unit-31 contain special operators. ((detstructures ?ref-90 of which syn-cat "the") ʊ ʈ [the])) (==1and (meets ?det-unit-31 We call the feature structure containing special operators the pattern referent save the (pos noun)) ?noun-unit-105)) ?ref-90 4 footprint the other one the source . The merger will look for any extension of the source (==0 det-noun) footprint (==0 det-noun) so that it would unify with the pattern. (d) FCG construction in graphical representation FCG-Merge Examples

reset

(fcg-merge ’a ’a) // returns ’a (fcg-merge ’(a) ’(a)) returns ’(a)containing special operators. Figure 2: An FCG//construction (fcg-merge ’(a) ’(a b)) // does not merge (fcg-merge ’(== a) ’(a b)) // returns ’(a b) (fcg-merge ’(a b) ’(a)) // returns ’(a b) it would unify with the pattern. In the examples below the pattern is (fcg-merge ’(==0 a) ’(b)) // returns ’(b)

parameter, the source the second.

the first

FCG-Merge Examples Merging can also return multiple hypotheses, for example: (fcg-merge ’a ’a) // returns ’a (fcg-merge a) ’(a b c)) (fcg-merge’(== ’(a)?x’(a)) // returns ’(a) (fcg-merge ’(a) ’(a b)) // does not merge returns ’(a b’(== c) with ?x bound to returns either b or’(a c. b) (fcg-merge a) ’(a b)) // Before we ’(a continue with more//advanced (fcg-merge b) ’(a)) returnsways ’(a to b)alter the feature structure there is one last keya)idea crucial the understanding of grammatical con(fcg-merge ’(==0 ’(b)) // to returns ’(b)

structions in FCG. This is the idea of linking through variable equalities. Both unification and merging are capable of making two distinct variables refer to Merging can alsoWe return multiple hypotheses, the same binding. call this a variable equality. for example: 4 FCG constructions (fcg-merge ’(== ?x b c)) are a) thus’(a patterns and the feature structures they apply on the source.

returns ’(a b c) with ?x bound to either b or c. Before we continue with more advanced ways to alter the feature structure there is one last key idea crucial to the understanding of grammatical constructions in FCG. This is the idea of linking through variable equalities (see [5]). As noted earlier one variable cannot be bound to multiple values but multiple variables can be bound to the same value (which can be a variable itself), we call this a variable equality.

2.1

Modification of Units and Moving Information between Units

Although we can now modify structures by merging in new information this is not powerful enough to build the complex constituent structures needed for processing natural language. In fact there are three important operations we currently cannot achieve:

1 of 1

28/01/10 11:06

1. We are unable to create new units.5 2. We cannot relocate existing (or new) units in the tree. 3. We cannot move features from one unit to another. In what follows we will show how we have solved these problems in FCG through a special tree manipulation operator called the J-operator [6]. The J-operator is specified inside the feature structure itself and resides at the same level as the units, which is why we refer to the declarations of these operations as J-units. Such a J-unit doesn’t however specify a unit at all, but instead specifies operations on a unit. To distinguish it clearly from “normal” units a J-unit does not start with a symbol (the unit-name) but instead with a list starting with the symbol J. A J-unit specifies operations for only one unit, called the focus unit. Of course a feature structure can contain multiple J-units allowing operations on multiple units. The focus unit therefore is the only parameter you are required to supply. ((?top (form ((string ?top "big")))) ((J ?new-unit) (syn-cat ((pos adjective)))))

The above feature structure consists of only one “real”unit ?top and one J-unit. When merged it will create a new unit ?new-unit containing the syntactic category adjective. It’s that easy to create new units and as shown in the example, the body of a J-unit (i.e. the part after the initial list) resembles that of a regular unit in that it can contain feature value pairs. Although we can now create new units we would still like to specify where it should be located in the feature structure tree. This is, we would like to specify its parent unit and optionally even child units. This can be done by two optional parameters following the focus unit, first specifying the parent and then a list of children as shown in figure 3. In the examples so far the focus unit has always been a reference to a new unit. The focus unit however, can refer to an existing unit as well. It will then not create a new unit but operate on the referred unit. From the three missing operations presented above we have now addressed the first two. All that remains is the moving of features from one unit to another (existing or new) unit. To move something from A to B you need a way to mark the thing you wish to move and whereto. Marking what feature value pair you wish to move is done by the tag-operator which allows you to bind a featurevalue pair to a variable. It has the following syntax: (tag ?tag-name (feature value)) 5 This could be done by merging, but not for complex trees and this would also cause problems with the bi-directionality of FCG.

((?top (unit-1 (syn-subunits (== ?creator ?created ?create)) ?top((string unit-1 ‘‘FCG’’))) (form (form (== (meets ?creator ?create) (syn-cat (ref-expression))) (meets ?create ?created))) form ((string ?top "big")) (unit-2 (syn-cat (==0 S))) (form ((meets unit-4 unit-5))) (?creator (syn-cat ((pos verb))) (syn-cat (==1 ref-expression))) (syn-subunits (unit-4 unit-5))) ?new-unit (?create (unit-4 (form ((string unit-4 ‘‘produce’’)))) (syn-cat (==1 (pos verb)))) adjective)) syn-cat ((pos (?created (unit-5 (syn-cat (==1 ref-expression))) (form ((string unit-5 ‘‘-s’’)))) ((J ?new ?top (?created ?create ?creator)) (unit-3 unit-1 (syn-cat (ref-expression)))) (syn-cat (S))))

Babel

(a) Syntactic Feature Structure (b) Syntactic pole of an FCG construction ((?top 6 (syn-subunits (== ?creator ?created ?create)) J-operator and J-units unit-4 (form (== (meets ?creator ?create) (meets top unit-2?create ?created))) Functionality The J-operator allows to bu (syn-cat (==0 S))) ((top unit-5 (?creator web interface is to specify how the http://localhost:8 construction m (syn-subunits (unit-1 unit-2 unit-3)) (syn-cat (==1 ref-expression))) (form ((meets unit-1 unit-2) they can also be used for modifying e (?create (meets unit-2 unit-3)))) (syn-cat (==1 (pos verb)))) unit-3 with a TAG operator (see below), for m ((?top (unit-1 (?created (syn-subunits (== ?creator ?created ?create)) On the surface, a J-unit looks like a r (form ((string unit-1 ‘‘FCG’’))) (syn-cat (==1 ref-expression))) (form (meets ?creator ?create) (syn-cat (ref-expression))) ((J ?new(== ?top (?created ?create ?creator)) which is a symbol in case of a regula top (meets ?create ?created))) ?top (syn-cat (S)))) (unit-2 (syn-cat (==0 S))) (J name parent children), instructi (form ((meets unit-4 unit-5))) ?top "big")) form ((string (?creator (syn-cat ((pos verb))) to by name a subunit of the parent un unit-1 (syn-cat (==1 J-operator andref-expression))) J-units (syn-subunits (unit-4 unit-5))) in the children slot subunits of the un (?create (unit-4 (syn-cat (==1 (pos verb)))) (form ?top ((string unit-4 ‘‘produce’’)))) Functionality The J-operator allowsExample to build J-units. Their main purpose unit-4 (?created (unit-5 is to (==1 specify how the construction modifies constituent structure, but ((string ?top "big")) (syn-cat ref-expression))) (form unit-5 ‘‘-s’’)))) form ((string new-unit unit-2 (unit-3 ((J ?new ?create ?creator)) existing units and, when combined they ?top can (?created also be used for modifying (syn-cat (ref-expression)))) (syn-cat (S)))) unit-5

?new-unit

with a TAG operator (see below),TAG-operator for moving information between units.

((?top the surface, J-unit like a regular unit except that its name, (a) Syntactic Feature Structure (b)On Syntactic pole ofa an FCGlooks construction (syn-subunits (== adjective)) ?creator ?created ?create)) ((pos syn-cat Functionality unit-3 J-operator and J-units which is a symbol in case of a regular unit, is now a list of the form (form (== (meets ?creator ?create) (J name parent children), instructing fcg to make the unit referred (meets ?create ?created))) Example Functionality The J-operator allows to build Their purpose (syn-cat (==0 S))) to by name a subunit of the parent unit, and J-units. to make all unitsmain specified unit-1 unit-1 (?creator is to specify how the construction modifies constituent structure, bu in the children slot subunits of the unit referred to by name [5]. (syn-cat (==1 ref-expression))) they can also be used for modifying existing units and, when combined (?create Example unit-4 unit-4 (syn-cat (==1 (pos verb)))) with a TAG operator (see below), for Predicate moving information between units String (string item-1 string-1 (?created top new-unit unit-2 top unit-2 (syn-cat (==1 ref-expression))) On the surface, a J-unit looks like a regular unit except that its name ((J ?new ?top (?created unit-5 ?create ?creator)) unit-5 stringapredicate determ which is a symbol in case ofFunctionality a regular unit,The is now list of the form TAG-operator (syn-cat (S))))

FCG Form Predicates

form. fcg to make the unit referred (J name parent children), instructing Functionality unit-3 to by name a subunit of the parent unit, and to make all units specified J-operator and J-units Example in the children slot subunits of the unit referred to by name [5]. Functionality The J-operator allows to build J-units. Their main purpose top reset (c) Example is to specify how the construction modifies structure, but FCG Form constituent Predicates they can also be used for modifying existing units and, when combined unit-1 Figure 3: Transformation of a feature structure by aitem-1 J-unit. String Predicate (string with a TAG operator (see below),TAG-operator for moving information between string-1) units. On the surface, a J-unit looks like a regular unit that its name, Functionality Theexcept string predicate determines that item-1 has string-1 as its unit-4 Functionality which is asimply symbolput in the case tag of avariable regular unit, ?tag-name) is now a list in of the the body form of a form. unit-2 Younew-unit can then (i.e. (J name parent children), instructing fcg to make the unit referred Example unit-5 value pair should be moved to. It works like J-unit to mark where the feature to by name a subunit of the parent unit, and to make all units specified cut and paste, you cut by the tag-operator and paste by placing the tag-variable in the children slot subunits of the unit referred to by name [5]. unit-3 in a J-unit. This means the body of a J-unit also allows at the desired location Example these tag-variables to reside there next to feature value pairs. You cannot refer unit-3

unit-1 to a tag-variable in regular units. An example is shown in figure 4 where a very small initial feature structure containing only one unit with some meaning is TAG-operator unit-4 transformed into a a new feature structure containing two units and where the Functionality top meaning new-unit tagged is movedunit-2 from one to the other. unit-5looks as follows: To conclude the syntax of a J-unit Example ((J focus parent children) unit-3 FCG body) Form Predicates

String Predicate string-1) with focus the only(string requireditem-1 parameter being a new variable or one of an existing reset unit. Parent should be a variable referring an item-1 existing and as children a Functionality The string predicate determinestothat hasunit string-1 its list ofform. existing unit variables. Body can contain tag-variables next to regular feature value pairs. 1 of 1

to a tag-variable regular units. (det xin[THE]))))) to a tag-variable in regular units.

((top ((?top (meaning ((river x) ((top (TAG ?tagged-meaning (tag ?tag-name (feature value)) 7 7 (det [THE]))))) (meaning ((river (meaning (==xx) (river ?x))))) 7 (det x [THE]))))) ?river(i.e. ?top) You can then simply put the tag((J variable ?tag-name) in the body of a ((?top (referent ?x) (tag ?tag-name (feature value)) J-unit to mark where the feature value pair should It works like (TAG ?tagged-meaning ((?top 7 (tag ?tag-name (feature value)) ?tagged-meaning be moved to. 7 (meaning (== (river ?x))))) (TAG ?tagged-meaning 7 cut paste, you cut by the tag-operator and paste by placing the tag-variable (tagand ?tag-name (feature value)) (sem-cat (== natural locale)))) You can then simply put the tag variable (i.e. ?tag-name) in the body of a ?river ?top) (meaning (river ?x))))) thenlocation simplytoinput the tag((J variable (i.e. ?tag-name) in the body of a like J-unit mark where the feature value pair should moved to. It works atYou the can desired a J-unit. This means the(== body of abe J-unit also allows (referent ?x)?tag-name) in the body of a ((J ?river ?top) ((top (tag ?tag-name (feature value)) You can then simply put the tag variable (i.e. cut and paste, you cut by the tag-operator and paste by placing the tag-variable J-unit to mark where the feature value should bepairs. moved to. It works like these tag-variables to reside there next to pair feature value You cannot refer ?tagged-meaning (referent ?x) 7 (meaning ((det x [THE]))) (tag ?tag-name (feature at the desired location in avalue)) J-unit. This means the body of also allows J-unit to paste, mark where the feature value pair should beby moved to. Ita J-unit works like cut and you cut the tag-operator and paste placing the tag-variable (sem-cat (== natural locale)))) to a tag-variable inYou regular units. ?tagged-meaning canbythen simply put the tag variable (i.e. ?tag-name) in the body of a 7 (sem-subunits (river-unit))) these tag-variables to reside there next to feature value pairs. You cannot refer cut and paste, you cut by the tag-operator and paste by placing the tag-variable (sem-cat (== natural locale)))) You can to then put tag variable (i.e.should ?tag-name) in theallows of like a (river-unit J-unit where thethe feature value moved to. Itbody works at the desired location inmark a simply J-unit. This means thepair body of abe J-unit also to a tag-variable in regular units. ((top ((top (meaning ((river x))) J-unit to mark where the feature value pair should be moved to. It works like atthese the desired location in a J-unit. This means the body of a J-unit also allows cut and paste, you cut by the tag-operator and paste by placing the tag-variable tag-variables to reside there next to feature value pairs. You cannot refer (meaning ((det xand [THE]))) ((top (meaning ((river x)reside x) cut and paste, you cut(referent by tag-operator paste placing the tag-variable atin the desiredthere location inthe a J-unit. This means the by body of a J-unit also allows these to next to feature value pairs. You cannot refer ((top to a tag-variables tag-variable regular units. (sem-subunits (river-unit))) (meaning ((det x [THE]))) (det these xthe[THE]))))) (sem-cat (natural locale)))) desired location in a J-unit. This means the body of a J-unit also allows (meaning ((river x) tag-variables to reside there next to feature value pairs. You cannot refer to a tag-variableatin regular units. (river-unit (sem-subunits (river-unit))) (det x(b) [THE]))))) (a) Initial Semantic these Feature Structure Final Semantic Feature Structurevalue after pairs. You cannot refer tag-variables to reside there next to feature to a tag-variable in regular units. ((top (meaning ((river x))) (river-unit ((?top construction application to a tag-variable inJ-operator regular units. and ((top (meaning ((river x) (referent x) J-units (meaning ((river x))) ((?top (TAG ?tagged-meaning ((top (meaning ((river (det xx) [THE]))))) (sem-cat x) (natural locale)))) (referent (TAG ?tagged-meaning (meaning (== (river ?x))))) (meaning ((river x) ((top Functionality The J-operator allows to build J-units. Their ma (meaning (== (river ?x))))) (det (meaning x [THE]))))) (sem-cat (natural (det x(b) [THE]))))) ((J (a) ?river ?top) ((river x) Initial Semantic Feature Structure Final Semantic Featurelocale)))) Structure after ((J ?river ?top) ((?top is Semantic to application specify how the construction modifies constituent str (det x(b)construction [THE]))))) (referent ?x) Feature (a) Initial Semantic Structure Final Feature Structure after (referent ?x) J-operator and J-units ((?top ((?top (TAG ?tagged-meaning construction application ?tagged-meaning they can also be used for modifying existing units and, whe ?tagged-meaning J-operator and J-units (TAG (river ?tagged-meaning ((?top (TAG ?tagged-meaning (meaning (== ?x))))) (sem-cat (== natural locale)))) (sem-cat (== natural locale)))) with a TAG operator (see below), for moving information betm Functionality The J-operator allows to build J-units. Their (meaning (== (river ?x))))) (TAG (river ?tagged-meaning (meaning (== ?x))))) ((J ?river ?top) ((J ?river ?top) (c) Semantic pole of the applicable FCG conFunctionality The J-operator allows to build J-units. Their ms (meaning (== (river ?x))))) On the surface, a J-unit looks like a regular unit except is to specify how the construction modifies constituenttha ((J(referent ?river ?top) ?x) ((top ((top struction ?x) ((J(referent ?river ?top) is to specify how the construction modifies constituent str (meaning ((det x [THE]))) (referent ?x) (referent which symbol in case a regularexisting unit, isunits now and, a listwho ?tagged-meaning they is cana also be used for of modifying (meaning ((det x ?tagged-meaning [THE]))) ?x) (sem-subunits (river-unit))) ?tagged-meaning Figure 3: Transformation of a feature bywith aname J-unit including tags. (see Note they can also be children), used for modifying existing units and,the whe (sem-cat (== (river-unit))) natural locale)))) (sem-cat (==structure natural locale)))) ?tagged-meaning (J parent instructing fcg to make u a TAG operator below), for moving information b (sem-subunits (river-unit (sem-cat (== natural locale)))) (sem-cat (== natural locale)))) that (river x) is moved from top unit to the newly created river-unit (c) Semantic pole of the applicable FCG conwith a TAG operator (see below), for moving information bet (river-unit to by name a subunit of the parent unit, and to make all un (meaning ((river x))) On the surface, a J-unit looks like a regular unit except th ((top ((top (c)struction Semantic of the applicable FCG con(meaning ((river x))) pole (referent x) On thechildren surface, a J-unit looks like aunit regular unit except tha (meaning ((det x [THE]))) in the slot subunits of the referred to by name which is a symbol in case of a regular unit, is now a list ((top ((top (meaning x) ((det x [THE]))) struction (sem-cat (natural locale)))) (referent (sem-subunits ((det structure x(river-unit))) [THE]))) which is a parent symbol in case regular unit, a list Figure 3: Transformation of a feature by aname J-unit includingchildren), tags. Noteof ainstructing ((top (J fcgistonow make the (meaning ((det (meaning x [THE]))) (sem-subunits (river-unit))) (sem-cat (natural locale)))) (river-unit (sem-subunits (river-unit))) (meaning ((river x) Figure 3: Transformation of a feature structure by aname J-unit including tags. Note Example that (river x) is moved from top unit to the newly created river-unit (J parent children), instructing fcg to make the u (sem-subunits (river-unit))) (river-unit to by name a subunit of the parent unit, and to make all u (meaning ((river x))) (river-unit x J-operator [THE]))))) and to J-units that (river x)(det is moved from top ((river unit newly created river-unit (river-unit (meaning ((river x))) (referent x) the name a subunit of the parent unit, and to make all un (meaning x)))toinby children slot tags. subunits Figure 4: Transformation of a feature structure bythe a J-unit including Noteof the unit referred to by nam (sem-cat (natural locale)))) (meaning ((river x))) x) (referent (referent x)Functionality J-operator and J-units ((?top The J-operator allows to build J-units. Their main in the children slot subunits of the unitpurpose referred to by name TAG-operator that((top (river x) is moved from top unit to the newly created river-unit (sem-cat (natural locale)))) (TAG ?tagged-meaning (referent x) (sem-cat (natural locale)))) is to specify how the construction modifies constituent structure, but (meaning ((river x) Example ((top (meaning (== (river ?x))))) Functionality The J-operator allows J-units. Their purpose (sem-cat (det (natural locale)))) xx) [THE]))))) J-operator J-units they can and alsoFunctionality be usedtoforbuild modifying existing unitsmain and, when combined (meaning ((river

Example ((J ?river ?top) (det x J-operator [THE]))))) and J-units (see modifies is to ?x) specify how construction structure, butunits. (referent withthe a TAG operator below), forconstituent moving information between J-operator and J-units ((?top Functionality The J-operator allows to build J-units. Their main purpose Example TAG-operator ?tagged-meaning On the surface, a J-unit looks like a regular unit except that itspurpose name, they can also be used for modifying existing units and, when combined (TAG ?tagged-meaning J-operator J-units ((?top Functionality The J-operator allows to build J-units. Their main is to specify how the construction modifies constituent structure, but (sem-cat (== and natural locale)))) TAG-operator (meaning (== (river ?x))))) which is a symbol in case of a regular unit, is now a list of the form (TAG ?tagged-meaning Functionality The J-operator allows to build J-units. Their main purpose a TAG operator (see below), for moving information between units. So far((J wewith have been concentrating on unification and merging of single feature is to specify how the construction modifies constituent structure, but Functionality they can also be used for modifying existing units and, when combined ?river ?top) (meaning (==The (river ?x))))) name parent instructing fcg to make unit referred ((top 6is to specify Functionality J-operator allows J-units. Their main purpose how the construction modifies constituent structure, butunits. Functionality structures . We will now (J focus on coupled feature structure and how they arethe they can also be children), used for modifying existing units and, when combined On the surface, awith J-unit looks liketo(see a build regular except that its name, (referent ?x) a TAG operator below), unit for moving information between ((J ?river ?top) (meaning ((det x [THE]))) to by name a subunit of the parent unit, and to make all units specified Example ?tagged-meaning is to specify how the construction modifies constituent structure, but (referent ?x) with athe TAG operator (see below), forisunits moving information between processed in bi-directional language processing. Onused surface, a regular J-unit looks like a now regular unit except that itsunits. name, they can also be for modifying existing and, when combined (sem-subunits (river-unit))) which is a symbol in case of a unit, a list of the form (sem-cat (== naturalinlocale)))) Example the slot subunits oflike the units referred toexcept by name [5].its name, ?tagged-meaning (river-unit On thechildren surface, aboth J-unit looks aunit regular unit that they can also be used for modifying existing and, when combined which is a symbol in case of a regular unit, is now a list of the form Fluid Construction Grammar supports production (generation in HPSG with a TAG operator (see below), for moving information between units. (J name parent children), instructing fcg to make the unit referred (sem-cat ((river (== natural (meaning x))) locale)))) which is a same symbol inoffor case of ainstructing regular unit, is tonow a list ofunit thereferred form (J name parent children), fcg make the ((topwithand terminology) parsing using the set constructions. Both start with a TAG operator (see below), moving information between units. Example (referent a J-unit likeunit, a regular except that specified its name, toOn byx)the namesurface, a subunit of parent thelooks parent and tounit make all make units (meaning ((det x [THE]))) (J children), instructing fcg the by name a subunit of the parent unit, andto tothat make all unit unitsreferred specified (sem-cat (natural locale)))) an((top initial coupled feature structure that contains either only meaning (in pro-of On thechildren surface, atoname J-unit looks like aunit regular unit except its name, (sem-subunits which is a[THE]))) symbol in case of a regular unit, is now a list the form in the slot subunits of the referred to by name [5]. (meaning ((det x(river-unit))) to by name a subunit of the parent unit, and to make all units specified in the children slot subunits of the unit referred to by name [5]. duction) or formis(in parsing). coupled feature structure the akey data (river-unit (sem-subunits (river-unit))) which aTAG-operator symbol inThis case ofslot ainstructing regular unit, istois now list of the [5]. form (J name parent make the unit in thechildren), children subunits of fcg the unit referred to by namereferred (meaning ((river x))) (river-unit structure of the language processing. It is this structure that will be modified FCG Form Predicates Example (Jto name parent children), instructing unit referred Example (referent x)name by a subunit of the parent unit,fcg andtotomake makethe all units specified Functionality (meaning ((river x))) by applicable constructions finally resulting in a much larger feature structure (sem-cat (natural locale)))) Example (referent x) to by name a subunit of the parent unit, and to make all units specified String Predicate (string item-1 string-1) in the children slotmeaning. subunitsAofhigh the level unitview referred to processing by name [5]. containing the(natural inferred form and of such Example (sem-cat locale))))

3

Language Processing in FCG

TAG-operator in the children slot subunits of the unit referred to by name [5].

TAG-operator Functionality The string predicate determines that item-1 has string-1 as its shown in figure TAG-operator FCG Form5. Predicates Example form. Functionality As is Form clear from figure 5 applying a construction consists of at least two FCG Predicates Functionality Example String Predicate (string item-1 string-1) Functionality phases, a unification phase and a merge phase. As explained in section 2 unifiExample String Predicate (string item-1 string-1) TAG-operator Example cation is quite strict and canpredicate thus be seen as a conditional for the construction Functionality The string determines that item-1 has string-1 as its Example TAG-operator Theboth stringleft predicate determines thatcoupled item-1 has string-1 as its but to Functionality apply. form. We do not and right pole of the feature structure onlyFunctionality theform. left pole in production and the right-pole in parsing. When unification Functionality of the required pole is successful both poles of the construction are merged with Example theExample central coupled feature structure. 6 We

take J operations to be part of merging.

Initial constructions CFS

CFS modified by cxn 3 and 72

constructions

CFS modified by cxn 2

CXN 1

CXN 1 CXN 2

UNIFY

CXN 2

MERGE

UNIFY

UNIT A

MERGE

... UNIFY

UNIT A

CXN 3

CXN 72 CXN 73

UNIT B MERGE

UNIT C

UNIT A

CXN 3

... CXN 72

UNIT B

UNIT D

...

UNIT C

CXN 73

Figure 5: A schematic high level depiction of language processing in FCG. From left to right you start with an initial coupled feature structure (cfs). Every construction tries to unify with the cfs and those that can, can merge with the cfs thereby altering it and potentially allow other constructions to unify. This process is repeated until no constructions can apply any longer.

References [1] Goldberg, A.E.: Constructions: A Construction Grammar Approach to Argument Structure. University of Chicago Press (1995) [2] Langacker, R.: Grammar and Conceptualization. Mouton de Gruyter, Den Haag (2000) [3] van Trijp, R.: The emergence of semantic roles in Fluid Construction Grammar. In Smith, A.D., Smith, K., Ferrer i Cancho, R., eds.: The Evolution of Language. Proceedings of the 7th International Conference (EVOLANG 7), Singapore, World Scientific Press (2008) 346–353 [4] Pollard, C.J.: The syntax-semantics interface in a unification-based phrase structure grammar. In Busemann, S., Hauenschild, C., Umbach, C., eds.: Views of the Syntax/Semantics Interface. Number 74 in KIT-FAST Report. Techical University of Berlin, Berlin (1989) 167–185 [5] Steels, L., Beule, J.D., Neubauer, N.: Linking in fluid construction grammar. Proceedings of BNAIC 2005 (2005) 11–18

[6] De Beule, J., Steels, L.: Hierarchy in Fluid Construction Grammar. In Furbach, U., ed.: KI 2005: Advances In Artificial Intelligence. Proceedings of the 28th German Conference on AI. Volume 3698 of Lecture Notes in Artificial Intelligence., Koblenz, Springer (2005)