To start using PML-TQ from the tree editor TrEd, press Shift+F3 or select Macros → TredMacro → New Tree Query from the main menu in TrEd.

Choose Treebank (server); if doing this for the first time, you will be asked to fill the connection form: as url, fill the search engine URL including port number (e.g. http://mysearchserver.org:8082 where mysearchserver.org is the host name or IP address of your PML-TQ search service and 8082 is the port the search service is listening on); fill username and password with your credentials for the search service (which you can receive from the administrator of the PML-TQ search service). When done, confirm with OK. TrEd will attempt to contact the search service you have specified and will ask it for a list of treebanks avaiable. Subsequently, you will be asked to select treebanks for which you want to configure a connection.

Once your connections are configured, a dialog window with a list of available connections will be offered. To select a connection, simply choose it from the list and press Select. You may also use the buttons Add Service to add/remove connections to other treebanks provided by the server of the selected connection, New URL to create a connection to a new server, Info to display information about the selected connection (such as name and description of the treebank), Edit to modify the connection data (url, username, and password), and Remove to remove the selected connection from the list.

A window with an empty query tree is displayed by TrEd:

You can also use the toolkit without TrEd from a web browser (although you will not be able to build the query graphically nor see the graphical representation of your query). To start, just open the search engine URL and log in using any web browser capable of combining JavaScript, CSS, and SVG (Scalable Vector Graphics). At the time of writing this tutorial, the best choice is the Opera browser, followed by Google Chrome, Firefox, and Safari (please avoid Microsoft Internet Explorer because it lacks native SVG support).

Now we may create our first simple query. We shall search for all nodes of the type t-node (tectogrammatical nodes in PDT 2.0) that whose attribute functor equals to DPHR. In TrEd, the query can be created in several ways:

The result in TrEd will look like this:

To start the search now, press Space or or . After a while, a window will pop up indicating whether some results have been found, and pressing Display will show the first result in a new view:

To see the full sentence in the text field above the trees , click on the result view on the right. Next result can be displayed by pressing the key n or .

Press p or to go back to the previous match and press to return the current match to view.

Note that the result view contains not only the matching tree but the complete document, so it is possible to see the tree preceding or following the currently matching tree by pressing Page Up/ or Page Down/ , respectively.

We shall now make the query more complex by adding another node to it. We shall ask for a t-node with functor "DPHR" that has a child (since DPHR t-nodes are often leaves, it may be interesting to see what children we get).

To add a new child, select the only node in our query tree and press Insert or on the toolbar. Now a pop-up window shows asking for a type of relation the new node to the existing node. The default value is child. Since this is what we want, click OK. TrEd automatically assumes the new query node to be a selector for nodes of the type t-node, since, according to the PML schema of the tectogrammatical layer, a t-node can only have a t-node for its child; otherwise it would offer a list of nodes types to choose from.

In text form, the query can be equivalently expressed as

t-node [ functor='DPHR', t-node [ ] ]

or

t-node [ functor='DPHR', child t-node [ ] ]

These forms use nesting of node selectors, the first form makes use of the fact that the default relation of a nested selector to the selector in which it is nested is child.

The query can also be expressed without nesting, using names, either as

t-node $a := [ functor='DPHR', child $b ];
t-node $b := [ ];

or

t-node $a := [ functor='DPHR' ];
t-node $b := [ parent $a ];

naming the two nodes $a and $b and either indicating that $a has a child $b or that $b has a parent $a.

We now extend our query expression to cover also t-nodes with functor CPHR. This can be done in three different ways:

Using a disjunction:

t-node [ functor='DPHR' or functor='CPHR', t-node [ ] ]

Apart from editing the query, this can be created using the GUI e.g. in the following steps:

Using a regular expression:

t-node [ functor ~ '[CD]PHR', t-node [ ] ]

Symbol ~ (tilde) denotes a binary relation between two values that is true if and only if the value on the left interpreted as string matches the value on the right interpreted as regular expression. The regular expression [CD]PHR is matched by any string containing either CPHR or DPHR as a substring. If, for example, XDPHR were a possible functor value, we would have to be more precise and rewrite the expression as

t-node [ functor ~ "^[CD]PHR$", t-node [ ] ]

Since ^ and $ meta-characters are only matched by the start and end of a string, the value of functor now must be exactly CPHR or DPHR.

Creating a regular expression test graphically in TrEd is similar to creating an equality test: either press ~ key or the toolbar button. Do not forget to enclose the regular expression (field labeled b in the dialog) into apostrophes or quotes since in the PML-TQ syntax it is just a literal string.

Using a set enumeration:

t-node [ functor in { "CPHR", "DPHR" }, t-node [ ] ]

The relation in asserts that the value computed from the expression on the left equals to a value of some of the expressions listed in the set enumeration on the right.

The query text editor provides a button in { ... } that, for attributes with a fixed set of possible values, allows the enumeration to be created by selecting the desired values from a list.

The member selector is useful for querying some types of complex-valued node attributes, e.g. lists of complex structures. Such attributes do not occur in PDT 2.0, but do occur for example in CoNLL-2009 Shared Task data when converted to PML.

Each node in CoNLL-2009 ST data can be annotated as an argument of some other node, called predicate. The argument node carries an attribute apreds which is a list of all predicates it belongs to. The list consists of structures with two members: a PML reference to the predicate node (apreds/target.rf) and an argument label apreds/label. The set of argument labels differs from language to language; for Czech data, the labels correspond to tectogrammatical functors and the predicates to effective parents.

So, each structure in the list represents one labeled semantic relation. To be able to combine constraints on the target node (predicate) with the label of the relation that points to it, we must use a feature of PML-TQ called member selectors.

The following example finds a PAT argument and its corresponding predicate:

node $arg := [
  member apreds [
    label = 'PAT',
    target.rf node $pred := [ ]
  ]
]

The intermediate member selector matches one element of the apreds list at a time and tests its label. If the label matches, the nested node selector for the target.rf PML-reference relation takes action.

More details and further examples are given in the section called “Member selectors”.

Sometimes it is useful to test existence, non-existence or number of occurrences of a node related to our query. For example, to find all predicates without a subject in PDT 2.0, we could use the following query

a-node [ afun='Pred', 0x echild a-node [ afun='Sb' ] ]

The query finds an a-node with afun='Pred' that has no effective children with afun='Sb'. This is expressed using a selector preceded by a restriction on number of occurrences (0x - zero times), which is called a subquery.

To create a subquery graphically in TrEd, simply create the selector echild a-node [ afun='Sb' ] as usual and then, with the corresponding query subtree selected, press x or .

Of course, we could constrain the number of occurrences to a non-zero value, too. For example, to find all predicates that govern one subject or one object, but not both, we could use the following query:

a-node [ afun='Pred', 1x echild a-node [ afun in {'Sb','Obj'} ] ]

The nodes matched by subqueries are not part of the result match (in our example, the match would consist of the predicate nodes only, the subjects or objects would not be included).

The number of occurrences of a subquery can be constrained not only to a single number (0 in our example) but to any finite union of bounded or partially unbounded intervals of positive integers; e.g. 0|2..4|6+x restricts the number of occurrences to zero, two to four, or six or more, eliminating one and five. While the plus sign stands for or more, the minus sign means or less, as in 4-x (occurring four or less times).

Subqueries are also created using boolean operators, such as negation:

a-node [ afun='Pred', ! echild a-node [ afun='Sb' ] ]

In this example, the selector ! echild a-node [ afun='Sb' ] is automatically turned into a (still negated) subquery with one and more occurrences; the query becomes:

a-node [ afun='Pred', ! 1+x echild a-node [ afun='Sb' ] ]

To create this query graphically, create the selector echild a-node [ afun='Sb' ] as usual, then select the query node corresponding to a-node [ afun='Pred' ], create a negation node (press ! or ) and drag the query subtree corresponding to the subject onto the negation node.

A common use of subqueries is also constraining nodes on a descending path from one node to another. Let us for example formulate a query searching for a descending chain of tectogrammatical nodes with the functor RSTR (restrictive or descriptive abdominal modification). We want the chain to satisfy the following conditions:

The corresponding query looks like this:

t-node $N:= [
  # condition 1.
  gram/sempos ~ "^n",
  functor != "RSTR",

  # conditions 2. and 3.
  descendant{3,} t-node $R := [
    functor = "RSTR",
    # condition 4.
    0x  t-node [ functor = "RSTR" ]
  ],

  # condition 5.
  0x descendant t-node [
    !functor = "RSTR",
    descendant $R
  ],
];

Note how the condition 5. is expressed: we say that there is no descendant of $N dominating $R whose functor would not equal RSTR. Thus, we have rewritten the original condition of the form as .

Sometimes you want to find a good small example tree demonstrating some linguistic phenomenon. You want it to fit to a presentation slide or an article page. You can do so by putting a limit on the tree size.

Using a subquery this can be done as follows:

t-node [
  10-x same-tree-as t-node [],
  functor='DPHR', # the rest of your query
]

This selects t-nodes with functor='DPHR' in trees with at most 10 other t-nodes. Using functions, this can be written as

t-root [
  descendants() <= 10,
  descendant t-node [ functor='DPHR' ]
]

but note that in this case the t-root appears as a node in the result set. To avoid it, we can write

t-node [
  functor='DPHR',
  1x ancestor t-root [ descendants() <= 10 ]
]

For treebanks that do not have a special node type for the root node, we can write e.g.:

node [
  functor='DPHR',
  1x ancestor node [
    depth() = 0, # the root
    descendants() <= 10
  ]
]

PML-TQ provides a set of built-in functions that can be used in expressions constraining nodes and also in output filters. The functions can be split into the following categories:

For description of all individual functions, refer to the section called “Functions”. Here, we only give a few examples demonstrating the use of some of the functions from the first category on a few common query constructions, usually also expressible by means of subqueries. Whether it is more efficient to use functions than subqueries may depend on implementation.

# a leaf node (using functions)
t-node [ sons()=0 ]

The above query can be created graphically in TrEd by creating a t-node selector (press Insert or on the toolbar and select a node type (t-node in our example) from the list), then create an equality constraint by pressing = or and fill-in sons() as a and 0 as a.

Alternatively, type the query in the text form editor (opened by pressing e or ). The function names with argument templates can be inserted using the Functions button in the editor.

Other queries involving functions can be created similarly.

# a leaf node (using a subquery)
t-node [ 0x child t-node [ ] ]

# right-most child
t-node [ rbrothers()=0 ]

# left-most child
t-node [ lbrothers()=0 ]

# first leaf node in a subtree of $t (using functions)
t-node $t := [
  descendant t-node [
    sons()=0,
    depth_first_order()-depth()=depth_first_order($t)-depth($t)
  ]
]

# first leaf node in a subtree of $t (using a subquery)
t-node $t := [
  descendant t-node $d := [ sons()=0 ],
  0x descendant [ sons()=0, depth-first-precedes $d ],
]

# last leaf node in a subtree of $t
t-node $t := [
  descendant t-node [
    sons()=0,
    depth_first_order()-depth()=depth_first_order($t)+descendants($t)-1-depth($t)
  ]
]

# last leaf node in a subtree of $t (using a subquery)
t-node $t := [
  descendant t-node $d := [ sons()=0 ],
  0x descendant [ depth-first-follows $d ],
]

Output filters are used for extracting data from the nodes matched by the query and generating tabular output. Filters must follow the selective part of the query and start with >>. Filters can be chained: the first filter extracts data from the matching nodes and all subsequent filters operate on the output from the immediately preceding filter. Details can be found in the PML-TQ Syntax Reference and the section called “Group Functions”.

The TrEd GUI does not provide any graphical builder for output-filter nor does it represent the filters graphically. To enter a filter, open the entire query in the query editor (press Ctrl+E or on the toolbar), place the cursor at the end of the query and enter the filter code. Various buttons in the editor can be used to insert special symbols, and templates for functions and common constructions.

One of the simplest filters uses the group function count() to compute the total number of matches of the query in the treebank:

# counting occurrences
t-node [ functor='DPHR' ]
>> count()

The group functions min(), max(), and avg(), can be used to compute maximum, minimum, and average values of data extracted from the matching nodes. For example: to compute a maximum number of child nodes of a t-node with the functor DPHR, we can use the following:

t-node $n := [ functor='DPHR' ]
>> max(sons($n))

The following query computes maximum, minimum and average size of a tectogrammatical tree:

t-root $n := [ ]
>> descendants($n)
>> max(), min(), avg()

The above query uses two filters: the first extracts the number of descendants from each node matched by the selector $n, the second computes maximum, minimum and average value from the values returned by the first filter.

The following query shows a common grouping construction using the 'for' clause. It extracts the attribute functor from the matched nodes and for each distinct value counts the number it occurred:

t-node $n := [ ]
>> for $n.functor
   give $1, count()

Note that $1 in the give clause refers to the first (and only) key used in the for clause, i.e. to $n.functor.

By appending a sort by clause to a filter, we may reorder the rows it produces by some of its columns. In the following query, the output of the filter is sorted using the second output column (the count()) in descendant order as the primary key and the first output column (the $1 in the give clause) in the default (ascending) order:

t-node $n := [ ]
>> for $n.functor
   give $1, count()
   sort by $2 desc, $1

The for clause can be used to create groups not only by attribute values, but also by some of the matching nodes. For example, in order to find out how many grammatical-coreference links can start in one tectogrammatical node, we may use the following query:

t-node $referring := [
  coref_gram.rf t-node $referred := [  ]
];
>>  for $referring give count()
>> max()

The selective part of the query matches every pair of tectogrammatical nodes that are linked by a grammatical-coreference link. The first filter groups the resulting pairs of nodes by the first of the nodes ($referring) and outputs the number of pairs in each group; this is the number of grammatical-coreference links starting in the node $referring. The second filter simply computes the maximum of the values returned by the first filter.

The for clause partitions all input rows into groups before any further processing and the subsequent give clause then produces one output row for each group, letting all group functions, such as count(), min(), max(), etc. operate on the particular group.

PML-TQ further supports a syntax that allows different partitions to be defined for different group function and also let the give clause operate on all input rows. This is done by following the function arguments by an over clause. Here we show an example where we use one of the ranking group functions (row_number()) to select just a few top ranking rows from each group. Please refer to the section called “Group functions explained” for more examples.

In the following query we extract the syntactic label (afun) and the part of speech (the first position of the morphological tag) from every node on the analytical (morphosyntactical) layer of PDT 2.0. Then we apply further filters to output in order to obtain the three most frequent parts of speech for each afun. If several parts of speech occur the same number of times for a given afun, we sample those three that come first alphabetically.

a-node $a:= [ ]
>> $a.afun, substr($a.m/tag,0,1)  # get afun and part of speech (POS)
>> for $1,$2 give $1, $2, count() # count occurrences of POS for each afun
>> $1, $2, row_number(over $1 sort by $3 desc, $2) # get the rank of each POS over the afun
   sort by $1, $3
>> filter $3 <= 3
>> $1, $2, $3

A complete graphical user interface for PML-TQ is available as an extension to the tree editor TrEd and provides the following features:

To use this interface, start by downloading and installing the tree editor TrEd from http://ufal.mff.cuni.cz/~pajas/tred/. The PML-TQ interface is available as an extension called PML Tree Query Interface for TrEd (pmltq) which can be either selected during installation of TrEd (on Windows) or from TrEd as follows:

See the section called “Tutorial” for a quick introduction to the query interface.

The PML-TQ search servers provide a client interface in the form of a web application that can be accessed by any web browser capable of combining JavaScript, CSS, and SVG (Scalable Vector Graphics). At the time of writing this tutorial, the best choice is the Opera browser, followed by Google Chrome, Firefox, and Safari (please avoid Microsoft Internet Explorer because it lacks native SVG support).

Unlike the TrEd interface, this interface does not require any installation, but lacks some features such as graphical query builder and graphical representation of the query (the queries must be entered in the text form), and of course does not support querying local files. The history of past queries is available for queries run on the particular PML-TQ search service.

For a quick introduction to the query language, see the section called “Tutorial” (only the text version of the queries is applicable).

To start using the web interface, simply open the PML-TQ server URL in a web browser, enter your query and press Submit New Query.

Figure 1. The Opera browser displaying a query and a result tree

Results of queries with output filters are displayed as an HTML table, queries without filters are rendered using SVG with the matching nodes highlighted by colours. A simple toolbar is displayed above the tree, with buttons for scaling the SVG image and displaying next, Nth, or previous match. For each matching node a button in a corresponding color is created above the displayed tree; by pressing the button, the tree containing the particular node can be displayed, which is useful for queries whose match can span across several trees or several annotation layers (see Figure 1, “The Opera browser displaying a query and a result tree” Below the toolbar, the file name, tree number, total number of trees in the file and the sentence (or other kind of textual representation) of the tree is displayed. The < and > links preceding the file name can be used to display neighboring trees from the same document.

PML-TQ comes with a command-line client utility called pmltq. The tool can be used to perform queries remotely (by connecting to a remote PML-TQ search engine) or locally (using one of the tools that come with the TrEd toolkit: btred, ntred, and jtred).

Currently this client is able to produces plain-text output only, so it is best used in connection with queries that provide output filters.

TODO: general usage yet to be documented. Run

pmltq --help

to display information about the program command-line options and usage.

Selectors

Node relationships

(Please note that relations order-follows and order-precedes are implemented differently in the local search and in the server-based search. The description below aplies to the local search implementation; for the server-based search, the relations behave the opposite way.)

Logical expressions

Value comparison

Arithmetical and string operators

Subquery and number of occurrences

Functions

Output filters

Nodes in PML are usually attribute-value structures with values that can be of either atomic PML data types (integers, strings, etc.) or complex PML data types (structures, lists, alternatives, sequences, containers). This means that to get to an atomic value stored within a node we sometimes have to travel through several nested complex data structures, starting from the top-level structure which is the node itself. PML-TQ uses attribute paths to describe the route of such a travel.

The syntax of an attribute path is described by the attributePath production of the PML-TQ grammar.

In this section we define how attribute paths are evaluated. (Note: complex queries over nested attribute values can be performed by combining attribute paths with the member selector, see the section called “Member selectors”.)

An attribute path consists of a sequence of steps separated by slashes. This sequence can be optionally preceded by a primitive quantifier the semantics of which is described later in the section called “Primitive quantifiers”. Each step is either a name, the string 'content()', an index, or an element index.

Let P be an attribute path consisting of steps S₁,…,S_m (m>0). The result of evaluation of P on a node N is a set V_N,P of atomic values (integers, floats, or character strings). The evaluation proceeds by evaluating the steps from 1 to m; the evaluation of the step S_n (1≤n≤m) takes as input a set of values V_n and results in a set of values V_n+1. For each n (1≤n≤m+1), all values in V_n are of equal data type (which, if P is a valid attribute path for N, is complex for n≤m and atomic for n=m+1).

The evaluation is initialized with a set V₁={N} whose only element is the node N, which is either a structure or a container. The result of the evaluation if the set V_N,p=V_m+1.

Let V_n be given. We now describe the evaluation based on the syntactic type of the n-th step S_n and the data type of values in V_n. Let t_n denote the type of the values in V_n.

As described above, evaluation of an attribute path on some node may result in a set of values (usually empty or containing one element, but if lists, alternatives or sequences are on the path, the set can be of arbitrary finite cardinality). In this section we define how the truth value of a predicate involving attribute paths is evaluated. We start with the formal definition and then demonstrate it on a few examples.

Definition. Let R be a predicate and let p₁,…,p_n be an enumeration of all occurrences of attribute paths in expressions (terms) contained in R in the order of occurrence and let N₁,…,N_n be the nodes to which the attribute paths relate. Let for i (1≤i≤n), Q_i denote the universal quantifier if p_i starts with a '*' and otherwise. Let V_i denote the set V_Ni,pi of atomic values obtained by evaluating the attribute paths p_i on the node N_i. Then the truth value of the predicate R for this assignment is that of the formula where R' is an atomic formula obtained from R by replacing the attribute paths p₁,…,p_n by variables x₁,…,x_n. (Note that each of the variables has exactly one occurrence in R'.)

Now let us demonstrate the definition on some examples. Let R be the predicate

*a != b/c + *$n.d/e/f

in the query

z-node $n := [ child z-node $m := [ *a != b/c + *$n.d/e/f ] ]

where z-node is some node type, and a b/c, d/e/f are valid attribute paths for nodes of this type. Let N and M be nodes from the searched data assigned to the selectors $n and $m.

Let's assume that the attribute a is a list of numbers and that V_N,a is the set of all values of the attribute a for the node N. Similarly, let V_M,b/c be the set of all values of the attribute path b/c evaluated on the node M and V_N,d/e/f the set of all values of the attribute path d/e/f evaluated on the node N.

The truth value of the predicate R is obtained by evaluating the following formula:

(1)

Thus, the query matches the nodes A, B if and only if B is a child of A and the above formula holds. Note that since the attribute paths *a and *$a.d/e/f start with the character '*' (called a primitive universal quantifier) the corresponding variables x and z in the formula (1) are universally quantified, whereas y, corresponding to b/c is quantified existentially. Note also, that the order of the quantifiers in the formula (1) preserves the order of the occurrence of the corresponding attribute paths in R.

If we had instead written

! *a = b/c + *$n.d/e/f

moving the negation (!) out of the predicate, the resulting formula would be completely different:

(2)

and equivalent to

(3)

Let us give some more practical examples. Assume nodes of the type p-node have an attribute functions that is an unordered list or an alternative of string values. Let us consider the following constraints and the translations to formulae (assuming V_N is the set of values of the functions for a given p-node N):

While primitive quantifiers allow one to quantify over atomic values on a complete attribute path, something it is useful to quantify over elements on some partial attribute paths while specifying conditions on the quantified element. This can be done using the relation member, which allows us to access data structures stored in node's attributes almost as if they were regular nodes.

For example: assume each node contains an annotation of the bridging anaphora. This can be represented by an attribute called bridging that is a list of structures with two members, informal-type (a string value for the type of the anaphora) and target.rf (a PML reference to the anaphora referred node). So, each element of the bridging list represents a labeled link to another node. We might want to ask for nodes with functor="ACT" that are pointed to from the current node by a pointer with a specific informal-type, say "CONTRAST".

The following query will not work

t-node $n := [
  bridging/informal-type = "CONTRAST",
  bridging/target-node.rf t-node [ functor="ACT" ]
]

The problem with this query is that bridging attribute contains a list and constraints on its values are independent. So, $n can still match a node whose bridging attribute is a list consisting of two list members, one that points to an ACTor but whose informal-label is not "CONTRAST", and one with informal-label="CONTRAST" but pointing somewhere else.

In order to be able to say that these list members are the same, we have to use the member selector:

t-node $n:= [
  member bridging [
    informal-type = "CONTRAST",
    target-node.rf t-node [ functor="ACT" ]
  ]
]

This query says that one of the values matched by the attribute path bridging (i.e. one of the members of the list contained in the attribute bridging of the node matched by $a) has informal-type="CONTRAST" and points to a t-node with functor="ACT". Thus, member selector works as an existential quantification over values of a list or alt attribute. We can also use member selector for sequence attributes, but the attribute path that follows the member keyword must specify a particular element name in the last step. For example, if bridging was not a list but a sequence of elements named e.g. terminal, non-terminal, we must use either

member bridging/terminal [...] 

to quantify over all terminals in the bridging sequence or

member bridging/non-terminal [...] 

to quantify over all non-terminals in the bridging sequence.

Of course, we can use member selectors within member selectors and (as we have seen), we can use PML-reference relations within member selectors. But since the objects represented by the member selector are not a regular nodes one cannot use the tree-structure selectors such as child or parent within member selectors.

A member selector can be used for a subquery, i.e. prefixed by an occurrence clause or used in boolean expressions. In particular, negated or zero-times occurring member selector with negated constraints can be used to formulate universal quantification over values of a list, alt, or sequence.

PML-TQ supports group functions in the output filters. These functions compute its value based on a group of input rows, not just the current row. For example, one can use them to compute a sum or maximum over a group of input rows, or a rank of the current input row in some particular ordering of the group of input rows it belongs to.

A filter can specify grouping of input rows in the following ways:

Let us consider an example that combines grouping based on 'for' and 'over'.

Let's say that for each functor A we want to know the probability that a child of a node with functor=A has functor A, B, C, D, etc. In other words, we want to compute the joint distribution of functor labels over nodes connected by an edge. This is done by the following query:

t-node $p := [  t-node $c := [  ] ];
>>  for $p.functor,$c.functor
    give $1,$2,count() div sum(count() over $1)
    sort by $1,$3 desc,$2
>> $1,$2,percnt($3,2) & '%'

The selective part select a pair of t-nodes ($p,$c) where $p governs $c.

We first group together pairs with the same pair of functors using for $p.functor,$c.functor. This partitions original input rows into groups g1,...,gn, each determined by the unique value of the grouping key ($p.functor,$c.functor). For each group we give to the next filter this pair of functors and the probability of the second functor on the first one. The filter thus produces one output row for each group. Let us see how the output row is produced for a group gi whose key is for example ('PRED','ACT').

The first two columns are just taken from the key vector, using $1,$2 and producing 'PRED','ACT'. The probability that 'ACT' is governed by 'PRED' is computed using the following expression:

count() div sum(count() over $1)

The filter then orders the results primarily by the functor of the parent node, secondarily by the probability in decreasing order, and tertiary by the functor of the child. The second filter merely applies the expression percnt($3,2) & '%' to the 3rd column, dividing it by 100, rounding the result to two decimal points and appends a percent sign.

The output looks like this (without the ellipses):

ACMP    RSTR    54.37%
ACMP    PAT     10.77%
ACMP    ACT     10.34%
ACMP    APP     4.99%
...
ACT     RSTR    49.56%
ACT     PAT     9.75%
ACT     APP     8.68%
...
ADDR    RSTR    64.67%
ADDR    APP     14.74%
ADDR    PAT     4.24%
ADDR    ID      3.17%
...
ADVS    PRED    48.5%
ADVS    ACT     13.18%
ADVS    CM      9.09%
...

The query just explained can also be rewritten as follows:

t-node $p := [ t-node $c := [  ] ];
>> $p.functor,$c.functor
>> distinct $1,$2, count(over $1,$2) div count(over $1)
   sort by $1,$3 desc, $2
>> $1, $2, percnt($3,2) & '%'

Another reformulation of the query uses the group function ratio():

t-node $p := [ echild t-node $c :=  [  ] ];
>>  for $p.functor,$c.functor
  give $1,$2,ratio(count() over $1)
  sort by $1,$3 desc
>> $1, $2, percnt($3,2) desc

Finally, we may insert filters selecting just a few (say two) best ranking rows for each functor in the first column:

t-node $p := [ echild t-node $c :=  [  ] ];
>>  for $p.functor,$c.functor
  give $1,$2,ratio(count() over $1)
  sort by $1,$3 desc
>> $1,$2,$3, row_number(over $1)
>> filter $4<=2
>> $1, $2, percnt($3,2) desc

to produce the following output (continuing after the final ellipsis):

ACMP    RSTR    54.37%
ACMP    PAT     10.77%
ACT     RSTR    49.56%
ACT     PAT     9.75%
ADDR    RSTR    64.67%
ADDR    APP     14.74%
ADVS    PRED    48.5%
ADVS    ACT     13.18%
...

Instalation in a few quick steps:

First of all make sure your treebanks are in PML. Otherwise you need to convert your data to PML first. (TODO: list few converters)

There are two main configuration files you will need to setup. Both of them are in PML-TQ installation directory.

<?xml version="1.0" encoding="utf-8"?>
<pmltq_cgi_config xmlns="http://ufal.mff.cuni.cz/pdt/pml/">
 <head>
  <schema href="pmltq_cgi_conf_schema.xml" />
 </head>
 <limit>500</limit>
 <row_limit>10000</row_limit>
 <timeout>30</timeout>
 <tree_print_service>http://localhost:8070/svg</tree_print_service>
 <configurations>
  <dbi id="pdt20_mwe" public="0" featured="99">
    <description>
      <moreinfo>http://ufal.mff.cuni.cz/lexemann/mwe</moreinfo>
      <title>Prague Dependency Treebank 2.0 with Multi-Word Expressions</title>
      <abstract>This dataset adds annotation of multiword expressions and multiword named entities to the original PDT 2.0 data.</abstract>
    </description>
   <driver>Pg</driver>
   <host>localhost</host>
   <port>5432</port>
   <database>pdt20_mwe</database>
   <username>pmltq</username>
   <password>your_password</password>
   <sources>
    <AM schema="valency_lexicon">/work/vallex</AM>
    <AM schema="adata">/work/data</AM>
    <AM schema="tdata">/work/data</AM>
   </sources>
  </dbi>
 </configurations>
</pmltq_cgi_config>

#
# Configuration file for run.sh
#

auth_file="${pmltq_dir}/config/.authorization"
config_file="${pmltq_dir}/config/pmltq_cgi.conf"

btred_config_file="/path/to/btred.rc"
tred_dir=/path/to/tred

# list of print service extensions
extensions=pdt20,pdt_vallex,ptb,arabic_treebank,hydt

# if you want graphics in the WWW interface, setup to your tred installation here
# You'll also need Xvfb installed and the xvfb-run script
print_service="xvfb-run $tred_dir/bin/start_btred -c $btred_config_file -Z $tred_dir/resources -m $tred_dir/examples/print_srvr_simple.btred --enable-extensions $extensions"

on_print_service_stop="grep_kill '[X]vfb :99'"

# Treebank ports and number of http servers to fork.
# Format:
#
# CONFIG_ID=PORT,NUMBER_OF_INSTANCES
#
# e.g
#      foo=1234,2
#      bar=1235,7
#
# where CONFIG_ID refers to the id of <dbi> elements in $config_file
#

# List of CONFIG_ID's of services to start by default

pdt20_mwe=8082,1

all=(# <-- names of treebanks to be run by default
pdt20_mwe
) 

If you want graphics in the WWW interface, Tred and Xvfb installation will be needed. For Tred installation follow this link to Tred Manual. Installation of Xvfb depends on your Linux distribution; use your packaging system or see www.x.org.