The fundamental phrase structure schema

The LexGram interpreters (parser, generator) are instances of an abstract grammar interpreter which is defined by the following phrase structure schema where the leaves are annotated with triples of a category, a string ( Phon value), and a Slash value.

             ( root : Root &
               leaves : Leaves )
             concat(Dir,APhon,FPhon)
             ASlash+FSlash
            /                 \
         A /                   \ F
          /                     \
( root : ArgRoot &              ( root : Root &
  leaves : ArgLvs )               leaves : [ ( dir : Dir &
APhon                                          root : ArgRoot &
ASlash+ToBind                                  leaves : ArgLvs &
                                               slash : ToBind )
                                             | Leaves ] )
                                 FPhon
                                 FSlash

concat(Dir,APhon,FPhon) concatenates the argument string  APhon and the functor string  FPhon according to the direction information  Dir. ASlash+FSlash means that the 'inherited slash' information is split nondeterministically into two disjoint subsets ASlash and FSlash. The (pre-)terminal schemata for (nonempty) words and for traces resp. read as follows ( EMPTY is the empty list or set.)

       Category                   Category
       Word                       EMPTY
       EMPTY                      Category
          |                          |
        Word                       TRACE

If you are acquainted with a sequent-based natural deduction style presentation of inference rules, you may rewrite the fundamental rule schema and the terminal schemata in the following manner, where |- separates the database (the categories for the input words and traces) from the goal category, and the colon divides the Phon value (now the lexical categories) from the Slash value (empty categories). The . means list concatenation.

APhon ; ASlash+ToBind |- ( root : ArgRoot &              
                           leaves : ArgLvs ) 

FPhon ; FSlash |-  ( root : Root &
                     leaves : [ ( dir : left &
                                  root : ArgRoot &
                                  leaves : ArgLvs &
                                  slash : ToBind )
                                | Leaves ] )
---------------------------------------------------------------
APhon.FPhon ; ASlash+FSlash |- ( root : Root &
                                 leaves : Leaves )

Here is the rule variant for the right direction.

FPhon ; FSlash |-  ( root : Root &
                     leaves : [ ( dir : right &
                                  root : ArgRoot &
                                  leaves : ArgLvs &
                                  slash : ToBind )
                                | Leaves ] )

APhon ; ASlash+ToBind |- ( root : ArgRoot &              
                           leaves : ArgLvs ) 
---------------------------------------------------------------
FPhon.APhon ; ASlash+FSlash |- ( root : Root &
                                 leaves : Leaves )

The axiom schemata read

Word ; EMPTY |- Category
----------------------------
Category ; EMPTY |- Category


EMPTY ; Category |- Category

for lexical resp. empty functor categories, where EMPTY designates an empty list or set. In addition, the words in the list of leaves of a proof must correspond to the input string. For more detailed information see [].

By virtue of the fundamental rule, we can think that the previously introduced category for the verb  eats corresponds to the following partial tree.

        (root:syn:s &
         leaves:[])
      /              \
(root:syn:np &    (root:syn:s &
 leaves:[])        leaves:[(dir:left &
                            root:syn:np &
                            leaves:[] &
                            slash:[])])
                           /               \    
              (root:syn:s &              (root:syn:np
               leaves:[(dir:right &       leaves:[])
                        root:syn:np &     
                        leaves:[] &       
                        slash:[]),
                       (dir: left &
                        root:syn:np &  
                        leaves:[] & 
                        slash:[])]) 
                      | 
                     eats