Tree Fragments

This abstraction level defines the building blocks of the grammar as tree descriptions. The objects of operation are shared structures of grammatical information: verbal spines, features and verbal arguments.

The elementary building blocks are fragmentary tree descriptions associated with a unique name and defined in classes. The XMG language allows for factoring out tree fragments by organising them in an inheritance hierarchy. The inheritance is controlled by the export and import declarations. The former allows the identifiers in a given class to be further inherited, whereas the latter allows one to include in a tree description the grammar information of upper classes. A tree fragment is specified as a set of node variables and relations that hold the between the nodes (precedence, dominance or equality). Further on, each node identifier contains (either locally defined or inherited by another class) the information as follows:

Verbal Spine

The hierarchy of the verbal spine forms a three-branch tree with one top node called VerbalTop. This mother class defines the skeleton of verb forms. It is inherited in VerbalNonInverted, VerbalInverted and Verbless classes.


VerbalTop

This class provides the skeleton of verbs: a V node projecting a VP or N node and rooted in S or NP node. The N projection and the NP root are needed to derive gerund forms and relative clauses. Features are added to impose additional constraints on the derived tree. There is no inversion or extraction on the root node (hence, <inv= -- > and <extracted = -- >). Each node is painted in black to allow merging with the tree descriptions of verbal arguments.

<VerbalTop>=
class  VerbalTop
export ?Sr ?VP ?V  
declare ?Sr ?VP ?V  ?fP ?fN ?fAC ?fACP ?fM ?fP1 ?fN1 ?fAC1 ?fACP1 ?fM1 ?fPass ?fTense ?fTense1 ?fPass1 ?fMV1
{<syn>{ 
        node ?Sr(color=black)[cat=@{s,np},bot=[inv= -, comp = nil, extracted = -,pass=?fPass,
                                pers=?fP,num=?fN,mode=?fM,tense=?fTense,assign-case=?fAC,assign-comp=?fACP]]{
                node ?VP (color=black)[cat=@{vp,n},
                     top=[pass=?fPass,pers=?fP,num=?fN,mode=?fM,tense=?fTense,assign-case=?fAC,assign-comp=?fACP],
                     bot=[mainv=?fMV1,pers=?fP1,num=?fN1,mode=?fM1,tense=?fTense1,pass=?fPass1,assign-case=?fAC1,
                        assign-comp=?fACP1,compar = -]]{
                    node ?V(color=black)[cat=v,
                     top=[mainv=?fMV1,pers=?fP1,num=?fN1,mode=?fM1,tense=?fTense1,pass=?fPass1,assign-case=?fAC1,
                     assign-comp=?fACP1,punct-struct=nil]]
                                                                                                                }
                                                                                                        }
        }
}
Defines VerbalTop (links are to index).

VerbalNonInverted

This class inherites from the imported one the verbal skeleton. Here the V node is defined as an anchor node. The active and passive classes inherit the information about the verb skeleton and the verb anchor. These classes specify the terminal tree descriptions of verb forms: active form with <passive = --> and passive form with <passive = +> and <mode = ppart>.

<*>= [D->]
class  VerbalNonInverted
import VerbalTop[]
{<syn> { 
         node ?V(mark=anchor)
        }
}

class  active
import VerbalNonInverted[]
{<syn> {
        node ?V[top=[pass = - ]]
        }
}

class  passive
import VerbalNonInverted[]
{<syn> { 
       node ?V[top =[mode = ppart, pass = +]]
        }       
}
Defines active, passive, VerbalNonInverted (links are to index).

VerbalInverted

To allow for inversion, this class adds to the root node of the mother class two nodes: an Sq root node dominating a Vq anchor. Thus, the <inv> becomes positively marked. The non-inverted verb item is filled with an empty category. The inverted V anchor node is coindexed with the non-inverted verb item by means of the <trace> feature.

<*>+= [<-D->]
class  VerbalInverted
import VerbalTop[]
declare ?Sq ?Vq  ?fM ?fC ?fP ?fN ?fT ?fM1 ?fTr
{<syn> {
        node ?Sq (color=black) [cat=s,bot=[inv= +, extracted = -, mode=?fM,comp=nil]];
        node ?Vq(color=red,mark=anchor)[cat=v,top=[assign-case=?fC,pers=?fP,num=?fN,tense=?fT,mode=?fM1,trace=?fTr]];
        node ?V [bot=[mode=?fM1,trace=?fTr,phon=e]] ;
             ?Sq ->* ?Vq ; 
             ?Sq ->* ?Sr ;
             ?Vq >> ?Sr 
         }
}
Defines VerbalInverted (links are to index).

Verbless

The so called 'verbless' class is needed to saturate families anchored not by a verb but by another part of speech (adjective, adverb, noun or preposition). The verb form is filled with an empty category.

<*>+= [<-D->]
class  verbless
import VerbalTop[]
{<syn> { 
        node ?V[phon=e]
        }
} 
Defines verbless (links are to index).

Particle

This class does not inherit any information from another class. It is defined as a stand-alone tree description dominated by a VP or N node and two daughters: a verb and a particle coanchor. To allow for particle movement, the verb does not precede immediately the particle. The particle cannot be merged with any other nodes and hence, it is painted in red.

<*>+= [<-D->]
class  particle
declare  ?xVP ?xV ?xPl
{ <syn> { 
          node ?xVP (color=white)[cat=@{vp,n}]{
               node ?xV (color=white)[cat=v] 
               ,,,node ?xPl(color=red,name=Particle,mark=coanchor)[cat=pl]
                                                }
         } 
}
Defines particle (links are to index).

Features

To ensure well-formed grammar, the tree descriptions are decorated with features. The most common feature structures which are applicable to more than one class are factorised in separate classes. In this way, a class of a tree description can import the relevant feature description. These are:

<Features>=
class  SubjectAgreement 
export ?Subj ?xagr ?S ?fAC
declare ?Subj ?xagr ?S ?fP ?fN ?fP1 ?fN1 ?fAC ?fAC1 ?fWH1 
{<syn>{ 
        node ?S[bot=[assign-case=?fAC,pers=?fP,num=?fN,wh=?fWH1]];
             node ?Subj (gf=subj)[top =[case=?fAC,pers=?fP,num=?fN,wh =?fWH1]];
             node ?xagr [top =[assign-case=?fAC,pers=?fP,num=?fN],bot=[assign-case=?fAC1,pers=?fP1,num=?fN1]]                   
        }
}

class  MovementAgreement
export ?Sr ?WH1 ?WhArg 
declare ?Sr ?WH1 ?WhArg ?fP ?fN ?fAC
{<syn> {
        node ?WH1 [top = [pers=?fP, num=?fN, case=?fAC]];
             node ?WhArg [top=[pers=?fP, num=?fN, case=?fAC]]
        }
}

class  PrepCaseAssigner
export ?PP ?P  ?NP
declare ?PP ?P ?fX ?NP  ?fY
{<syn> {
        node ?PP [bot=[assign-case=?fX, wh = ?fY]]{
            node ?P [top=[assign-case=?fX]]
            node ?NP[top=[case=?fX, wh = ?fY]]
                                                }
        }; ?fX = acc
}

class  VerbCaseAssigner
export ?verbph ?verb ?NP2 ?NP1 
declare ?verbph ?verb ?NP2 ?NP1 ?fAC ?fAC1
{<syn> {
        node ?verbph [bot=[assign-case=?fAC1]]{
            node ?verb[top=[assign-case=?fAC1]]
            ,,,node ?NP2[top=[case=acc]]
            ,,,node ?NP1[top=[case=acc]]
                                        }
        }
}

class  Inversion
export ?InvS
declare ?InvS ?fI
{<syn> { 
        node ?InvS [bot = [invlink = ?fI, inv = ?fI, wh= ?fI]]
        }
}
Defines Inversion, MovementAgreement, PrepCaseAssigner, SubjectAgreement, VerbCaseAssigner (links are to index).

Verbal Arguments

The elementary trees of the verbal arguments are factored out in a hierarchical network with a single mother node -- VerbalArgument. On the basis of the linear order of the predicate arguments, the hierarchical classes are further partitioned in five major groups with the following mother classes:

VerbalArgument

The VerbalArgument class is a single mother node in the predicate-argument hierarchy which provides the skeleton of predicate arguments: a root S, NP or N node dominating a VP, A or N node. The nodes are coloured in white so that they can merge with a verb form.

<VerbalArgument>=
class  VerbalArgument
export ?XP ?VP
declare ?XP ?VP     
{<syn> {
        node ?XP(color=white)[cat = @{s,np,n}]{
            node ?VP(color=white)[cat = @{vp,a,n}]
                                        }               
        }
}
Defines VerbalArgument (links are to index).

SubjectArgumentTop

This top subject argument class adds to the VerbalArgument definition a Subj node which is dominated by the root S node and which precedes the VP node. This mother class is subdivided into three main subject classes: SubjectArgument, SubjectXCoanchorCan and SubjectOuterTop.

<SubjectArgumentTop>=
class  SubjectArgumentTop
import VerbalArgument[]
       SubjectAgreement[]
export  ?fCtrl ?fPrg ?fPerf ?fMV
declare ?fCtrl ?fPrg ?fPerf ?fMV
{<syn> {
        node ?XP[cat=s,bot=[control=?fCtrl,progress= ?fPrg,perf=?fPerf,mainv=?fMV]]{
            node ?Subj [top=[control=?fCtrl]]
            node ?VP [cat=vp,top=[progress= ?fPrg,perf=?fPerf,mainv=?fMV]]
                      }
        }; ?XP = ?S ; ?VP = ?xagr                
}
Defines SubjectArgumentTop (links are to index).

SubjectArgument

The SubjectArgument class is a mother of tree descriptions which contain one node for the subject argument. This Subj node is a fully saturated node and therefore it is painted in red. This class has been further inherited in the following terminal classes of subject arguments:
<*>+= [<-D->]
class  SubjectArgument
import SubjectArgumentTop[]
{<syn> { 
         node ?Subj(color=red)[top=[wh = -]]
       }
}

class  CanSubject
import SubjectArgument[]
{<syn> { 
         node ?Subj(mark=subst)[cat=np]
        }; ?fAC = nom   
}


class  CanSententialSubject
import SubjectArgument[]
{<syn> {
        node ?Subj(mark=subst)[cat=s,top=[mode=@{inf,ind},comp=@{that,whether,for,nil},assign-comp=inf_nil]]
       }
}

class  ImperativeSubject
import SubjectArgument[] 
declare ?X
{<syn> { 
         node ?XP [top=[inv = -], bot=[mode=imp]]{
            node ?Subj(mark=nadj)[cat=np,top=[wh = -,pers=2,num=@{sing,plur}]]{
                node ?X(color=red,mark=flex)[phon=e]}
            node ?VP[top=[tense=pres],top=[mode=imp]]}
        } ; ?fAC = nom
}

class  ProSubject
import SubjectArgument[]
declare ?X 
{<syn> {
        node ?XP[bot=[assign-case=?fAC]]{
                node ?Subj(mark=nadj)[cat=np,top=[case = none]]{
                        node ?X(color=red,mark=nadj)[cat=Pro]}
                node ?VP [top=[mode=@{inf,ger,ind}]]   
                                                    
                                       }
        }
}
Defines CanSententialSubject, CanSubject, ImperativeSubject, ProSubject, SubjectArgument (links are to index).

SubjectXCoanchorCan

This tree description is defined to ensure well-formed passive diathesis in idiom verb families (this includes n0VDN1, n0VDAN1, n0VN1 and n0VAN1). Unlike SubjectArgument where the Subj node was marked for substitution, here the it dominates a coanchor node. The coanchor is coloured in red since it forms a fully saturated tree node and no merging with this node is permissible. On the basis of its category the subject coanchor is subdivided into the following terminal tree descriptions:

<*>+= [<-D->]
class  SubjectXCoanchorCan
import SubjectArgumentTop[]
export ?xcoanch
declare ?xcoanch 
{<syn> { 
         node ?Subj [cat=np]{
             node ?xcoanch(color=red,mark=coanchor)
                           }   
        }; ?fAC = nom
}

class  SubjectNCoanchorCan
import SubjectXCoanchorCan[]
{<syn> { 
         node ?Subj (color=black){
             node ?xcoanch(name=Noun,rank=3)[cat=n]
                                }
        }
}

class  SubjectAdjCoanchorCan
import SubjectXCoanchorCan[]
{<syn> { 
         node ?Subj (color=white){
             node ?xcoanch(name=Adjective,rank=2)[cat=a]
                                }
        }
}

class  SubjectDetCoanchorCan
import SubjectXCoanchorCan[]
{<syn> { 
         node ?Subj (color=white){
             node ?xcoanch(name=Determiner,rank=1)[cat=det]
                                }
        }
}
Defines SubjectAdjCoanchorCan, SubjectDetCoanchorCan, SubjectNCoanchorCan, SubjectXCoanchorCan (links are to index).

SubjectOuterTop

The so called 'outer' subject is defined to ensure well-formed outer passive diathesis of idiom verb families which subcategorise for a PP (these include n0VN1Pn2, n0VDN1Pn2, n0VDAN1Pn2 and n0VAN1Pn2). In outer passive, the object of the PP is extracted out of its canonical position and is realised before the verb form. This does not imply wh-movement. The empty object of PP and the subject are coindexed by the <trace> feature. The mother class SubjectOuterTop falls in two terminal desriptions as follows:

<*>+= [<-D->]
class  SubjectOuterTop
import SubjectArgumentTop[]
       PrepCaseAssigner[]
export ?xverb ?xprepph ?xprep ?xe ?fT
declare ?xverb ?xprepph ?xprep ?xe ?fT
{<syn> { 
         node ?VP {
            node ?xverb(color=white)[cat=v]
            ,,,node ?xprepph(color=red,rank=6)[cat=pp]{
                    node ?xprep(color=red,mark=coanchor,name=Prep)[cat=prep]
                    node ?xe(color=red)[phon=e,cat=np,top=[trace=?fT]]
                                                }
                }
        };  ?xprepph = ?PP ; ?xprep = ?P ; ?xe = ?NP
}

class  SubjectOuterCan
import SubjectOuterTop[]
{<syn> {
        node ?Subj (color=red,mark=subst)[cat=np,top=[trace=?fT,wh = -]]
       }; ?fAC = nom
}

class  SubjectOuterPro
import SubjectOuterTop[]
declare ?X
{<syn> {
        node ?Subj(color=red,mark=nadj)[cat=np,top=[case = none,trace=?fT]]{
                 node ?X(color=red,mark=nadj)[cat=Pro]
                                                        }
        }
}
Defines SubjectOuterCan, SubjectOuterPro, SubjectOuterTop (links are to index).

CanComplement

The group of canonical complements with CanComplement mother node comprises non-extracted sentential and nominal arguments whose canonical position is after the verb (hence the V node declaration). The V node is painted in white so that it could merge with the verb anchor of the verbal skeleton. The CanComplement breaks down in 12 subclasses as follows: CanObject, CanIObject, CanLocative, CanBEComplement, ComplementCoanchorCan, CanXAnchor, CanPPIObject-VPE, CanPPTop, AdjCoanchorCanR, CanSentComplement, CanSentComplement2 and PPAnchorTop.

<*>+= [<-D->]
class  CanComplement
import VerbalArgument[]
export ?V ?compl
declare ?V ?compl
{<syn> {
        node ?VP[cat=vp]{
                node ?V(color=white)[cat=v]
                ,,,node ?compl[top=[wh = -]]
                }
        }
}
Defines CanComplement (links are to index).

CanObject

This terminal class provides the tree description of a direct object in its canonical position. The complement node is specified as an NP node marked for substitution. It is of rank 2 so that the indirect object (in n0Vn2n1 family) can precede the direct complement. Here we also import the VerbCaseAssigner feature description to ensure that the verb selecting a canonical complement assigns an accusative case to it. This has been defined by equating the relevant CanComplement node variables with the relevant VerbCaseAssigner ones.

<*>+= [<-D->]
class  CanObject
import CanComplement[]
       VerbCaseAssigner[] 
{<syn> {
        node ?compl(color=red,mark=subst,gf=obj,rank=2)[cat=np]
        }; ?VP = ?verbph ; ?V = ?verb ; ?compl = ?NP1
}
Defines CanObject (links are to index).

CanIObject

This terminal class provides the tree description of a canonical indirect object. Its complement node is an NP node marked for substitution. It is of rank 1 so when generating the n0Vn2n1 tree family the indirect complement precedes the direct one. The class imports the VerbCaseAssigner class to ensure that the verb selecting a canonical indirect object assigns an accusative case to the complement. This has been defined by equating the relevant CanComplement node variables with the relevant VerbCaseAssigner ones.

<*>+= [<-D->]
class  CanIObject
import CanComplement[]
       VerbCaseAssigner[] 
{<syn> {
        node ?compl(color=red,mark=subst,gf=iobj,rank=1)[cat=np]
        }; ?V = ?verb; ?VP = ?verbph ; ?compl = ?NP2 
}
Defines CanIObject (links are to index).

CanLocative

This class provides a tree fragment of adverbial anchor. It appears in n0n1ARB. The tree descriptions adds to the complement node of the CanComplement class two daughter nodes: an NP marked for substitution and an Adv anchor node. Both nodes are coloured in red and hence no combination is allowed with these two nodes.

<*>+= [<-D->]
class  CanLocative
import CanComplement[]
       VerbCaseAssigner[] 
declare ?xNP ?xAdv ?fWh
{<syn> {
        node ?compl(color=red,gf=obj,rank=2)[cat=advp,bot=[wh=?fWh]]{
             node ?xNP (color=red,mark=subst)[cat=np,top=[wh=?fWh]]
             node ?xAdv (color=red,mark=anchor)[cat=adv]}
        }; ?VP = ?verbph ; ?V = ?verb ; ?compl = ?NP1
}
Defines CanLocative (links are to index).

CanBEComplement

This complement is used in equative BE family. The tree description adds to the complement node of the CanComplement class two daughter nodes: an empty verb category and an NP substitution node.

<*>+= [<-D->]
class  CanBEComplement
import CanComplement[]
declare ?Ve ?xNP
{<syn> { 
         node ?compl (color=red)[cat=vp,bot=[compar= -]]{
              node ?Ve(color=red)[cat=v,phon=e]
              node ?xNP(color=red,mark=subst)[cat=np,gerund= -, case=@{nom,acc}]
                                                          }
        }
}
Defines CanBEComplement (links are to index).

ComplementCoanchorCan

The definition of this class can be viewed in parallel to the SubjectXCoanchor class. The ComplementCoanchorCan provides a tree description of an object coanchored by an argument. It appears in the active diathesis of verb families of idioms. The node is fully saturated node and hence painted in red. The category of the coanchor node is the criterion for importing this class into three terminal classes as follows:

<*>+= [<-D->]
class  ComplementCoanchorCan
import CanComplement[]
       VerbCaseAssigner[] 
export ?xcoanch 
declare ?xcoanch
{ <syn> { 
          node ?compl(gf=obj)[cat=np]{
             node ?xcoanch(color=red,mark=coanchor)
                                                }
        };?compl = ?NP1 ; ?V = ?verb ; ?VP = ?verbph
}

class  ObjectNCoanchorCan
import ComplementCoanchorCan[]
declare ?fC ?fP ?fN ?fWH ?fDef ?fPron ?fCmp
{ <syn>{
        node ?compl(color=black,rank=2)[bot=[case=?fC,pers=?fP,num=?fN,wh=?fWH,definite=?fDef,pron=?fPron,compar=?fCmp]]{
             node ?xcoanch(rank=3,name=Noun)[cat=n,top=[case=?fC,pers=?fP,num=?fN,wh=?fWH,definite=?fDef,pron=?fPron,compar=?fCmp],bot=[compar= -]]
                                                                        }
        }
}

class  AdjCoanchorCan
import ComplementCoanchorCan[]
declare ?A ?fCmp ?fWH 
{<syn> {
        node ?compl (color=white)[bot=[compar=?fCmp,wh=?fWH]]{
             node ?xcoanch(rank=2,name=Adjective)[cat=a,bot=[compar=?fCmp,wh=?fWH]]
                                                                }
        }
}

class  DetCoanchorCan
import ComplementCoanchorCan[]
declare ?fDef
{<syn>{
        node ?compl(color=white)[bot=[definite=?fDef]]{
             node ?xcoanch(rank=1,name=Determiner)[cat=det,top=[definite=?fDef]]
                                                        }
        }
}
Defines AdjCoanchorCan, ComplementCoanchorCan, DetCoanchorCan, ObjectNCoanchorCan (links are to index).

CanXAnchor

This tree fragment provides the anchor node to families which are not anchored by a verb but by a noun or an adjective. Its canonical position is after the verb. On the basis of its category, the anchor complements are differentiated in the following two terminal classes:

<*>+= [<-D->]
class  CanXAnchor
import CanComplement[]
export ?xanch  ?fWH
declare ?xanch  ?fWH 
{<syn> { 
        node ?compl(color=black)[bot=[wh=?fWH]]{
             node ?xanch(color=red,mark=anchor)[top=[wh=?fWH]]
                                                };   
        ?V >> ?compl 
        }
}

class  CanObjectAnchor
import CanXAnchor[]
       VerbCaseAssigner[]
declare ?N ?fAC ?fP ?fN ?fG ?fWH ?fDef ?fPron ?fCmp
{<syn>{
        node ?compl[cat=np,bot=[case=?fAC,pers=?fP,num=?fN,definite=?fDef,compar=?fCmp,pron=?fPron]]{
             node ?xanch(rank=2)[cat=n,top=[case=?fAC,pers=?fP,num=?fN,definite=?fDef,compar=?fCmp,pron=?fPron]]
                                                                        }
        };?compl = ?NP1 ; ?V = ?verb ; ?VP = ?verbph
}

class  CanAdjAnchor
import CanXAnchor[]
declare ?A ?fCmp 
{<syn>{ 
        node ?compl [cat=ap,bot=[compar=?fCmp]]{
                  node ?xanch(rank=2)[cat=a,top=[compar=?fCmp]]
                                                }
        } 
}
Defines CanAdjAnchor, CanObjectAnchor, CanXAnchor (links are to index).

CanPPIObject-VPE

This tree description defines prepositional phrase complements. The tree fragments contains an additional emtpy V node to allow adjunction between the V and the P node. This adjunction is permitted to the right of the VP as in Bill thinks often of his devorce. This class is inherited in two classes with exhaustive PPs:

<*>+= [<-D->]
class  CanPPIObject-VPE
import CanComplement[]
export ?VE ?prepph ?xprep
declare ?VE ?prepph ?xprep
{<syn>{ 
         node ?compl(color=red,rank=4)[cat=vp,bot = [mainv = -, compar = -, assign-comp = none]]{
                    node ?VE(color=red,mark=nadj)[cat=v,phon=e]
                    node ?prepph(color=red)[cat=pp]{
                        node ?xprep(color=red)[cat=prep]             
                                                }
                                               }
        }
}

class  CanPPCoanchorExhaustive  
import CanPPIObject-VPE[]
{<syn>{ 
        node ?xprep(mark=coanchor,name=Prep)
        }
} 

class  CanPPSubstExhaustive
import CanPPIObject-VPE[]
{ <syn>{ 
         node ?xprep(mark=subst)
        }
}

class  CanPPCoanchor
import CanPPCoanchorExhaustive[]
       PrepCaseAssigner[]
{ <syn> { 
        node ?NP(color=red,mark=subst) [cat=np]
        }; ?prepph = ?PP ; ?xprep  = ?P
}

class  CanPPSubst
import CanPPSubstExhaustive[]
       PrepCaseAssigner[]
{<syn> { 
        node ?NP(color=red,mark=subst) [cat=np]
        } ; ?prepph = ?PP ; ?xprep  = ?P
}
Defines CanPPCoanchor, CanPPCoanchorExhaustive, CanPPIObject-VPE, CanPPSubst, CanPPSubstExhaustive (links are to index).

CanPPTop

The tree description of a canonical prepositional phrase complement does not contain an additional VP node and hence, the right adjunction in VP is not permissible. The tree fragment is inherited in the classes as follows:

<*>+= [<-D->]
class  CanPPTop
import CanComplement[]
       PrepCaseAssigner[]
{<syn>{
        node ?compl(color=red)[cat=pp]{    
                node ?P(color=red)
                node ?NP(color=red,mark=subst)[cat=np]          
                                        }
        }; ?compl = ?PP
}

class  CanByAgent
import CanPPTop[]
{<syn>{
        node ?compl (rank=7);
              node ?P (mark=flex)[cat=by]
        }
}

class  CanToObject
import CanPPTop[]
{<syn>{
        node ?compl(rank=4);
              node ?P(mark=flex)[cat=to]
        }
}

class  CanPPIObject
import CanPPTop[]
{<syn>{
        node ?compl(rank=5);
             node ?P(mark=coanchor,name=Prep)[cat=prep]
        }
}
Defines CanByAgent, CanPPIObject, CanPPTop, CanToObject (links are to index).

CanAdjComplement

The canonical position of the adjective complement is after the verb. It is of AP category and is marked for substitution.

<*>+= [<-D->]
class  CanAdjComplement
import 
       CanComplement[]
{ <syn>{
        node ?compl(color=red,rank=3,mark=subst)[cat=ap]
        }
}
Defines CanAdjComplement (links are to index).

AdjCoanchorCanR

This tree fragment is defined to saturate a resultative family with adjective coanchor. The complement is of A category and is marked as a coanchor node.

<*>+= [<-D->]
class  AdjCoanchorCanR
import CanComplement[]
declare ?A ?fCmp ?fWH
{<syn> {
         node ?compl (color=red,rank=3)[cat=ap,bot=[compar=?fCmp,wh=?fWH]]{
             node ?A(color=red,mark=coanchor,name=Adjective)[cat=a,bot=[compar=?fCmp,wh=?fWH]]}
        }
}
Defines AdjCoanchorCanR (links are to index).

CanSentComplement

The canonical position of the sentential complement is after the verb and the object complement. The S licenses indicative and infinitive mode with the constraint that the indicative clause must cooccur with a complementiser. Verbs selecting a sentential complement impose constraints on their <mode > and <comp > values and these are declared in the lexical entry of the verb. On the basis of the S mark, the CanSentComplement class is inherited in the two classes as follows:

<*>+= [<-D->]
class  CanSentComplement
import CanComplement[]
{ <syn>{ 
         node ?compl (color=red,rank=6)[cat=s,top=[assign-comp=@{inf_nil,ind_nil},inv= - ]]
        }
}

class  CanSentComplementFoot
import CanSentComplement[]
{ <syn>{ 
         node ?compl (mark=foot)
        }
}

class  CanSentComplementFootECM
import CanSentComplementFoot[]
{<syn> { 
         node ?compl [top=[inv = -, extracted = -,comp=nil,
                      assing-comp=@{ecm,for},assing-case=acc]]
       }        
}

class  CanSentComplementSubst
import CanSentComplement[]
{ <syn>{ 
         node ?compl (mark=subst) 
                  
        }
}

class  CanSentComplementSubstECM
import CanSentComplementSubst[]
{<syn> { 
         node ?compl [top=[inv = -, extracted = -,comp=nil],
                      bot=[assing-comp=@{inf_nil,ind_nil,ecm},assign-case=acc]]
       }        
}
Defines CanSentComplement, CanSentComplementFoot, CanSentComplementFootECM, CanSentComplementSubst, CanSentComplementSubstECM (links are to index).

CanSentComplement2

This tree fragment is used by verbs selecting an adjective complement and a sentential complement. The complement node is painted in white so that the node can merge with the complement node of the adjective. The S complement node is marked for substitution.

<*>+= [<-D->]
class  CanSentComplement2
import CanComplement[]
declare ?xS ?fCtrl
{ <syn>{ 
         node ?XP [bot=[control=?fCtrl]];
         node ?compl (color=white)[cat=@{ap,np}] {
              node ?xS (color=red,rank=6,mark=subst)[cat=s,top=[assign-comp=@{inf_nil,ind_nil},control=?fCtrl,inv= -]]
                                        }
        }
}
Defines CanSentComplement2 (links are to index).

PPAnchorTop

This class is the mother class of small clauses which select a prepositional phrase. The complement node is a PP dominating a Prep node. This mother class is further inherited in two main classes:
<*>+= [<-D->]
class  PPAnchorTop
import CanComplement[]
export ?xprep
declare ?xprep
{<syn> {
        node ?compl(color=red) [cat=pp]{
             node ?xprep(color=red)[cat=prep]
                                        }
        }
} 

class  PPAnchorExhaustiveCan
import PPAnchorTop[]
{<syn> {
        node ?xprep (mark=anchor)
       }
}

class  PPAnchorArgument
import PPAnchorTop[]
       PrepCaseAssigner[]
export ?xNP
declare ?xNP
{<syn> {
        node ?xNP (mark=subst,color=red)[cat=np];
        ?xprep >> ?xNP ; 
        ?compl = ?PP ; ?xprep = ?P ; ?xNP = ?NP
        }
}

class  PPAnchorArgumentNPCan
import PPAnchorArgument[]
{<syn> {
        node ?xprep (mark=anchor)
       }
}

class  PPAnchorArgumentXP
import PPAnchorArgument[]
export  ?xprep2 ?xArg
declare ?xprep2 ?xArg
{<syn> {
        node ?xprep {
             node ?xArg (color=red,mark=coanchor,name=Anchor)
             node ?xprep2 (color=red,mark=anchor)[cat=prep]
                      }
        }
}

class  PPAnchorArgumentAdvCan 
import PPAnchorArgumentXP[]
{<syn> { 
         node ?xArg [cat=adv]
       } 
}

class  PPAnchorArgumentAdjCan 
import PPAnchorArgumentXP[]
{<syn> { 
         node ?xArg [cat=a]
       } 
}

class  PPAnchorArgumentNCan 
import PPAnchorArgumentXP[]
{<syn> { 
         node ?xArg [cat=n]
       } 
} 

class  PPAnchorArgumentPCan 
import PPAnchorArgumentXP[]
{<syn> { 
         node ?xArg [cat=prep]
       } 
}

class  PPAnchorArgumentPNPCan
import PPAnchorArgumentNCan[]
declare ?xprep1
{<syn> {
        node ?xprep {
            node ?xprep1 (color=red,mark=coanchor,name=Anchor2)[cat=prep]
            node ?xArg
            node ?xprep2
                 }
        }
}
Defines PPAnchorArgument, PPAnchorArgumentAdjCan, PPAnchorArgumentAdvCan, PPAnchorArgumentNCan, PPAnchorArgumentNPCan, PPAnchorArgumentPCan, PPAnchorArgumentPNPCan, PPAnchorArgumentXP, PPAnchorExhaustiveCan, PPAnchorTop (links are to index).

ExtractedArgument

The extraction phenomenon affects nominal and sentential complements and is characterised by the complements being "moved" at an unbounded distance to the left-hand side of the verb. The moved element can be surface-realised as a wh-word, topicalised-NP or a relative clause. The current grammar covers <wh=+ > extraction and relative clauses, leaving aside topicalisation cases.

The extraction of an argument to the left-hand side of the verb is represented by adding to the non-extracted XP node two additional nodes: an S0 node which is a mother of the XP node and a WH node which is a sister of the XP node. The canonical argument position is an empty position filled with an epsilon. The empty position and the extracted element are coindexed by the <trace> feature (hence the empty argument is referred to as a trace) and therefore the WH node can be substituted by the same phrase as the extracted one, including wh-NP (who, what), wh-phrase headed by a preposition (by whom), adjectival question (how) and a determiner phrase (which island). The ExtractedArgument class inherits the feature information of movement agreement between the extacted element and its trace. This is defined by equation between variables.

<*>+= [<-D->]
class  ExtractedArgument
import VerbalArgument[]
       MovementAgreement[]
export ?S0 ?WH  ?Trace ?fT ?fWH ?X ?fPass ?fM ?fI ?fTense ?fN
declare ?S0 ?WH  ?Trace ?fT ?fWH ?X ?fPass ?fM ?fI ?fTense ?fN
{<syn> {
        node ?S0(color=red)[cat=s,bot = [wh=?fWH,mode=?fM,tense=?fTense,pass=?fPass,num=?fN]]{
            node ?WH(color=red)[top = [trace = ?fT, wh = ?fWH,num=?fN]]
            node ?XP [cat=s,top=[mode=?fM,tense=?fTense,pass=?fPass,inv = ?fI]]
                                                                          };
                node ?Trace [top=[trace= ?fT, wh = ?fWH],bot=[phon=e]];
                node ?VP    [cat=vp]
        } ; ?WH = ?WH1 ; ?Trace = ?WhArg
}
Defines ExtractedArgument (links are to index).

WhExtraction

The top S0 node of trees with wh-extraction are marked with <extracted = +>. There is no inversion in the bottom XP node. Depending on whether the extracted element is a subject or a verb complement, we WhExtraction class is subdivided in two main classes: WhSubjectArgument and WhComplementTop.

<*>+= [<-D->]
class  WhExtraction
import ExtractedArgument[]
{<syn>{
        node ?S0[bot = [inv = ?fI,extracted = +, comp=nil]];
             node ?XP[top=[conj = nil,comp=nil, inv = ?fI],bot=[inv= -,comp=nil]]
        }
}
Defines WhExtraction (links are to index).

WhSubjectArgument

The class of the extacted subject argument specifies that the position of the moved argument is before the VP node. The wh-moved element is of NP category, it is <wh=+>. The agreement between the subject and the main verb is preserved (hence the feature class of SubjectAgrement has been imported and the agreement is solved by equating the node variables of the current class with the ones of the imported class). Depending on whether the extracted element is an NP or a sentence, this class has been further inherited in two terminal classes as follows:

Structurally, both classes are identical.

<*>+= [<-D->]
class  WhSubjectArgument
import WhExtraction[]
       SubjectAgreement[]
{<syn> { 
         node ?S0 {
              node ?WH (mark=subst)[cat=np,top = [wh = +]]
              node ?XP [bot=[assign-comp=@{inf_nil,ind_nil,ecm}]] {
                       node ?Trace (color=red,mark=nadj)
                       node ?VP    
                                                } 
                   }
        } ; ?fI = - ; ?fAC = nom ;
            ?XP = ?S; ?Trace = ?Subj ; ?VP = ?xagr 
}

class  WhSubject
import WhSubjectArgument[]
{<syn>{
        node ?Trace [cat=np]
        }
}

class  WhSententialSubject
import WhSubjectArgument[]
{<syn>{
        node ?Trace [cat=s]
        } 
}
Defines WhSententialSubject, WhSubject, WhSubjectArgument (links are to index).

WhComplementTop

This class defines wh-moved complements. The trace is positioned after the verbal element and therefore, the we declare a V node dominated by the VP. As in the CanComplement class, the node is painted in white so that it can be merged with the verb form. The MovementAgreement feature description has been imported to ensure agreement between the extracted element and its trace. The Inversion feature has been imported too to ensure inversion between the verb and the extracted element. Depending what type the complement is (e.g., a direct object, an indirect object, a PP complement with VP, PP complement without VP, extracted object out of PP or a locative) the WhComplementTop class breaks down in the classes as follows: WhComplement, WhPPIObjectVPE, WhPPIObject, WhPObjectVPE, WhPObject and WhLocative2

RelativeClause

Relative clauses involve the extraction of an argument or an adjunct forming thus a complex nominal phrase which appears as an auxiliary tree within each tree family. Relative clauses were implemented by adding two nodes to the tree description of wh-extracted argument with an NP root node. Relative clauses fall in two major classes: RelativeOvertExtractedWH (i.e. clauses with an overt wh-NP and without a complementiser, as in the girl which Nately had fallen so deeply in love with ) and RelativeCovertExtractedWH (i.e., clauses with a covert complementiser and without a surface realised wh-NP, as in the girl that Nately had fallen so deeply in love with ).

<*>+= [<-D->]
class  RelativeClause
import ExtractedArgument[]
export ?RelClause ?Foot?fP ?fN ?fG ?fC ?fPron ?fCmp
declare ?RelClause ?Foot ?fP ?fN ?fG ?fC ?fPron ?fCmp
{<syn> {
        node ?RelClause (color=red)[cat=np,bot = [rel-clause = +,num=?fN,pers=?fP,case=?fC,pron=?fPron,compar=?fCmp]]{
             node ?Foot(color=red,mark=foot)[cat=np,top=[num=?fN,pers=?fP,case=?fC,pron=?fPron,compar=?fCmp],
                        bot=[refl = -, rel-clause= -,case=@{nom,acc}]]
             node ?S0(mark=nadj){
                  node ?WH 
                  node ?XP [top = [inv = -,conj = nil]] }
                }       
         }
}

RelativeOvertExtractedWH

Relative clauses with an overt extracted wh-argument involve substitution of wh-NP by a lexical item with a positively marked wh-feature <wh =+ > on the WH node. The adjunction of a complementiser is blocked by the <comp=nil > value on the XP node. The <XP.top mode = ind> (unlike XTAG, where <mode=ind,inf >) to prevent parsing of *the man who to sleep. On the basis of the category of the wh-element and the trace, this class is inherited in seven distinct classes as follows RelativeOvertSubject, RelativeOvertComplement, RelativePied-Piping, RelativeAdjunctPied-Piping, RelativeOvertPPObject-VPE, RelativeOvertPPTop and RelativeOvertPPAnchorArgumentNP:

RelativeCovertExtractedWH

The WH node in covert extracted relative clauses is filled with an empty category which prevents from substituting the wh-NP node. The insertion of an auxiliary tree anchored by that-COMP is permitted by the unification of <assign-comp=that > on the foot node of the auxiliary tree and the <assign-comp= that/ind_nil/inf_nil,for,ecm > on the XP node of the relative tree. The XP top.mode is assigned a value <ind,ind> to parse clauses as the man that bakes a cake and the man to bake a cake.

The inheritance of this class is implemented in parallel to the subhierarchy with mother class RelativeOvertExtractedWH, namely: the class has been inherited by six major classes depending on the category of the wh-element and the position of the trace: RelativeCovertSubject, RelativeCovertComplementTop, RelativeCovertPPObject-VPE, RelativeCovertPPTop, RelativeCovertPPAnchorArgumentNP and RelativeAdjunctCovert. It should be noted, however, that the relativised pied-piping PPs appear only with overt extracted wh-NP. Thus, the hierarchical organisation is as follows:

GerundArgument

The implementation of subject and object arguments coocurring with a gerund verb marks the different behaviour of gerund clauses: on one hand, the so called 'determiner gerunds' might appear with determiners, they can be modified by adjectives and the object of the gerund verb can be instantianted as an object of a PP (e.g., the baking for Lisa of a blueberry pie). These features make them behave as basic nominals. On the other hand, there exist 'NP gerunds' which have an internal sentential structure, i.e., an NP gerund tree has the same active/passive alternations and functional distributions as the declarative case in the corresponding family (differing only in the root NP).

The hierarchical organisation of gerund argument follows the double behaviour of gerund in the following manner: there is one mother class called GerundArgument with an NP root node. This noun is always in 3rd person and it can appear either in nominative or in accusative case. The root NP dominates a VP node which either of an N category (for DeterminerGerund or a VP (for NPGerund).

<*>+= [<-D->]
class  GerundArgument
import VerbalArgument[]
{<syn>{ 
        node ?XP[cat=np,bot=[pers = 3,case=@{nom,acc}]]{
                node ?VP[cat=@{vp,n}]
                                }
        }
}
Defines GerundArgument (links are to index).

DeterminerGerund

The determiner gerund is anchored by a verb in gerund mode projecting a noun. The further division into classes has been drawn upon the position of the gerund argument: before or after the verb item. This differentiates the two main classes as follows:

<*>+= [<-D->]
class  DeterminerGerund
import GerundArgument[]
export ?V
declare ?V 
{<syn>{ 
        node ?VP[cat=n]{
             node ?V(color=white)[cat=v,bot=[mode=ger]]
                        }
        }
}

class  DeterminerGerundSubject
import DeterminerGerund[]
declare ?Det ?fConst ?fDef ?fQu ?fCard ?fDecr ?fWH ?fCmp
{<syn>{
        node ?XP[bot =[const=?fConst,definite=?fDef,quan=?fQu,card=?fCard,decrease=?fDecr,wh=?fWH,compar=?fCmp]]{
             node ?Det(color=red,mark=subst)[cat=det,
                bot = [const=?fConst,definite=?fDef,quan=?fQu,card=?fCard,decrease=?fDecr,wh=?fWH]]
             node ?VP [cat=n,top=[compar=?fCmp]]
                  }; ?fDef = + ; ?fCmp = -
        }
}

class  DeterminerGerundComplement
import DeterminerGerund[]
export ?gerundcompl 
declare ?gerundcompl 
{<syn>{
        node ?VP{
             node ?V
             ,,,node ?gerundcompl(color=red)
                }
        }
}

class  DeterminerGerundObject
import DeterminerGerundComplement[]
       PrepCaseAssigner[]
{<syn>{
        node ?gerundcompl(rank=2)[cat=pp]{
             node ?P(color=red,mark=flex)[cat=of]
             node ?NP(color=red,mark=subst)[cat=np]
                                } ; 
        ?gerundcompl=?PP
        }
}

class  DeterminerGerundObjectNCoanchor 
import DeterminerGerundComplement[]
       PrepCaseAssigner[]
declare ?X ?N ?fAC ?fP ?fN ?fG ?fWH ?fConst ?fDef ?fQu ?fCard ?fDecr
{<syn>{ 
        node ?gerundcompl(rank=2)[cat=pp]{
             node ?P(color=red,mark=flex)[cat=of]
             node ?NP(color=red)[cat=np,bot=[case=?fAC,num=?fN,wh=?fWH,definite=?fDef]]{
                  node ?N(color=red,name=Noun,mark=coanchor)[cat=n,top=[case=?fAC,num=?fN,wh=?fWH,definite=?fDef]]
                                                                        }
                                        }
        }; ?gerundcompl = ?PP
}

class  DeterminerGerundToObject
import DeterminerGerundComplement[]
       PrepCaseAssigner[]
{<syn>{ 
        node ?gerundcompl(rank=3)[cat=pp]{
             node ?P(color=red,mark=flex)[cat=to]
             node ?NP(color=red)[cat=np,mark=subst]
                                        }
        }; ?gerundcompl = ?PP
}

class  DeterminerSentComplement
import DeterminerGerundComplement[]
{<syn> {
        node ?gerundcompl(color=red,mark=subst,rank=6)[cat=s]
        }
}

class  DeterminerIObject
import DeterminerGerundComplement[]
       PrepCaseAssigner[]
{<syn>{
        node ?gerundcompl(rank=1)[cat=pp]{
             node ?P(color=red,mark=flex)[cat=for]
             node ?NP(color=red,mark=subst)[cat=np]
                                        }
        }; ?gerundcompl = ?PP
}

class  DeterminerGerundPPIObject
import DeterminerGerundComplement[]
       PrepCaseAssigner[]
export ?Ve 
declare ?Ve
{ <syn>{
        node ?gerundcompl(rank=4)[cat=vp]{
             node ?Ve(color=red)[cat=v,phone=e]
             node ?PP(color=red)[cat=vp]{
                  node ?P(color=red)[cat=prep]
                  node ?NP(color=red,mark=subst) [cat=np]          
                                         }
                                       }
        }
}

class  DeterminerGerundPPSubst
import DeterminerGerundPPIObject[]
{<syn>{
        node ?P(mark=subst)
        }
}

class  DeterminerGerundPPAnchor
import DeterminerGerundPPIObject[]
{<syn>{
        node ?P(mark=coanchor,name=Prep)
        }
}
Defines DeterminerGerund, DeterminerGerundComplement, DeterminerGerundObject, DeterminerGerundObjectNCoanchor, DeterminerGerundPPAnchor, DeterminerGerundPPIObject, DeterminerGerundPPSubst, DeterminerGerundSubject, DeterminerGerundToObject, DeterminerIObject, DeterminerSentComplement (links are to index).

NPGerund

NP gerunds have the internal structure of transitive trees expect from the root node. The hierachical organisation of NP gerund arguments contain only tree descriptions for a subject. The tree description of NP gerund object would be the same as the one of canonical object and thus, there is no need for its specification. We cannot however, use the subject tree description due to the differing root node. The top node in the NP gerund subhierarchy declares a gerund subject positioned before the VP node. This tree description is inherited by the three classes as follows:

<*>+= [<-D->]
class  NPGerund 
import GerundArgument[]
export ?GerundSubj ?fWH ?fCmp
declare ?GerundSubj ?fWH ?fCmp
{<syn>{ 
        node ?XP  [bot = [gerund = +,wh = ?fWH, num=sing, compar=?fCmp]]{
             node ?GerundSubj (color=red)[top = [wh=?fWH,compar=?fCmp]]
             node ?VP [cat=vp,top =[mode=ger]]
                  }
        }
}

class  SubjectNCoanchorNPGerund
import NPGerund[]
declare ?N
{<syn>{
        node ?GerundSubj [cat=np,top=[wh= -]]{
             node ?N(color=red,name=Noun,mark=coanchor)[cat=n]
                                        }
        }
}

class  NPGerundSubjectCan
import NPGerund[]
{<syn>{
        node ?XP [cat=np]{
        node ?GerundSubj(mark=subst)[cat=np,top=[definite= -, wh = -, case=@{acc,gen}]]
                        }
        }
}

class  NPGerundSubjectPro
import NPGerund[]
declare ?X
{<syn> {
        node ?XP [top=[definite= - ]]{
                node ?GerundSubj(mark=nadj)[cat=np,top = [definite= -,case = none,wh= -]]{
                        node ?X(color=red,mark=nadj)[cat=Pro]
                                                        }
        node ?VP
            }
        }
}
Defines NPGerund, NPGerundSubjectCan, NPGerundSubjectPro, SubjectNCoanchorNPGerund (links are to index).

CleftArgument

Cleft arguments are characterised by the following main properties:
  1. a dummy subject and the main verb be; and
  2. a cleft element of an NP, Adv or PP category
  3. an S clause
The tree fragment of the top node in the cleft argument's hierarchy is a anchored by the main verb be and is coanchored by it. The coanchor node is specified in the lexical entry of the verb. The grammar covers the declarative cases and wh-movement without inversion (and with obligatory adjunction of an auxiliary verb). The top class has been inherited by the two major classes: CanonicalCleftArgument and WhCleftArgument

Lexical Classes

The grammar contains the most common non-verbal tree descriptions so that the test suite of sentences can be parsed. They cover nouns, noun modifiers, adjectives, adverbs, prepositions, prepositional phrases, determiners, complementisers and auxiliary verbs.

*