;;; The head-complement rule is described in the textbook as being a
;;; single rule. In fact, part of the justification for eliminating the [
;;; VAL int|tr|dtr ] feature and introducing the head-complement rule is
;;; precisely because the revision reduces the number of rules needed from
;;; 3 to 1.  However, it turns out that the notation used in the textbook
;;; is imprecise in the computational system of the LKB.  It's still
;;; necessary to explicitly detail a head-complement rule for heads that
;;; take 0, 1, and 2 complements.

;;; Note that the rules here are written slightly different than in the
;;; textbook.  Rather than the --> notation we're simply embedding
;;; everything that occurs to the right of the arrow in a feature called
;;; ARGS (for arguments) in the resulting structure (the structure built
;;; on the left-hand side of the arrow).  Also, we're currently hand
;;; encoding the Head Feature Priniciple and the Valence Principle into
;;; the rules themselves.  In the next iteration of the grammar we'll show
;;; how to tease out these constraints so that they apply to all rules,
;;; and don't have to be redundantly specified.

head-complement-rule-0 := phrase & 
[ HEAD #0,
  SPR #a,
  COMPS < >,   

  ARGS < word & 
         [ HEAD #0,
           SPR #a, 
           COMPS < > ] >  ].


head-complement-rule-1 := phrase &
[ HEAD #0,
  SPR #a, 
  COMPS < >,   

  ARGS < word & 
         [ HEAD #0,
           SPR #a, 
           COMPS < #1 & [ SPR < > ] > ],  #1 >  ].


head-complement-rule-2 := phrase &
[ HEAD #0,
  SPR #a, 
  COMPS < >,   

  ARGS < word & 
         [ HEAD #0,
           SPR #a, 
           COMPS < #1, #2 & [ SPR < > ] > ],  #1, #2 >  ].


head-specifier-rule := phrase &
[ HEAD #0,
  SPR < >,
  COMPS #a,

  ARGS < phrase & 
         #1 & [ SPR < > ],   phrase & 
                             [ HEAD #0,
                               SPR < #1 >,
                               COMPS #a ] > ].