ENHANCING A ROLE AND REFERENCE GRAMMAR APPROACH TO ENGLISH MOTION CONSTRUCTIONS IN A NATURAL LANGUAGE PROCESSING ENVIRONMENT

This paper puts forward a finer-grained computational treatment of the English causedmotion construction (e.g. He kicked the ball into the net) within a knowledge base for natural language processing systems called FunGramKB. This computational project is largely based on Role and Reference Grammar (RRG), which is a functional projectionist theory of language. We argue that the RRG-based characterization of the caused-motion construction in FunGramKB is insufficient to account for the semantic and syntactic complexity of realizations such as He walked the dog to the park, I will show you out, or Mac flew Continental to Bush International Airport. Thus, drawing on insights from Constructions Grammars, three minimally distinct transitive motion subconstructions are formalized within FunGramKB. It is through the inclusion of additional constructional schemas that the machine will be able to capture the various ways in which verbs and constructions interact to yield different input texts.

In the field of Natural Language Processing (NLP), the development of probabilistic approaches has gradually relegated linguistic models to a marginal position (Periñán 2012: 13; see also Callison-Burch and Osborne 2003;Bod 2009).However, Nolan and Periñán (2014: 2) point out that, with the rise of the Semantic Web and the existence of a multilingual, globalized world, "the need for language aware software applications that are grounded in a robust linguistic model, with a robust model of semantics, is […] critical to our society".Similarly, several scholars have emphasized the numerous ways in which theoretical linguistics can enhance NLP (and vice versa), and therefore, the need to bridge the gap between these areas of research (cf.Dimitriadis 2010;Sharma 2010;Cambria and White 2014;Diedrichsen 2016;Nolan 2016).This is especially important given that, in order to avoid deceptively intelligent NLP applications and allow natural language understanding instead, NLP systems require sound linguistic models laying at their foundation (see Periñán and Mestre 2016: xxi).This is the case of the English knowledge base known as FrameNet (Baker 2014).
FrameNet, which is based on Frame Semantics (Fillmore 1976(Fillmore , 1982;;Fillmore and Atkins 1992), aims to record "the range of semantic and syntactic combinatory possibilities -valences-of each word in each of its senses" (Ruppenhofer et al. 2010: 5).
Another NLP project that has incorporated a solid linguistic theory into its design is the lexico-conceptual knowledge base for NLP known as FunGramKB (see www.fungramkb.com and references therein).More concretely, the linguistic level of FunGramKB, which includes a Lexicon and a Grammaticon, is grounded in Role and Reference Grammar (RRG; Van Valin and LaPolla 1997; Van Valin 2005), which is a functional projectionist theory of language that has already been implemented in several applications such as Guest's (2008) and Winther-Nielsen's (2009) parsers or Nolan and Salem's (2010) machine translation program called UniArab.
The Grammaticon of FunGramKB, which is the module that concerns us here, stores linguistic constructions, that is, entrenched form-meaning/function pairings that exist at all level of linguistic enquiry (cf.Goldberg 2006Goldberg , 2013)).Among the various types of syntactic patterns that together make up the constructicon of a given language, this paper focuses on argument-structure constructions, which are configurations based on the linguistic expression of predicate-argument relationships (Goldberg 1995).In FunGramKB, argument-structure characterizations take the form of machine-tractable representations labeled 'constructional schemata' (cf.Periñán 2013;Mairal and Periñán 2014;Periñán and Arcas 2014;Mairal 2015;Luzondo and Ruiz de Mendoza 2015).As argued in Van Valin and Mairal (2014: 224), although the Grammaticon of FunGramKB rests on some of the basic assumptions of RRG, argument-structure constructions in such a functional model are much less sophisticated semantically than the FunGramKB constructional schemas (see also Jiménez and Luzondo 2013;Nolan 2014).While this is certainly the case, argument-structure constructions may show a great deal of syntactic and semantic variation, which, in some cases, is not captured by the schemata stored in the Grammaticon, let alone in RRG.A case in point is discussed in Goldberg and Jackendoff (2004) under the rubric of 'causative path resultative' or 'caused-motion construction' (e.g. Bill rolled the ball down the hill).This structure, whose basic semantic layout designates a caused change of location, is part of the broader family of English resultative constructions (cf.Peña 2009Peña , 2015Peña : 1263Peña -1274)).
Contrary to Van Valin and Mairal's (2014) claim, we argue that the present formalization of the caused-motion constructional schema in FunGramKB does not do clac 70/2017, 245 justice to the actual complexity of this configuration.This is evidenced by the existence of corpus-attested realizations such as I'll see you to the door (Google Books American Corpus; GBAC 2015), He flew Continental to Bush International Airport (Corpus of Contemporary American English; COCA 2000), etc., which, as will be shown, differ in several ways from the literal example above (cf.Bill rolled the ball down the hill).Thus, this paper contends that, by drawing on insights from another linguistic framework, i.e. (CxGs;Hoffmann and Trousdale 2013;Hoffmann 2017), we can enrich RRG-based constructional schemas within FunGramKB and arrive at a finergrained computational approach of argument-structure constructions.In order for the machine to adequately capture the various ways in which verbs and constructions interact to yield specific input texts, this paper posits additional transitive motion subconstructions that pair particular semantics/pragmatics with very specific syntactic frames, much as it is done in CxG approaches such as the one by Boas (2003Boas ( , 2005Boas ( , 2011)).

Construction Grammars
With this in mind, the structure of this paper is as follows.Section 2 briefly introduces the architecture of FunGramKB.To properly understand the way verbs and constructions combine in this computational resource, section 2.1 deals with the Lexicon and the Ontology, while 2.2.focuses on the Grammaticon and the existing computational treatment of the caused-motion construction.On the basis of this, Section 3 examines the dimensions of variation of such a configuration from a constructionist perspective, paying special attention to their motivation.Such dimensions are shown to escape the current operationalization of the construction at hand.Section 4 summarizes the main points discussed throughout the paper.

A brief introduction to the architecture of FunGramKB
FunGramKB is a user-friendly online environment for the semiautomatic construction of a multipurpose lexico-conceptual knowledge base for NLP systems.It has been designed to be reused in other NLP tasks, and in particular, in those that focus on natural language understanding (e.g. machine translation, dialogue based-systems, etc.).
For example, FunGramKB is being implemented in UniArab, an Arabic-to-English machine translator that uses RRG to build an interlingua architecture for the input text (Salem, Hensman and Nolan 2008;Nolan and Salem 2010;Periñán and Mairal 2010a, clac 70/2017, 246 2012).In addition, the knowledge base offers a multilingual environment that currently supports various western languages (e.g.Spanish, English, Italian, French, etc.).This paper, however, is solely devoted to English.
As shown in Figure 1, FunGramKB comprises three major knowledge levels.The lexical and grammatical levels are language-specific, while the conceptual level is language-independent and therefore shared by all the languages included in the knowledge base.This type of modular approach, in which lexical-semantic knowledge is connected to a target language, while ontological knowledge is language-independent, is consistent with other approaches that are geared towards the development of knowledge bases designed for natural language understanding (e.g.Ovchinnikova 2012).What follows is a brief description of the knowledge levels specified in Figure 1: -The lexical level comprises a Morphicon and a Lexicon.The former handles cases of inflectional morphology.The latter, which preserves some of the basic assumptions of RRG (e.g.'logical structures' or representations containing lexico-semantic information with an impact on syntax), deals with morphosyntactic and collocational information of lexical units (see Mairal and Periñán 2009, for details).
-The grammatical level, or Grammaticon, is the repository of constructional schemata.-The conceptual level is made up of three sub-modules, all of which employ the same metalanguage (i.e.COREL) for the formal codification of different types of knowledge.This ensures that information sharing takes place effectively among all conceptual modules (Periñán and Arcas 2007).The Onomasticon, which handles episodic knowledge, stores information about instances of entities and events (e.g.9/11, Jim Morrison).The Cognicon contains procedural knowledge in the form of scripts (e.g.'going to a restaurant').Finally, the Ontology, in which semantic knowledge is stored, is defined as a hierarchical or IS-A structured catalogue of the concepts that a person has in mind.Since this submodule is the pivot around which the whole knowledge base revolves, FunGramKB qualifies as a conceptualist approach to NLP.
In order to arrive at a general understanding of constructional schemas in FunGramKB, and the current computational treatment of causative path resultatives in specific, we shall address the type of information contained in the Lexicon, the Ontology, and the Grammaticon, as well as the way in which these modules interact with each other.

The Lexicon and the Ontology
In the Lexicon, the most important component in the case of verbal predicates is called 'core grammar' (see Figure 1).This component, which heavily draws on RRG, displays a list of attributes whose values allow the system to build the basic 'conceptual logical structure' (CLS) of verbs automatically (Mairal and Periñán 2016).More concretely, CLSs, which are meant to be employed in NLP applications that require natural language understanding, are automatically built by ARTEMIS ("Automatically Representing Text Meaning via an Interlingua-based System"), i.e. a proof-of-concept NLP system designed "to model the semantic representation of the input text in terms of a CLS" (Periñán and Arcas 2014: 189).CLSs involve a conceptual shift from RRG canonical logical structures, and thus a number of changes in the classical system of representation (see Periñán 2013: 218-220 for details).For example, in the metalanguage employed in the logical structures of RRG, which follows the conventions of formal semantics, constants capture the idiosyncratic meaning of clac 70/2017, 248 predicates ( Van Valin and LaPolla 1997: 102).They appear in boldface followed by a prime together with the required arguments: x, y, z (e.g. the English verb see is stored in the RRG Lexicon by means of the logical structure see'(x,y)).In order to solve some of the shortcomings that logical structures present (e.g. the fact that they only capture syntactically relevant lexico-semantic information or their redundancy in including the definiendum in the definiens; see Mairal, Periñán andPérez 2012, andVan Valin andMairal 2013), constants in the FunGramKB Lexicon have been replaced with ontological concepts (e.g.+SEE_00).These, however, preserve the Aktionsart distinctions posed by RRG.Accordingly, the CLS of see will be +SEE_00 (x,y).
Although it might seem that there are not many differences between both systems of representation, CLSs do offer a more comprehensive representation of meaning, providing a greater amount of information as each concept in the Ontology is defined in terms of two semantic properties, i.e. a 'Thematic Frame' (TF) and a 'Meaning Postulate' (MP).While TFs realize the conceptual arguments that a given concept displays, MPs are sets of one or more logically connected predications (e 1 , e 2 … e n ) that carry the meaning of concepts (Mairal and Periñán 2009: 224).Take the case of +SEE_00, which is identified by means of the following features: From these language-independent representations, the machine "knows" that 'seeing' is a state that prototypically involves two participants: humans or animals (x1), and what is seen or (x2).In addition, it implies that the human or animal perceives something using their eyes.As CLSs contain a finer-grained semantic decomposition, which grants us access to world knowledge, they are employed to represent the meaning of input texts in FunGramKB.
To exemplify the type of information that the system uses to build a CLS, Table 1 presents the core grammar of the English verbal predicate fly: Table 1: Core grammar: The case of fly.
In FunGramKB, lexical entries -or more concretely, the senses of a lexical entry-, are connected to different concepts in the Ontology, as much as the senses of a lexical unit in FrameNet evoke larger schematic representations of a situation type, i.e. 'frames' (Fillmore et al. 2003: 305).For example, fly, Spanish volar, German fliegen, etc., are linked to the ontological unit +FLY_00, from which they get their conceptual representation via the TF and MP.The formal language that allows computational linguists to spell out a machine-readable representation of TFs and MPs is COREL (see Periñán and Mairal 2010b).On the one hand, Figure 2 presents the attributes of fly, which in FunGramKB, like in so-called computational CxGs (e.g.Fluid CxG; Steels 2011Steels , 2012)), are represented through Attribute-Value Matrices (AVMs).In this case, the AVM originates from the information contained in Table 1.Note that AVMs specify the different argumentstructure constructions in which a verb may be embedded.Fly, for example, can be incorporated into the caused-motion construction (cf.CMOT), as in I do know that I picked up a heart […] and I flew it to the hospital (GBAC, 2014).On the other hand, Figure 2 shows the conceptual knowledge in +FLY_00, to which, as noted above, the predicate fly is connected.The semantic properties of +FLY_00 in Figure 2 read as follows: 'to fly means that a human or animal entity (x1) transports either themselves or another entity (x2) through the air from point A to point B using an aircraft.The aircraft is controlled by (x1), and both (x1) and (x2) are located inside the aircraft'.As may be apparent to the reader, the MP of +FLY_00 accounts for different senses of the verbal predicate fly within a single conceptual unit.The vast majority of concepts in FunGramKB, however, conceptually represent one sense of a given lexical unit, and as such, the view adopted in FunGramKB is the following: "word senses actually are concepts, i.e. cognitive units of knowledge" (Ovchinnikova 2012: 45, emphasis in the original; cf.Jackendoff 1983).Nevertheless, in this case, the machine is able to distinguish between senses in input texts like Birds fly and The pilot flew the plane.This clac 70/2017, 251 is achieved thanks to the inference reasoning mechanism of FunGramKB (see Periñán and Arcas 2010), which works by recovering information from the TFs and MPs of other concepts in the Ontology.For example, +OPERATE_00 and +AIRCRAFT_00 are used to describe the semantics of +FLY_00, although, obviously, these make reference to a sense different from intransitive fly (e.g.The poor bird couldn't fly).However, the (x1) participant in the TF of +OPERATE_00, for example, is constrained by the concept +HUMAN_00.Since there is a mismatch between the (x1) role in +FLY_00 and the (x1) role in +OPERATE_00, the machine will "know" that an animal cannot operate an aircraft, although it can fly.

With this in mind, consider
For the sake of comparison, let us briefly deal with FrameNet.In this lexical resource, fly evokes several frames, namely: 'self-motion' (e.g.This is what moths are doing when they fly into a candle); 'motion' as in The arrow was flying towards her; 'bringing' (e.g.We will fly you both from Heathrow to Aberdeen), 'ride vehicle' (e.g. You can fly North-west Airlines from Gatwick to San Francisco), and 'operate vehicle' (e.g.He flies a plane).These frames capture widely studied argument-structure constructions like the intransitive motion (cf.self-motion), caused-motion (cf.bringing), etc., in which fly participates.This type of fine-grained approach is in fact similar to the one put forward here.That is, instead of positing broad general constructions à la Goldberg (1995), we put forward more specific sub-constructions, or mini-constructions -in Boas' terminology (Boas 2003(Boas , 2008(Boas , 2011)-, i.e. pairings of a particular function with a very specific syntactic frame.
FrameNet, however, is inconsistent in its treatment of grammatical constructions.To exemplify this, consider the self-motion frame, which FrameNet defines as follows: The Self_mover, a living being, moves under its own direction along a Path.
Alternatively or in addition to Path, an Area, Direction, Source, or Goal for the movement may be mentioned. [https://framenet2.icsi.berkeley.edu/fnReports/data/frameIndex.xml?frame=Self_motion In the lexical entries for the noun way and the verb make, which are related to the selfmotion frame, one finds realizations of the way construction such as You can build an appetite for dinner by making your way from the beach to the restaurant, Hundreds of Californians made their way to their computers after the quake, The Knights of St. John, a holy military force, made their way to Rhodes and Kos in the Dodecanese.Unlike clac 70/2017, 252 crawl, dance, hike, run, swim or walk, which are some of the lexical items that also evoke the frame under scrutiny, way or make do not lexically entail self-motion unless subsumed in the broader syntactic context of the way construction, in the case at hand.
In fact, note that realizations like the ones given above are redundantly listed in the English FrameNet Constructicon (http://sato.fm.senshu-u.ac.jp/frameSQL/cxn/CxNeng/cxn00/21colorTag/index.html;see also Fillmore 2008 andFillmore et al. 2012) As was the case with lexical entries (cf. Figure 2), constructional schemas employ the same formal representation system, i.e. both are described in terms of AVMs which eventually merge via unification processes, following the paradigm of constraint-based or unification grammars (cf.Goldberg 2006: 215-217).
When processing an input text, specific argument-structure constructions are activated by means of a series of pointers in the Lexicon which link a given verbal predicate to the range of configurations in which it may participate.For example, as we saw with fly, the verbal predicate break is also connected to the caused-motion configuration in the Grammaticon, since it is compatible with such syntactic pattern: e.g.Freddie broke the walnuts into the bowl (Goldberg 1995: 86).Thus, taking this realization as a case in point, we now zoom in on the current computational treatment of the caused-motion construction in the L1-Constructicon (see Periñán and Arcas 2014: 173;Mairal 2015: 19), which we reproduce in Figure 3: The following is a brief explanation of the different components making up the AVM in -In the CLS, we first find that constructional schemas, as much as verbs in the Lexicon, are provided with an Aktionsart type, which, in the case of the construction at hand, is a causative accomplishment or CACC.This entails that the construction depicts an induced bounded change of location (cf.Van Valin andLaPolla 1997: 91-113, andVan Valin 2005: 42-48, for a detailed explanation of verb classes and the tests to identify them).
-The construction displays three variables, i.e. x (e.g.'Freddie'), y (e.g.'the walnuts'), w (e.g.'into the bowl').Variables x and y are shared participants of both the verbal and constructional subevents (cf.Goldberg and Jackendoff 2004: 538), while the change of location (i.e.w) is contributed by the construction.In other words, the resultative ingredient in the realization above does not arise from the argument-structure of the causative verb break, which has two arguments, one acting as an Agent and the other as a Patient.Rather, it comes from the higher-level construct, i.e. the causedmotion construction, in which break can be embedded.Given this, only the thematic role, phrase, syntax, and selectional preferences of the w added variable need to be spelled out in the AVM of the caused-motion configuration.As such, w, which is assigned the thematic role 'Goal' (i.e.location to which in entity moves), can be realized by a Prepositional Phrase (PP).The descriptor labeled 'syntax' accounts for the syntactic status of the variables of the construction as argument or as nucleus (see Van Valin 2005: 4-5).In the case at hand, the PP functions as a nucleus, that is, the semantic predicate in RRG terms.In turn, selectional preferences, which employ concepts from the Ontology (cf.+LOCATION_00), work as conceptual constraints prototypically related to a cognitive situation.In this case, +LOCATION_00 captures the fact that caused motion events impose an actual change of location on the part of the affected entity, as opposed to PPs like "struggle somebody to death", "break something into pieces", etc., in which there is a change of state (interpreted as a metaphorical change of location).
-Finally, the COREL schema codifies the cognitive content of the construction by means of the same formal language employed in the conceptual module.It makes use of ontological concepts together with their corresponding MP.In Figure 3, the semantics contributed by the caused-motion construction can be translated as follows: '(x1: x)Agent causes (x2: y)Theme to move to (x5:w)Goal by means of event (verb)'.Note clac 70/2017, 255 that this COREL schema is fully consistent with the skeletal semantic representation of the causative path resultative provided in Goldberg and Jackendoff (2004: 540) Having explained the way verbs are handled in the Lexicon, as well as the current computational treatment of the caused-motion construction, we now show how the NLP system would generate the semantic representation of the caused-motion realization in (1a) through a CLS: (1) (a) Input text: Freddie broke the walnuts into the bowl As stated in Periñán (2013: 219), if reasoning is required to process the input text, as it would be the case in machine translation, the CLS is transduced into an extended COREL representation, so that it can be enriched with the conceptual knowledge from any cognitive module in FunGramKB.Thus, the CLS in ( 1b) is modeled into the COREL representation (2).In (2) the semantic contribution of the caused-motion construction, which is generated on the basis of the AVM in Figure 3, is highlighted in bold: ( 3. Constructional subtypes Goldberg and Jackendoff (2004: 535) treat resultatives as forming a family of subconstructions that share important properties but differ in certain specifics.Much like the rest of the constructional members that participate in this family, the English causedmotion construction shows a great deal of semantic and syntactic variation.In line with Goldberg and Jackendoff (2004), we argue that, besides the caused-motion construction in Figure 3, three minimally distinct transitive motion or path sub-constructions need to be posited in order for the machine to correctly process different realizations of the same general construction.
To begin with, recall that the COREL schema in Figure 3 specifies that the Agent causes the Theme to move to a destination or goal, as in I shoved the canoe into the deep water (GBAC, 2004).Note that in this literal example, the object referent is the only entity traversing the path expressed by the Resultative Phrase (RP), i.e. the canoe moves into the water.However, the examples in (3) show that changes of location may be depicted in various ways: (3) (a) The prince galloped his horse into the woods (GBAC, 2005).
(b) He walked the dog to the store (COCA, 1993).
(c) He'd make a good watchdog […] he could run the rats out of the barn (GBAC, 2003).
(e) When we reached his floor, he helped me into his room where he gently put me down on the couch (GBAC, 2014).
(f) Let me show you into the waiting room (GBAC, 2010).
(g) Nurses wheel him into the operating room (COCA, 2006).
As opposed to the literal example with shove above, the realizations in ( 3 In (3a,b) an animate volitional entity (cf. the horse/dog) is manipulated into moving as instigated by the causer of motion, who is also the one that determines or controls the path to be followed (cf.Levin 1993: 31).The causee is thus accompanied by the causer of motion, who either rides or walks together with the animal.A different form of caused motion is that of (3c).Once again, both the Subject and the Object end up in a different location.However, in this case, it is the chasing activity that causes the rats to move towards the desired destination (i.e.outside the barn), as opposed to the kind of accompanied causation codified in (3a,b).
One aspect that is not addressed in Goldberg and Jackendoff's (2004)  Ruiz de Mendoza and Galera 2014).More concretely, these instances are licensed by the high-level metonymy A CAUSED EVENT FOR AN ACTIVITY, through which the activities of galloping, walking and running are seen as part of a causal event including them.The linguistic expression specifies the causal event, which stands for the activity in the target domain.This metonymic development where the y constructional argument is both the object of the subject's causal action (e.g.'x runs the rats') and the actor of the activity ('the rats run'), is consistent with our experience, thus allowing inherently intransitive (non-causal) predicates into the caused-motion construction.
Now compare (3b) and (3d).In both cases the syntactic pattern has coerced the intransitive verb walk to shift its valency from a one-place predicate to a three-place predicate.Despite their formal similarity, however, only (3b) is causative.That is, the paraphrase of (3b) would be 'He caused his dog to walk to the store'.In other words, this realization gives prominence to the caused event over the idea of accompaniment, which is latent.By contrast, the example They walked him to the station, or other likes Let me walk you to the door (GBAC, 2012), are more appropriately paraphrased as clac 70/2017, 258 'They accompanied him as they walked to the station' than 'They caused him to walk to the station'.Therefore, in these examples the idea of accompaniment gains prominence over causation of motion, especially in contexts in which it is evident that motion is a willful choice on the part of the non-subcategorized object.It may be argued that these instances involve a further metonymic extension of causative walk in (3b), which arises from the fact that as one causes a person to walk, they are in fact accompanying them.
This shift of meaning allowing transitive uses of walk would be licensed by the highlevel metonymy CAUSED MOTION FOR ACCOMPANIED MOTION.Other forms of accompanied motion -or, in some cases, 'aided motion'-, are provided in (3e)-(3g).
Unlike walk, gallop, or run, show in (3f), for example, is a transitive verbal predicate.
As such, it does not require a process of transitivization; the directional phrase being the only argument contributed by the construction.In this case, the integration of show into the caused-motion frame is licensed by a 'high-level' metaphor in which a perceptual action like showing is understood as if it were caused motion (see Baicchi 2007).
Although space constraints preclude a more elaborate explanation of the role of highlevel metaphor and metonymy, our analysis shows that, on the basis of these cognitive operations, all realization possibilities of a given construction can be economically accounted for.Unfortunately, the computational tractability of the metaphor/metonymybased solution in FunGramKB has not been investigated yet, probably due to its highly generic format.
This necessarily brief discussion evidences that the computational approach to the caused-motion configuration given in Section 2.2 is insufficient to process some examples expressing caused motion (cf.walk the dog) and/or accompanied/aided motion (cf.wheel somebody into the room).As a result, an alternative approach requires the postulation of two additional subtypes of the caused-motion pattern.These constructional schemas, which we shall label 'Accompanied motion constructions  Finally, a different type of structure is that of Mac flew Continental to Bush International Airport, which Goldberg and Jackendoff (2004: 553) refer to as a case of the 'transitive noncausative spatial resultative'.This specific realization is distinguished from everything we have addressed thus far in that, although the expression is a transitive one, it is the Subject rather than the Object that changes location.In Goldberg and Jackendoff (2004: 537)   This constructional schema stands apart from previous AVMs in two ways.On the one hand, the w constructional argument is assigned the thematic role 'location', which is in turn constrained by the selectional preferences +VEHICLE_00 (cf. a plane operated by Continental) or +PATH_00 (cf.Highway 53).On the other, the x variable, which is an argument shared by both the verbal and the constructional subevents, is mapped onto the Theme or the entity in motion, as opposed to previous cases in which x was the causer of motion.In turn, the real Agent of the action can be retrieved from the MP of +FLY_00 (see Figure 2), which not only specifies that there is a human (x1)Agent entity who transports a Theme role using an aircraft that is operated by ( x1), but also the fact that both Agent and Theme are located inside the aircraft.
To conclude, we now turn our attention to how the machine will process input texts containing the AVMs presented above.In other words, we show below how the NLP system would generate the semantic representation or CLS of some realizations of the accompanied motion constructions (Figures 4 and 5) and the transitive spatial resultative (Figure 6).As explained in section 2.2, if some kind of reasoning were required, the CLSs above would need to be enhanced with the knowledge stored in any of the modules in FunGramKB, resulting in the COREL representations in ( 7)-( 9), where the semantic contribution of the three sub-constructions is incorporated: Consequently, enriching the constructional information that NLP systems house will result in better applications that require text understanding, such as question answering, information extraction, and dialogue systems.Therefore, the three different subtypes of constructions presented in this paper, depending on whether it is the Agent and the clac 70/2017, 264 Patient or the Patient in Subject position the ones that change location, aid to build up the strength of FunGramKB and the potential NLP applications in which it will be implemented.This, however, contrasts with the type of semantic contribution that CLSs will display if only one type of CMC is posited (cf. Figure 3 and the COREL representation in (2)).

Conclusion
This paper has shown that the current constructional schema of the caused-motion or causative spatial resultative construction is too broad to account for the semantic and syntactic complexity of possible realizations of the same general construction.Thus, in order to provide a finer-grained computational treatment, we have drawn insights from CxG approaches in an attempt to enhance the current RRG-based constructional schemas in FunGramKB.This procedure is consistent with the very nature of FunGramKB, a computational project that bridges the gap between theoretical linguistics and NLP.To that end, we have posited three additional subtypes of motion configurations that pair specific semantics/pragmatics with a particular form, thus resulting in minimally distinct, yet related, subconstructions.Likewise, we have briefly discussed the pervasive licensing role of cognitive operations like high-level metaphor and metonymy in lexical-constructional integration.Although on the basis of two cognitive operations, we can account for diverse realizational possibilities without the need to posit very specific constructions, the highly abstract nature of such cognitive mechanisms does not easily comply with computational requirements.
It comprises several Constructicons that are inspired in the four constructional layers of clac 70/2017, 247 the usage-based constructionist model known as the Lexical Constructional Model (Ruiz de Mendoza 2013; Ruiz de Mendoza and Galera 2014).In FunGramKB, constructional schemas help RRG to build the syntax-semantics linking algorithm.

Figure 2 :
Figure 2: Attribute-Value Matrix of fly and its conceptual representation.
, i.e. the repository in which grammatical constructions are stored and annotated.More concretely, these cases exemplify what the English FrameNet Constructicon refers to as 'way neutral' construction (e.g.She carefully made her way through the cluttered room to the altar).Thus, with the aim of avoiding uncontrolled redundancy between the lexicographic database and the language-specific Constructicons, Torrent et al. (2014) have recently devised a set of annotation policies for the Brazil FrameNet Constructicon, which could also be potentially applied to other language-specific Constructicons.One such policy is concerned with the task of deciding what should be accounted for as an instance of a construction, or rather, as a valence pattern of a lexical unit in the lexicographic database.By contrast, border conflicts in the treatment of specific syntactic structures do not pose a problem in FunGramKB in which there is a clearer-cut division between what goes in the Lexicon and what is part of the Grammaticon, the component to which we turn our attention now.2.2.The Grammaticon As advanced in the introduction, argument-structure constructions are housed in the FunGramKB Grammaticon, and more concretely in the L1-Constructicon.It should be noted that besides argument-structure constructions, the Grammaticon stores three additional construction types: (i) the L2-Constructicon addresses implicational constructions such as What's X Doing Y? (Kay and Fillmore 1999); (ii) the L3-Constructicon is devoted to the computational representation of illocutionary structure constructions, such as Can you please X?, which is conventionally used to make requests (Panther and Thornburg 1998); and (iii) the L4-Constructicon handles discourse structure constructions (e.g.X Let Alone Y; Fillmore, Kay and O'Connor 1988).clac 70/2017, 253

Figure 3 :
Figure 3: AVM of the caused-motion construction.
Figure 3: caused the walnuts to fall into the bowl by means of breaking them') Thus, through the constructional schema in Figure3, the machine will be able to correctly provide the CLS of input texts whose semantics displays a causer argument directly causing the theme to move along a path designated by the PP (cf.Goldberg 1995: 152), as in: She kicked the ball into the goal (GBAC, 2009), She sneezed the napkin off the table(Steels and van Trijp 2011: 12), The man laughed him out of the shop (GBAC, 2011), The scientist ran the rats through the maze(Levin 1993: 31), I pushed the cone into the current(COCA, 1996), etc.Nevertheless, the following section demonstrates that this constructional schema is insufficient to account for other realizations codifying motion such as He flew Continental to Bush International Airport(COCA, 2000), Petersen will show you out clac 70/2017, 256(GBAC 2006), etc.
) display externally induced self-instigated changes of location in which both Agent and Patient end up in a different location as the result of the action denoted by the verb.Let us consider each of them in more detail.clac 70/2017, 257

Figure 5 :
Figure 5: AVM of the 'accompanied motion construction': sub-type 2.Although minimally, these representations differ from the original caused-motion construction (cf.Figure3) in two ways.First, while the current approach to the
analysis of the members of the family of the resultative is the role that cognitive operations play as licensing factors on lexical-constructional unification (see Ruiz de Mendoza and Mairal 2008; Peña 2015).These explain why certain verbal predicates are allowed in a given construction, while others, even semantically related ones, are not (see Ruiz de Mendoza and Galera (2014) for an in-depth discussion).For example, (3a,b,c) are motivated by what authors like Ruiz de Mendoza and Pérez (2001: 334-336) label 'high-level' or grammatical metonymy (see also Ruiz de Mendoza and Mairal 2008; (Simpson 1983;Peña 2016at undergoes a change of location or state whose endpoint is expressed by the RP is called the 'host' of the RP.Under normal circumstances, the choice of host is directly related to transitivity.That is, the host of the intransitive motion construction is the Subject (e.g.The ball rolled down the hill), whereas the affected entity of a transitive realization is the Object, as in Bill rolled the ball down the hill.Mac flew Continental to Bush International Airport, however, defies this behavior since, in this particular case, the host of the RP is the Subject, i.e. the entity in motion.Semantically, in addition, this spatial resultative is different from previous instances due to the fact that the direct object is not a Patient: Mac is not acting on Continental or, more concretely, the plane flown by Continental Airlines.However, Goldberg and Jackendoff miss the fact that although Mac is not the causer argument, the event is in fact causal, i.e. a pilot working for Continental Airlines makes the plane in which Mac is a passenger fly to a destination.Thus, the real Agent or causer role (the pilot) is omitted so that the Patient can appear in Subject position.This process of reconstrual is licensed by a high-level metonymy by virtue of which the activity of 'Mac flying' stands for a caused event in which 'Mac is flown' to a different location.Following upon this logic, the paraphrase of this example would be 'Someone caused a clac 70/2017, 261 plane owned by Continental Airlines, in which Mac is a passenger, to fly to Bush International Airport'.As with John walked the dog to the park, the construction coerces the intransitive predicate fly, whose description was given in Table1, to expand its valency to a three-place predicate.This is also the case in sentences like Jake flew him to New York(GBAC, 2012).The difference between these examples lies in the choice of Object contributed by the construction.In Mac flew Continental, which is the one that concerns us here, it is pragmatic factors that motivate the presence of the airline in the object slot.If compared to Mac flew to Bush International Airport with Continental, in which the airline company is peripherally referred to through a PP, it is the emphasis on the means (the vehicle) by which Mac flies to the airport that allows the non-affected entity to immediately follow the verb.Interestingly enough, pragmatic factors can also motivate the insertion of fake reflexives(Simpson 1983;Peña 2016) in object position, as in Blair walked himself back to bed.In line withBoas' (2003: 240-  250) analysis of this last example, the fake reflexive fulfills a relevant pragmatic First, 'Continental' is exploited metonymically to stands for 'a flight operated by Continental' in the target domain, which is what we are actually referring to.On the basis of this previous operation, we build the high-level metonymy spelled out above, i.e.A CAUSED EVENT FOR AN ACTIVITY.
function, i.e. that of overcoming an obstacle in order to reach the desired destination.As it happens with the way construction (e.g.A tribute to the 70,000 Mormon pioneers who pushed, pulled, and walked their way across America's prairies and mountains to the Great Salt Lake Valley stands near the south wall of Temple Square; Google Books (2012): Table in the Wilderness: This Place Temple Square, by M. Stewart.Accessed 7 April, 2016) the fact that motion implies some kind of extra effort is not obtained in the absence of the fake-reflexive object: Blair walked back to bed.But pragmatic factors are not the only motivating mechanism in Mac flew Continental to Bush International Airport.