..........................................NEXT PREVIOUS INDEX
 

 L03 FS: CFG & Unification: Processing


            CFG & Unification: Processing


o  Order of unification not important.  Illustrated below
   by several different evaluation orders.
   +  Example sentence: a child sees toys.
   +  Parse tree for example sentence:
  
                   S                    
                   |                    
            -------------               
            |           |               
           NP1         VP               
            |           |               
         ------     --------            
         |    |     |      |            
        det   n     v     NP2           
         |    |     |      |            
         a  child sees     n             
                           |            
                         toys   
        
      *  Labels 1 and 2 are put on NP to refer to them 
         umambiguously.    

    -  Feature equations may be solved in any order.

+  Ex.1.  Suppose functional equations solved bottom-up on parse tree

o  Evaluation order 1.1: left-to-right, bottom-up on parse tree
   - Start evaluation with leaf nodes of NP
 
                 NP                             
                 |                             
           --------------
           |            |                           
          det           n 
           |            |                           
           a          child
      
    + Function equations are:
       -  FS(det)  =  FS from lexical entry for 'a'
       -  FS(n)    =  FS from entry for 'child'
       -  FS(NP1) =  FS(det)  U  FS(n)

    + Feature structure (FS) satisfying above equations, are shown 
      attached to nodes below (see lines with dots):

                   NP                             
                   |                             
             --------------
             |            |                           
            det           n 
             |            |                           
             a          child
             .            .
             .            .
             .       [CAT       n           ]
             .       [AGRMNT  [NUMBER   sg] ]
             .       [        [PERSON    3] ]
             .
        [SPEC    indef         ]
        [AGRMNT  [NUMBER   sg] ]
        [        [PERSON    3] ]

    +  Resulting FS for NP:

         [ CAT         n            ]
         [ SPEC        indef        ]
         [ AGRMNT      [NUMBER  sg] ]
         [             [PERSON   3] ]

o  Evaluation order 1.2: Right-to-left, bottom-up on parse tree
   - Start evaluation with leaf nodes of VP

                  VP               
                  |               
              --------            
              |      |            
              v      NP            
              |      |            
             sees    n            
                     |            
                   toys           

    -  FS(VP).AGRMNT =  FS(v).AGRMNT. Now, FS for VP is:

         [TENSE   prsnt         ]
         [AGRMNT  [NUMBER   sg] ]

    -  FS(NP1).AGRMNT =  FS(VP).AGRMNT
        *  At this point, the two FSs are checked for compatibility.
        *  Note: In case one FS was not already built, it would 
           get defined by unification (rather than checked).

o  Another evaluation order 2:  Suppose equations are solved
   from buttom-to-top (for VP subtree) and then top-to-bottom
   (for subject NP subtree).  

           :-----------<--------------:
          :              S             :     Functional
         :               |               :    equation
        :         -------------            :   evaluation-
       :          |           |              :  order
      :          NP1         VP               :
     v            |           |                ^
    :          ------     --------              :
   :           |    |     |      |               :
   :          det   n     v     NP2               :
   :           |    |     |      |                 :
 <-:           a  child sees     n                  : 
                                 |                   <--
                               toys   


     -  FS(VP).AGRMNT =  FS(v).AGRMNT

          [TENSE   prsnt         ]
          [AGRMNT  [NUMBER   sg] ]

     -  FS(NP1).AGRMNT =  FS(VP).AGRMNT
        *  FS for AGRMNT attribute of NP gets defined.
        *  Note:  NP1 has not yet been formed. Its lexical
           entries 'a' and 'child' not yet looked up in lexicon.

     -  FS(NP1) = FS(det)  U  FS(n)
        *  This results in a check to be performed for attribute
           AGRMNT in NP1, det and n. (Value for NP1 already defined
           in previous step.)
        *  As mentioned earlier,  '=' is also unification.
   
o  Another evaluation order 3: Unification along with derivation of
   parse tree.
   +  Ex.  One possible context free derivation.

         -  S
         -  NP VP
         -  det n VP
         -  a child VP
         -  a child v NP
         -  a child sees NP
         -  a child sees n
         -  a child sees toys

   -  Evaluate feature equations along side

         -  S
         -  NP VP          -->  FS(NP).AGRMNT = FS(VP).AGRMNT  -- Eqn 1
         -  det n VP       -->  FS(NP) = FS(det) U FS(n)
         -  a child VP     -->  FS(NP) =
                       [SPEC  indef      ]
                       [CAT   n          ]
                       [AGRMNT [NUM S6]  ]
                       [       [PERS 3]  ]

           *  Note: FS for VP has the value of AGRMNT.
              the moment FS for NP is formed. (See Eqn (1))
..........................................NEXT PREVIOUS INDEX