Embodied Compositionality by x6eVhef

VIEWS: 0 PAGES: 127

									Getting From the Utterance to
        the SemSpec

                    Johno Bryant
• Need a grammar formalism
   – Embodied Construction Grammar (Bergen & Chang 2002)

• Need new models for language analysis
   – Traditional methods too limited
   – Traditional methods also don’t get enough leverage out of the
     semantics.
     Embodied Construction
          Grammar

• Semantic Freedom
  – Designed to be symbiotic with cognitive approaches to
    meaning
  – More expressive semantic operators than traditional
    grammar formalisms

• Form Freedom
  – Free word order, over-lapping constituency

• Precise enough to be implemented
 Traditional Parsing Methods
          Fall Short

• PSG parsers too strict
  – Constructions not allowed to leave constituent order
    unspecified

• Traditional way of dealing with incomplete
  analyses is ad-hoc
  – Making sense of incomplete analyses is important when
    an application must deal with “ill-formed” input
  (For example, modeling language learning)
• Traditional unification grammar can’t handle
  ECG’s deep semantic operators.
               Our Analyzer

• Replaces the FSMs used in traditional chunking
  (Abney 96) with much more powerful machines
  capable of backtracking called construction
  recognizers

• Arranges these recognizers into levels just like in
  Abney’s work

• But uses a chart to deal with ambiguity
          Our Analyzer (cont’d)

• Uses specialized feature structures to deal with
  ECG’s novel semantic operators

• Supports a heuristic evaluation metric for finding
  the “right” analysis

• Puts partial analyses together when no complete
  analyses are available
  – The analyzer was designed under the assumption that the
    grammar won’t cover every meaningful utterance
    encountered by the system.
      System Architecture
              Grammar/Utterance


Semantic
Chunker


                                  Learner


 Semantic
Integration

               Ranked Analyses
                    The Levels

• The analyzer puts the recognizer on the level
  assigned by the grammar writer.
  – Assigned level should be greater than or equal to the levels
    of the construction’s constituents.

• The analyzer runs all the recognizers on level 1,
  then level 2, etc. until no more levels.

• Recognizers on the same level can be mutually
  recursive.
                  Recognizers

• Each Construction is turned into a recognizer

• Recognizer = active representation
  – seeks form elements/constituents when initiated
  – Unites grammar and process - grammar isn’t just a static
    piece of knowledge in this model.

• Checks both form and semantic constraints
  – Contains an internal representation of both the semantics
    and the form
  – A graph data structure used to represent the form and a
    feature structure representation for the meaning.
          Recognizer Example



Mary kicked the ball into the net.


This is the initial Constituent
Graph for caused-motion.                   Patient



           Agent                  Action


                                            Path
         Recognizer Example


                         Construct:
                       Caused-Motion



Constituent:    Constituent:     Constituent:      Constituent:
  Agent           Action           Patient            Path




     The initial constructional tree for the instance of
       Caused-Motion that we are trying to create.
            Recognizer Example


caused motion.m
agent : 5          agent.m              patient.m            
                    ,  category :
                         1                 , 3category :       
 scene : 4                                                    
                     resolved  ref : resolved  ref :
                                                                 
 action : 6       
    caused motion.cm        path.m             
    agent :  5            source :          
             1                                       action.m 
4 patient : {3}{cm1} ,{7} path :              , 2tense :      
                                                                  
    action : 26           goal :                  x  schema :
                                                                      
     path : {7}
                          
                              trajector : {cm1}
                                                  
            Recognizer Example

processed



 Mary kicked the ball into the net.


  A node filled with gray is removed.
                                        Patient



            Agent              Action


                                         Path
         Recognizer Example

                     Construct:
                   Caused-Motion



   RefExp:   Constituent:   Constituent:   Constituent:
    Mary       Action         Patient         Path




Mary kicked the ball into the net.
              Recognizer Example

caused  motion.m
agent : 5       agent.m                patient.m                 
                 ,  category : Person
                      1                   , 3category :            
 scene : 4                                                        
                  resolved  ref : Mary resolved  ref
                                                                    :
                                                                        
 action : 6    
   caused  motion.cm      path.m           
   agent :  5           source :        
            1                                    action.m 
4 patient : {3}{cm1} ,{7} path :          , 2tense :      
                                                              
   action : 26          goal :                x  schema :
                                                                  
    path : {7}
                       
                            trajector : {cm1}
                                              
            Recognizer Example

processed



 Mary kicked the ball into the net.



                             Patient



            Agent   Action


                              Path
         Recognizer Example

                  Construct:
                Caused-Motion



   RefExp:    Verb:     Constituent:   Constituent:
    Mary     kicked       Patient         Path




Mary kicked the ball into the net.
               Recognizer Example

caused motion.m
agent : 5      agent.m                patient.m                 
                ,  category : Person
                     1                   , 3category :            
 scene : 4                                                       
                 resolved  ref : Mary resolved  ref
                                                                   :
                                                                       
 action : 6   
   caused motion.cm       path.m           
   agent :  5           source :        
            1                                    action.m          
4 patient : {3}{cm1} ,{7} path :          , 2tense : simpPast 
                                                                   
   action : 26          goal :                x  schema : kick
                                                                       
    path : {7}
                       
                            trajector : {cm1}
                                              
            Recognizer Example

processed



 Mary kicked the ball into the net.

 According to the Constituent Graph,
 The next constituent can either be the
 Patient or the Path.                     Patient



            Agent              Action


                                           Path
            Recognizer Example

processed



 Mary kicked the ball into the net.



                             Patient



            Agent   Action


                              Path
         Recognizer Example

                  Construct:
                Caused-Motion



   RefExp:    Verb:      RefExp:    Constituent:
    Mary     kicked      Det Noun      Path




              Det     Noun



Mary kicked the ball into the net.
              Recognizer Example

caused motion.m
agent : 5      agent.m                patient.m           
                ,  category : Person
                     1                   , 3category : ball 
 scene : 4                                                 
                 resolved  ref : Mary resolved  ref :
                                                              
 action : 6   
   caused motion.cm       path.m           
   agent :  5           source :        
            1                                    action.m          
4 patient : {3}{cm1} ,{7} path :          , 2tense : simpPast 
                                                                   
   action : 26          goal :                x  schema : kick
                                                                       
    path : {7}
                       
                            trajector : {cm1}
                                              
            Recognizer Example

processed



 Mary kicked the ball into the net.



                             Patient



            Agent   Action


                              Path
         Recognizer Example

                  Construct:
                Caused-Motion



   RefExp:    Verb:      RefExp:       Spatial-Pred:
    Mary     kicked      Det Noun      Prep RefExp


                                            RefExp


              Det     Noun      Prep     Det     Noun



Mary kicked the ball into the net.
              Recognizer Example

caused motion.m
agent : 5          agent.m                    patient.m           
                    ,  category : Person
                         1                       , 3category : ball 
 scene : 4                                                         
                     resolved  ref : Mary resolved  ref :
                                                                      
 action : 6       
    caused motion.cm        path.m           
    agent :  5            source :        
             1                                     action.m          
4 patient : {3}{cm1} ,{7} path :            , 2tense : simpPast 
                                                                     
    action : 26           goal : net            x  schema : kick
                                                                         
     path : {7}
                          
                              trajector : {cm1}
                                                
         Resulting SemSpec

After analyzing the sentence, the following identities
are asserted in the resulting SemSpec:


             Scene = Caused-Motion
             Agent = Mary
             Action = Kick
             Patient = Path.Trajector = The Ball
             Path = Into the net
             Path.Goal = The net
                       Chunking
L3 ________________________S_____________S
L2 ____NP _________PP                 VP       NP ______VP
L1 ____NP P_______NP                  VP       NP ______VP
L0 D        N       P D N       N V-tns Pron Aux V-ing
      the woman in the lab coat thought you were sleeping
  0     1       2 3    4    5     6        7     8   9


 Cite/description
           Construction Recognizers
                                            Form      Meaning
                    Form     Meaning
Form     Meaning                            PP$,N <-> [Hand
                    D,N <-> [Cloth
“you”<->[Addressee]                                    num:sg
                             num:sg]
                                                     poss:addr]


 NP         NP           NP        NP          NP
 You    want to put    a cloth     on       your hand    ?

Like Abney:                      Unlike Abney:
 One recognizer per rule          Check form and semantics
 Bottom up and level-based        More powerful/slower than FSMs
                    Chunk Chart
• Interface between chunking and structure
  merging
• Each edge is linked to its corresponding
  semantics.


You   want to put    a cloth   on   your hand   ?
      Combining Partial Parses
• Prefer an analysis that spans the input utterance
  with the minimum number of chunks.
• When no spanning analysis exists, however, we
  still have a chart full of semantic chunks.
• The system tries to build a coherent analysis out of
  these semantics chunks.
• This is where structure merging comes in.
            Structure Merging
• Closely related to abductive inferential mechanisms
  like abduction (Hobbs)
• Unify compatible structures (find fillers for frame
  roles)
• Intuition: Unify structures that would have been co-
  indexed had the missing construction been defined.
• There are many possible ways to merge structures.
• In fact, there are an exponential number of ways to
  merge structures (NP Hard). But using heuristics
  cuts down the search space.
       Structure Merging Example
Utterance:You used to hate to have the bib put on .
Before Merging:             After Merging:

[Addressee < Animate]        Caused-Motion-Action
 Bib < Clothing              Agent: [Addressee]
 num:sg                      Patient:
                                      Bib < Clothing
 givenness:def                        num:sg
                                      givenness:def
  Caused-Motion-Action
  Agent: [Animate]           Path:On
  Patient: [Entity]
  Path:On
             Semantic Density
• Semantic density is a simple heuristic to choose
  between competing analyses.
• Density of an analysis = (filled roles) / (total roles)
• The system prefers higher density analyses
  because a higher density suggests that more frame
  roles are filled in than in competing analyses.
• Extremely simple / useful? but it certainly can be
  improved upon.
                Summary: ECG
• Linguistic constructions are tied to a model of
  simulated action and perception
• Embedded in a theory of language processing
   – Constrains theory to be usable
   – Frees structures to be just structures, used in processing
• Precise, computationally usable formalism
   – Practical computational applications, like MT and NLU
   – Testing of functionality, e.g. language learning
• A shared theory and formalism for different
  cognitive mechanisms
   – Constructions, metaphor, mental spaces, etc.
Issues in Scaling up to Language
• Knowledge
  –   Lexicon (FrameNet)
  –   Constructicon (ECG)
  –   Maps (Metaphors, Metonymies) (MetaNet)
  –   Conceptual Relations (Image Schemas, X-schemas)
• Computation
  – Representation (ECG)
       • expressiveness, modularity, compositionality
  – Inference (Simulation Semantics)
       • tractable, distributed, probabilistic concurrent, context-
         sensitive
A Best-Fit Approach for Productive
  Analysis of Omitted Arguments

        Eva Mok & John Bryant
     University of California, Berkeley
  International Computer Science Institute
    Simplify grammar by exploiting the
      language understanding process
•   Omission of arguments in Mandarin Chinese
•   Construction grammar framework
•   Model of language understanding
•   Our best-fit approach
    Productive Argument Omission (in Mandarin)
1                                           • Mother (I) give you this (a
                                              toy).
    mother give 2PS this+CLS
2                        • You give auntie [the peach].
     2PS give auntie
3                                • Oh (go on)! You give [auntie] [that].
    EMP 2PS give EMP
4          • [I] give [you] [some peach].
    give


                          CHILDES Beijing Corpus (Tardiff, 1993; Tardiff, 1996)
  Arguments are omitted with different
             probabilities
                     % elided (98 total utterances)
           100.00%
           90.00%
                             Giver
           80.00%
           70.00%                                Theme
           60.00%
           50.00%                    Recipient
           40.00%
           30.00%
           20.00%
           10.00%
            0.00%



All arguments omitted: 30.6%                        No arguments
  omitted: 6.1%
  Construction grammar approach
• Kay & Fillmore 1999; Goldberg 1995
• Grammaticality: form and function
• Basic unit of analysis: construction,
  i.e. a pairing of form and meaning constraints
• Not purely lexically compositional
• Implies early use of semantics in processing
• Embodied Construction Grammar (ECG) (Bergen &
  Chang, 2005)
Problem: Proliferation of constructions
         Subj     Verb      Obj1      Obj2
           ↓        ↓         ↓         ↓
         Giver   Transfer Recipient   Theme
                  Verb      Obj1      Obj2
                    ↓         ↓         ↓
                 Transfer Recipient   Theme
         Subj     Verb                Obj2
           ↓        ↓                   ↓
         Giver   Transfer             Theme

         Subj     Verb      Obj1
           ↓        ↓         ↓
                                              …
         Giver   Transfer Recipient
If the analysis process is smart, then...

             Subj    Verb      Obj1      Obj2
              ↓        ↓         ↓         ↓
            Giver   Transfer Recipient   Theme




 • The grammar needs only state one construction
 • Omission of constituents is flexibly allowed
 • The analysis process figures out what was omitted
 Best-fit analysis process takes burden
    off the grammar representation

Utterance   Discourse & Situational     Constructions
                   Context




                     Analyzer:
                    incremental,
                 competition-based,
                 psycholinguistically
                      plausible


             Semantic Specification:
              image schemas, frames,       Simulation
                  action schemas
  Competition-based analyzer finds
         the best analysis
• An analysis is made up of:
                               The best fit has the
  – A constructional tree      highest combined score
  – A set of resolutions
  – A semantic specification
 Combined score that determines
            best-fit
• Syntactic Fit:
  – Constituency relations
  – Combine with preferences on non-local elements
  – Conditioned on syntactic context
• Antecedent Fit:
  – Ability to find referents in the context
  – Conditioned on syntactic information, feature agreement
• Semantic Fit:
  – Semantic bindings for frame roles
  – Frame roles’ fillers are scored
  Analyzing ni3 gei3 yi2 (You give auntie)
                     Two of the competing analyses:

ni3      gei3            yi2         omitted   ni3        gei3         omitted         yi2
 ↓        ↓               ↓            ↓        ↓          ↓             ↓              ↓
Giver   Transfer Recipient Theme               Giver    Transfer Recipient Theme


• Syntactic Fit:
   – P(Theme omitted | ditransitive cxn) = 0.65
   – P(Recipient omitted | ditransitive cxn) = 0.42

          (1-0.78)*(1-0.42)*0.65 = 0.08                (1-0.78)*(1-0.65)*0.42 = 0.03
Using frame and lexical information
    to restrict type of reference
The Transfer Frame
Giver                 Lexical Unit gei3
Recipient             Giver        (DNI)
Theme                 Recipient    (DNI)
                      Theme        (DNI)
Manner      Purpose
Means       Reason
Place       Time
          Can the omitted argument be
            recovered from context?
  • Antecedent Fit:
 ni3      gei3     yi2     omitted    ni3       gei3    omitted   yi2
  ↓        ↓        ↓        ↓         ↓         ↓        ↓        ↓
Giver   Transfer Recipient Theme     Giver    Transfer Recipient Theme




                        Discourse & Situational               ?
                               Context

                       child         mother
                       peach         auntie
                       table
        How good of a theme is a peach?
             How about an aunt?
• Semantic Fit:
 ni3      gei3     yi2     omitted    ni3      gei3    omitted   yi2
  ↓        ↓        ↓        ↓         ↓        ↓        ↓        ↓
Giver   Transfer Recipient Theme     Giver   Transfer Recipient Theme


               The Transfer Frame
               Giver           (usually animate)
               Recipient       (usually animate)
               Theme           (usually inanimate)
The argument omission patterns shown earlier
 can be covered with just ONE construction
                                                                  % elided (98 total utterances)
                                                         90.00%
                                                                         Giver
                                                         80.00%
                                                         70.00%                              Theme

                                                         60.00%
                                                         50.00%                  Recipient

                  Subj     Verb        Obj1      Obj2    40.00%
                                                         30.00%
                                                         20.00%


                   ↓         ↓          ↓          ↓     10.00%
                                                         0.00%




                  Giver   Transfer   Recipient   Theme
P(omitted|cxn):   0.78                0.42       0.65




  • Each cxn is annotated with probabilities of omission
  • Language-specific default probability can be set
   Leverage process to simplify
         representation
• The processing model is complementary to the
  theory of grammar
• By using a competition-based analysis process, we
  can:
   – Find the best-fit analysis with respect to constituency
     structure, context, and semantics
   – Eliminate the need to enumerate allowable patterns of
     argument omission in grammar
• This is currently being applied in models of
  language understanding and grammar learning.
Embodied Compositional
      Semantics

       Ellen Dodge
     edodge@berkeley.edu
        March 9, 2007
                Questions
• What is the nature of compositionality in
  the Neural Theory of Language?
• How can it be best represented using
  Embodied Construction Grammar?
                   Examples
•   He bit the apple
•   He was bitten (by a toddler)
•   He bit into the apple
•   His white teeth bit into the apple.
•   He shattered the window
•   The window was shattered
•   The window shattered
                  Outline
• Compositionality
• Neural Theory of Language and ECG
  – Assumptions
  – Overview
• Examples:
  – Representation of constructions and meaning
  – Simulation
• Concluding Remarks
           Compositionality
• Put the parts together to create the meaning of
  the whole.
           Compositionality
• Put the parts together to create the meaning of
  the whole.

• Questions:
  – what is the nature of the parts?
  – How and why do they combine with one another?
  – What meaning is associated with this composition?
            Short answers
• Parts = constructions, schemas
• Combination = binding, unification
• Meaning of the whole = simulation of
  unified parts
               Constructions
Construction Grammar
• Constructions are form-meaning pairings
• A given utterance instantiates many different
  constructions

Embodied Construction Grammar
• Construction meaning is represented using
  schemas
• Meaning is embodied
     Key assumptions of NTL

• Language understanding is simulation

• Simulation involves activation of neural
  structures
              Comments
• Language understanding

• Understanding process is dynamic

• “Redundancy” is okay
          Conceptual structure
•   Embodied
•   Schematic
•   (Potentially) language-independent
•   Highly interconnected
       Simulation parameters
• Constructions unify to create semantic
  specification that supports a simulation
• Two types of simulation parameters for
  event descriptions:
  – Event content
  – Event construal
 Putting the parts together
• Bindings

• Unification
          “Pre-existing” structure


    schema
                       Cxn
schema        schema
                       Cxn

     schema
                       Cxn
         schema
                       Unification


    schema
                          Cxn
schema        schema
                          Cxn

     schema
                          Cxn
         schema
               Summary
• Parts = constructions, schemas
• Combination = binding, unification
• Meaning of the whole = simulation of the
  combined parts
              First example
• He bit the apple.
Schemas
          schema MotorControl
           subcase of Process
            roles
                   Actor ↔ Protagonist
                   Effector
                   Effort
                   Routine
             constraints
                   Actor ← animate
schema Contact
  subcase of SpatialRelation
  roles
    Entity1: entity
    Entity2: entity                   schema MotorControl
                                       subcase of Process
                                        roles
   schema ForceTransfer                        Actor ↔ Protagonist
   evokes Conact as C                          Effector
    roles                                      Effort
      Supplier ↔ C.entity1                     Routine
      Recipient ↔ C.entity2              constraints
      Force                                    Actor ← animate



               schema ForceApplication
                subcase of MotorControl
                evokes ForceTransfer as FT
                 roles
                   Actor ↔ FT.Supplier ↔ Protagonist
                   Acted Upon↔ FT.Recipient
                   Effector
                   Routine
                   Effort ↔ FT.Force.amount
                 Schema networks
                  Contact

                                    MotorControl
               ForceTransfer


                                                        Motion
                 ForceApplication     Effector                    SelfMotion
CauseEffect                           Motion
                                                     MotionPath
                                     Effector
                                     MotionPath          SPG
                                                                  SelfMotion
                                                                  Path


              Agentive Impact        SpatiallyDirectedAction
                                                                  Contact
               Verb Constructions
Construction BITE1                   schema ForceApplication
 subcase of Verb                      subcase of MotorControl
 form: bite                           evokes ForceTransfer as FT
 meaning: ForceApplication             roles
   constraints:                          Actor ↔ FT.Supplier ↔ Protagonist
     Effector ← teeth                    Acted Upon ↔ FT.Recipient
                                         Effector
     Routine ← bite // close mouth
                                         Routine
                                         Effort ↔ FT.Force.amount
                Verb Constructions
cxn BITE                          schema MotorControl
  meaning: ForceApplication

cxn GRASP
  meaning: ForceApplication
                              schema ForceApplication
                                subcase of MotorControl
cxn PUSH
  meaning: ForceApplication

cxn SLAP
  meaning: AgentiveImpact
                              schema Agentive Impact
cxn KICK                        subcase of ForceApplication
  meaning: AgentiveImpact

cxn HIT
  meaning: AgentiveImpact
Argument Structure Construction
  construction ActiveTransitiveAction2
   subcase of VP
   constituents:
     V : verb
     NP: NP
   form
    constraints:
        VF before NPF
   meaning: CauseEffect
     evokes; EventDescriptor as ED; ForceApplication as FA
     constraints:
      {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Causer ↔ ED.ProfiledParticipant
       FA ↔ Vm
      Causer ↔ FA.Actor
      Affected ↔ FA.ActedUpon
      Affected ↔ NPm
Argument Structure Construction
  construction ActiveTransitiveAction2
   subcase of VP
   constituents:
     V : verb
     NP: NP
   form
    constraints:
        VF before NPF
   meaning: CauseEffect
     evokes; EventDescriptor as ED; ForceApplication as FA
     constraints:
      {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Causer ↔ ED.ProfiledParticipant
       FA ↔ Vm
      Causer ↔ FA.Actor
      Affected ↔ FA.ActedUpon
      Affected ↔ NPm
     CauseEffect schema

schema CauseEffect
 subcase of ForceApplication; Process
  roles
    Causer ↔ Actor
    Affected ↔ ActedUpon ↔ Process.Protagonist
    Instrument ↔ Effector
                  Schema Network
                  Contact

                                    MotorControl
Process        ForceTransfer


                                                        Motion
                 ForceApplication     Effector                    SelfMotion
CauseEffect                           Motion
                                                     MotionPath
                                     Effector
                                     MotionPath          SPG
                                                                  SelfMotion
                                                                  Path


              Agentive Impact        SpatiallyDirectedAction
                                                                  Contact
Argument Structure Construction
  construction ActiveTransitiveAction2
   subcase of VP
   constituents:
     V : verb
     NP: NP
   form
    constraints:
        VF before NPF
   meaning: CauseEffect
     evokes: EventDescriptor as ED; ForceApplication as FA
     constraints:
      {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Causer ↔ ED.ProfiledParticipant
       FA ↔ Vm
      Causer ↔ FA.Actor
      Affected ↔ FA.ActedUpon
      Affected ↔ NPm
                  Schema Network
                  Contact

                                    MotorControl
Process        ForceTransfer


                                                        Motion
                 ForceApplication     Effector                    SelfMotion
CauseEffect                           Motion
                                                     MotionPath
                                     Effector
                                     MotionPath          SPG
                                                                  SelfMotion
                                                                  Path


              Agentive Impact        SpatiallyDirectedAction
                                                                  Contact
         Important points

Compositionality does not require that each
 component contain different information.

Shared semantic structure is not viewed as
 an undesirable redundancy
Argument Structure Construction

  construction ActiveTransitiveAction2
   subcase of VP
   constituents:
     V : verb
     NP: NP
   form
    constraints:
        VF before NPF
   meaning: CauseEffect
    evokes; EventDescriptor as ED; ForceApplication as FA
    constraints:
     {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Causer ↔ ED.ProfiledParticipant
      FA ↔ Vm
     Causer ↔ FA.Actor
     Affected ↔ FA.ActedUpon
     Affected ↔ NPm
Event Descriptor schema

  schema EventDescriptor
    roles
      EventType: Process
      ProfiledProcess: Process
     ProfiledParticipant: Entity
      ProfiledState(s): State
      SpatialSetting
      TemporalSetting
Argument Structure Construction
  Construction ActiveTransitiveAction2
   subcase of VP
   constituents:
     V : verb
     NP: NP
   form
    constraints:
        VF before NPF
   meaning: CauseEffect
    evokes; EventDescriptor as ED; ForceApplication as FA
    constraints:
     {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Causer ↔ ED.ProfiledParticipant
      FA ↔ Vm
     Causer ↔ FA.Actor
     Affected ↔ FA.ActedUpon
     Affected ↔ NPm
          Bindings with other cxns
construction NPVP1               construction ActiveTransitiveAction2
constituents:                     subcase of VP
  Subj: NP                        constituents: V ; NP
  VP : VP                         form: VF before NPF
form                              meaning: CauseEffect
  Constraints                       evokes; EventDescriptor as ED
     Subj f before VPf              constraints:
meaning: EventDescriptor             {Selfm ↔ ED.EventType}
   ProfiledParticipant ↔ Subjm       {Vm ↔ ED.ProfiledProcess}
                                     Causer ↔ ED.ProfiledParticipant
                                     Affected ↔ NPm
          Bindings with other cxns
Construction NPVP1               construction ActiveTransitiveAction2
constituents:                     subcase of VP
  Subj: NP                        constituents: V ; NP
  VP : VP                         form: VF before NPF
form                              meaning: CauseEffect
  constraints                       evokes; EventDescriptor as ED
     Subj f before VPf              constraints:
meaning: EventDescriptor             {Selfm ↔ ED.EventType}
   ProfiledParticipant ↔ Subjm       {Vm ↔ ED.ProfiledProcess}
                                     Causer ↔ ED.ProfiledParticipant
                                     Affected ↔ NPm
schema EventDescriptor
  roles
    EventType
    ProfiledProcess
    ProfiledParticipant
    ProfiledState(s)
    SpatialSetting
    TemporalSetting
          Bindings with other cxns
construction NPVP1               construction ActiveTransitiveAction2
constituents:                     subcase of VP
  Subj: NP                        constituents: V ; NP
  VP : VP                         form: VF before NPF
form                              meaning: CauseEffect
  Constraints                       evokes; EventDescriptor as ED
     Subj f before VPf              constraints:
meaning: EventDescriptor             {Selfm ↔ ED.EventType}
   ProfiledParticipant ↔ Subjm       {Vm ↔ ED.ProfiledProcess}
                                     Causer ↔ ED.ProfiledParticipant
                                     Affected ↔ NPm
schema EventDescriptor
  roles
    EventType
    ProfiledProcess
    ProfiledParticipant
    ProfiledState(s)
    SpatialSetting
    TemporalSetting
                       Unification
          Meaning                    Constructions
EventDescriptor
 EventType                 NPVP1
 ProfiledProcess
 ProfiledParticipant

    CauseEffect
     causer                        TransitiveAction2
     affected


  ForceApplication
   actor                             BITE
   actedupon

 ReferentDescriptor                                    NP2

                                             THE         APPLE
 ReferentDescriptor        NP1

                           HE
                       Unification
          Meaning                    Constructions
EventDescriptor
 EventType                 NPVP1
 ProfiledProcess
 ProfiledParticipant

    CauseEffect                    TransitiveAction2
     causer
     affected


  ForceApplication
   actor                             BITE
   actedupon

 ReferentDescriptor                                    NP2

                                             THE         APPLE
 ReferentDescriptor        NP1
  resolved referent
                           HE
                       Unification
          Meaning                    Constructions
EventDescriptor
 eventtype                 NPVP1
 ProfiledProcess
 ProfiledParticipant

    CauseEffect                    TransitiveAction2
     causer                             Verb
     affected


  ForceApplication
   actor                             BITE
   actedupon

 ReferentDescriptor                                    NP2

                                             THE         APPLE
 ReferentDescriptor        NP1
  resolved referent
                           HE
                       Unification
          Meaning                    Constructions
EventDescriptor            NPVP1
 eventtype
                            subj
 ProfiledProcess
 ProfiledParticipant

    CauseEffect                    TransitiveAction2
     causer
     affected


  ForceApplication
   actor                             BITE
   actedupon

 ReferentDescriptor                                    NP2

                                             THE         APPLE
 ReferentDescriptor        NP1

                           HE
                       Unification
          Meaning                    Constructions
EventDescriptor
 eventtype                 NPVP1
 ProfiledProcess
 ProfiledParticipant

    CauseEffect                    TransitiveAction2
     causer                          NP
     affected


  ForceApplication
   actor                             BITE
   actedupon

 ReferentDescriptor                                    NP2

                                             THE         APPLE
 ReferentDescriptor        NP1

                           HE
                Semantic Specification
                       He bit the apple
EventDescriptor
 eventtype
 ProfiledProcess       CauseEffect        ForceApplication
 ProfiledParticipant    causer             actor
                        affected           actedupon
                                           routine  bite
                                           effector  teeth

          RD27
          category      Person


                                     RD55
                       Apple
                                     category
                  Simulation -
                 He bit the apple
CauseEffect

   ForceApplication
                             Protagonist =
                             Causer ↔ Actor




 Protagonist =
 Affected ↔
                 Process
 ActedUpon
                  Simulation -
                 He bit the apple
CauseEffect

   ForceApplication
                             Protagonist =
                             Causer ↔ Actor




 Protagonist =
 Affected ↔
                 Process
 ActedUpon
       Passive voice

He was bitten (by a toddler)
Argument Structure Construction
       He was bitten (by a toddler)
  construction PassiveTransitiveAction2
  subcase of VP
  constituents:
   V : PassiveVerb
    (PP: agentivePP)
  form
   constraints:
      VF before PPF
  meaning: CauseEffectAction
    evokes; EventDescriptor as ED; ForceApplication as FA
    constraints:
     {Selfm ↔ ED.EventType}
     {Vm ↔ ED.ProfiledProcess}
     Affected ↔ ED.ProfiledParticipant
      FA ↔ Vm
     Causer ↔ FA.Actor
     Affected ↔ FA.ActedUpon
     Causer ↔ PP.NPm
                Semantic Specification
                He was bitten (by a toddler)
EventDescriptor
 eventtype
 ProfiledProcess       CauseEffect        ForceApplication
 ProfiledParticipant    causer             actor
                        affected           actedupon
                                           routine  bite
                                           effector  teeth

          RD27
          category      Person


                                     RD48
                       Person
                                     category
          Simulation -
    He was bitten (by a toddler)
CauseEffect


  Action = Bite                   Protagonist =
                                  Causer ↔ Actor




Protagonist    Effect = Process
= Affected ↔
ActedUpon
       Variations on a theme
• He shattered the window
• The window was shattered
• The window shattered
          Verb Construction -- shatter
Construction SHATTER1                     schema StateChange
 subcase of Verb                           subcase of Process
 form: shatter                             roles
 meaning: StateChange                         Undergoer ↔ Protagonist
   constraints:
     Initial :: Undergoer.state ← whole
     Final :: Undergoer.state ← shards
Argument Structure Construction
           He shattered the window
  construction ActiveTransitiveAction3
   subcase of VP
   constituents:
     V : verb
     NP: NP
   form
    constraints:
        VF before NPF
   meaning: CauseEffect
     evokes: EventDescriptor as ED; StateChange as SC
     constraints:
      {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Causer ↔ ED.ProfiledParticipant
      SC ↔ Vm
      Affected ↔ SC.Undergoer
      Affected ↔ NPm
                Semantic Specification
                       He shattered the window
EventDescriptor
 eventtype
 ProfiledProcess           CauseEffect        StateChange
 ProfiledParticipant        causer             Undergoer
                            affected           state  “wholeness”




          RD27
          category          Person


                                         RD189
                           Window
                                         category
                     Simulation -
                 He shattered the window

CauseEffect

   Action
                                 Protagonist =
                                 Causer




 Protagonist =
 Affected ↔
                   Process
 Undergoer
Argument Structure Construction
        The window was shattered
  construction PassiveTransitiveAction3
  subcase of VP
  constituents:
   V : PassiveVerb
    (PP: agentivePP)
  form
   constraints:
      VF before NPF
  meaning: CauseEffect
    evokes: EventDescriptor as ED; StateChange as SC
    constraints:
     {Selfm ↔ ED.EventType}
     {Vm ↔ ED.ProfiledProcess}
      Affected ↔ ED.ProfiledParticipant
     SC ↔ Vm
     Affected ↔ SC.Undergoer
     Causer ↔ PP.NPm
                Semantic Specification
                  The window was shattered
EventDescriptor
 eventtype
 ProfiledProcess       CauseEffect        StateChange
 ProfiledParticipant    causer             Undergoer
                        affected           state  “wholeness”




                                     RD175
                       Window
                                     category
                   Simulation -
             The window was shattered

CauseEffect

   Action
                             Protagonist =
                             Causer




 Protagonist =
 Affected ↔
                 Process
 Undergoer
Argument Structure Construction
             The window shattered
  construction ActiveIntransitiveAction1
   subcase of VP
   constituents:
     V : verb
   form
   meaning: Process
     evokes: EventDescriptor as ED; StateChange as SC
     constraints:
      {Selfm ↔ ED.EventType}
      {Vm ↔ ED.ProfiledProcess}
      Protagonist ↔ ED.ProfiledParticipant
      SC ↔ Vm
      Protagonist ↔ SC.Undergoer
                Semantic Specification
                       The window shattered
EventDescriptor
 eventtype
 ProfiledProcess          Process             StateChange
 ProfiledParticipant       protagonist         Undergoer
                                               state  “wholeness”




                                         RD177
                         Window          category
                  Simulation -
                The window shattered

Process




Protagonist =
Undergoer
                Process
Some more variations on a theme


• He bit the apple
• He bit into the apple
• His white teeth bit into the apple.
Argument Structure Construction
                   He bit into the apple
construction ActiveEffectorMotionPath2
    subcase of VP
    constituents:
        V : verb
        PP: Spatial-PP
     form
 constraints:
          VF before PPF
meaning: EffectorMotionPath
  evokes; EventDescriptor as ED; ForceApplication as FA
  constraints:
          {Selfm ↔ ED.EventType}
          {Vm ↔ ED.ProfiledProcess}
          Actor ↔ ED.ProfiledParticipant
          FA ↔ Vm
          Actor ↔ FA.Actor
          Effector ↔ FA.Effector // INI
          Target ↔ FA.ActedUpon
          SPG ↔ PPm
          Target ↔ PPm .Prep.LM
                        Schema

schema EffectorMotionPath
 subcase of EffectorMotion
 subcase of SPG // or evokes SPG
  roles
    Actor ↔ MotorControl.protagonist
    Effector ↔ SPG.Tr ↔ M.Mover ↔ Motion.protagonist
    Target ↔ SPG.Lm
                  Schema Network
                  Contact

                                    MotorControl
Process        ForceTransfer


                                                        Motion
                 ForceApplication     Effector                    SelfMotion
CauseEffect                           Motion
                                                     MotionPath
                                     Effector
                                     MotionPath          SPG
                                                                  SelfMotion
                                                                  Path


              Agentive Impact        SpatiallyDirectedAction
                                                                  Contact
Argument Structure Construction
                   He bit into the apple
construction ActiveEffectorMotionPath2
    subcase of VP
    constituents:
        V : verb
        PP: Spatial-PP
     form
 constraints:
          VF before PPF
meaning: EffectorMotionPath
  evokes: EventDescriptor as ED; ForceApplication as FA
  constraints:
          {Selfm ↔ ED.EventType}
          {Vm ↔ ED.ProfiledProcess}
          Actor ↔ ED.ProfiledParticipant
          FA ↔ Vm
          Actor ↔ FA.Actor
          Effector ↔ FA.Effector // INI
          Target ↔ FA.ActedUpon
          SPG ↔ PPm
          Target ↔ PPm .Prep.LM
         EffectorMotionPath
Action                    Protagonist = Actor




 Effector
 Motion
                          Protagonist = Effector




 Source     Path   Goal
Argument Structure Construction
                   He bit into the apple
construction ActiveEffectorMotionPath2
    subcase of VP
    constituents:
        V : verb
        PP: Spatial-PP
     form
 constraints:
          VF before PPF
meaning: EffectorMotionPath
  evokes; EventDescriptor as ED; ForceApplication as FA
  constraints:
          {Selfm ↔ ED.EventType}
          {Vm ↔ ED.ProfiledProcess}
          Actor ↔ ED.ProfiledParticipant
          FA ↔ Vm
          Actor ↔ FA.Actor
          Effector ↔ FA.Effector // INI
          Target ↔ FA.ActedUpon
          SPG ↔ PPm
          Target ↔ PPm .Prep.LM
Simulation: He bit into the apple
  Action                    Protagonist = Actor




   Effector
   Motion
                            Protagonist = Effector




   Source     Path   Goal
Argument Structure Construction
        His white teeth bit into the apple
construction ActiveEffectorMotionPath3
    subcase of VP
    constituents:
        V : verb
        PP: Spatial-PP
     form
 constraints:
          VF before PPF
meaning: EffectorMotionPath
  evokes; EventDescriptor as ED; ForceApplication as FA
  constraints:
          {Selfm ↔ ED.EventType}
          {Vm ↔ ED.ProfiledProcess}
          Effector ↔ ED.ProfiledParticipant
          FA ↔ Vm
          Actor ↔ FA.Actor // INI
          Effector ↔ FA.Effector
          Target ↔ FA.ActedUpon
          SPG ↔ PPm
          Target ↔ PPm .Prep.LM
Simulation: His white teeth bit into the apple

   Action                    Protagonist = Actor




    Effector
    Motion
                             Protagonist = Effector




    Source     Path   Goal
              Non-agentive biting
• He landed on his feet, hitting the narrow pavement
  outside the yard with such jarring impact that his
  teeth bit into the edge of his tongue. [BNC]

• The studs bit into Trent's hand. [BNC]

• His chest burned savagely as the ropes bit into his
  skin. [BNC]
                  Schema Network
                  Contact

                                    MotorControl
Process        ForceTransfer


                                                        Motion
                 ForceApplication     Effector                    SelfMotion
CauseEffect                           Motion
                                                     MotionPath
                                     Effector
                                     MotionPath          SPG
                                                                  SelfMotion
                                                                  Path


              Agentive Impact        SpatiallyDirectedAction
                                                                  Contact
Simulation: His teeth bit his tongue




Motion
                        Protagonist = Mover




Source   Path   Goal
                Summary
• Small set of constructions and schemas
• Composed in different ways
• Unification produces specification of
  parameters of simulation
• Sentence understanding is simulation
• Different meanings = different simulations
       Concluding Remarks
• Complexity
• Simulation
          Concluding Remarks
• Complexity
• Simulation
• Language understanding is simulation
• Simulation involves activation of
  conceptual structures
• Simulation specifications should include:
    – which conceptual structures to activate
    – how these structures should be activated
Extra slides follow:
    Prototypes and extensions?
CauseMotion Path:
• He threw the ball across the room
• He kicked the ball over the table
• He sneezed the napkin off the table
• [He coughed the water out of his lungs]
                 Key points
• In prototypical verb-argument structure
  construction combinations, verb meaning is very
  similar to argument structure meaning.
• Verbs whose meaning partially overlaps that of a
  given argument structure constructions may also
  co-occur with that argument structure construction
• These less prototypical combinations may
  motivate extensions to the central argument
  structure constructions

								
To top