Querying the PTB

The following syntactic shortenings are supported in v0.2.3:

Standard XPath Short Form

self::* =::*

child::* >::*

parent::* <::*

descendant::* >>::*

descendant-or-self::* =>>::*

ancestor-or-self::* <<=::*

following::* ->::*

preceding::* <-::*

following-sibling::* $>::*

preceding-sibling::* <$::*

Here are some simple queries:

Nodes with constituent label NP
```
=>>::NP
```
Nodes with constituent label S, and role TPC
```
=>>::S[contains(@roles,'TPC')]
```
Nodes with label John (terminals) which are followed by nodes with label Mary
```
=>>::John[->::Mary]
```
Nodes with label Mary in the query above
```
=>>::John/->::Mary
```

While there is no command line utility, this is very easy to access using the API. The following code can be used to produce counts of queries:

    public int getCount(String ptbRoot, String xpathExpr) throws Exception{

        //The navigator provides iterators that
        //traverse the tree.
        PTBNavigator nav = new PTBNavigator(null);

        //Compile the XPath expression
        PTBXPath xp = (PTBXPath)(nav.parseXPath(xpathExpr));
        
        int count = 0;

        //For each treebank file
        for(PTBTask task = new PTBTask(ptbRoot);task.hasNext();){

            //Get the abstract root node whose children
            //are the sentences.
            PTBTreeNode root = task.next();
            
            //For each sentence
            for(Enumeration children = root.children(); children.hasMoreElements();){

                //Set a sentence as the root of a tree against
                //which an expression is run
                nav.setRoot((PTBTreeNode)(children.nextElement()));

                //Run the expression
                count += ((List)xp.evaluate(nav.getRoot())).size();
            }
            
        }
        return count;
    }

Relevant Packages: edu.upenn.cis.ptb.xpath and edu.upenn.cis.ptb.util

The following are queries from the Bird et al. paper in our notation. Please refer to the paper for details on the semantics.

Clauses containing the word saw :
```
 >>::S/>>::saw 
```
NPs immediately following a verb:
```
 i-foll(>>::VB,{=::NP}) 
```
Nouns that follow a verb which is a child of a verb phrase:
```
 >>::VP/>::VB/->::NN 
```
Within a verb phrase, find nouns that follow a verb which is a child of a verb phrase:
```
 subtree(>>::VP,{>::VB/->::NN}) 
```
NPs which are the rightmost child of a VP:
```
 subtree(>>::VP,{>::NP[r-edge()]}) 
```
NPs which are the rightmost descendants of a VP:
```
 subtree(>>::VP,{>>::NP[r-edge()]}) 
```

VPs comprising of a verb (on the left edge), an NP (immediately following the verb) and a PP (immediately following the NP and on the right edge):

 
>>::VP[
       subtree(.,
               {i-foll(=>>::VB[l-edge()],
                       {i-foll(=::NP,
                               {=::PP[r-edge()]})
                       })
               })
      ]

"subtree" and "i-foll" are implemented as functions which take two arguments. Their signatures are as follows:

node-set subtree(node-set, string)

node-set i-foll(node-set, string)

The second argument is a string which should be a valid xpath expression, and it is applied to each node in the node-set supplied in the first argument. Since we need the ability to embed these functions, curly braces are used instead of quotes in the expressions above.

Standard XPath	Short Form
`self::*`	`=::*`
`child::*`	`>::*`
`parent::*`	`<::*`
`descendant::*`	`>>::*`
`descendant-or-self::*`	`=>>::*`
`ancestor-or-self::*`	`<<=::*`
`following::*`	`->::*`
`preceding::*`	`<-::*`
`following-sibling::*`	`$>::*`
`preceding-sibling::*`	`<$::*`