LiGER (Linguistic Graph Expansion and Rewriting)
In line with much recent research on semantic annotation, LiGER is designed to add annotations to syntactic analyses of natural language expressions. In particular, the system focuses on analyses provided by two syntactic frameworks, namely, LFG (as implemented in the Xerox Lingustics Environment (XLE)), and Universal Dependencies (as implemented in the Stanford CoreNLP library).
The system translates (parts) of LFG and UD representations into more abstract linguistic annotation graphs and allows the user to apply transfer rules (an expression coined by the XLE transfer system) to rewrite and expand on linguistic annotations. The system is inspired by the previously mentioned transfer component of the XLE, the packed rewrite system, which is, unfortunately not supported by XLE anymore. LiGER aims at picking up this legacy and provides a framework independent rule system for expansion or rewriting of linguistic annotations.
In addition to adding linguistic annotations (i.e., relational information and linguistic feature information) the system is also coupled with the Glue Semantics Workbench (GSWB), a glue semantics prover written in Java. To make use of the GSWB, the system also allows users to write rules that directly produce glue semantics representations based on a description-by-analysis framework.
This page provides a simple demo of the system with a visualization component to better explain the capabilities of the system, as well as some experimental examples for extended functionalities.
Querying:
The rewrite system is based on a query language for directed graphs. The following demo parses a sentence with a UD parser and then queries the resulting graph with the presented query.If the graph satisfies the query, then the system returns true, else it returns false.
Simple Demo:
The simple demo adds abstract tense and aspect information to a universal dependency graph. More concretely, it aggregates syntactic features into semantically interpretable features. It abstracts away from complex syntactic structures to a simple attribute/value matrix for tense and aspect. For this purpose it uses the rules listed in TAM-conversion rules. The final result of this conversion is given in the TAM node. These test rules follow, to some extent, the best practices of encoding tense and aspect in XLE in accordance with the ParGram project, providing a flat analysis of complex auxiliary constructions (e.g. English perfect, and progressive).
- Light blue circles describe the initial syntactic analysis (a UD dependency parse)
- Red circles describe the added annotation
Graph should appear below here:
Glue semantics integration demo
In addition to adding relational and attribute/value information, the abstract syntax annotator also allows users to design rules that produce semantic representations. More concretely, the system allows users to add meaning constructors, semantic representations used in Glue semantics. Rules for semantic interpretation initialize a set of nodes the indices of which serve the generation of linear logic formulas.
The system uses the rules in semantic interpretation rules to produce meaning constructors. These rules make use of the fact, that variables on the left hand side can be instantiated to concrete values on the right side of a rule (If multiple instantiations are possible, all instantiations are produced, but are mapped to different readings of the sentence).
Graph should appear below here:
How to write rules
In this section, you can modify the simple semantic rules introduced above. For this, a simple editor is provided. The editor highlights variables of different kinds and certain functional elements such as the rule separator, the conjunction, and the end-of-rule ".". The "Parse input" button below the input text provides a syntactic analysis provided by the Stanford CoreNLP. The "Apply rules" button below the rule editor is used to apply the rules in the editor to the sentence entered above.
After submitting the rules, the system displays those rules that apply to the current input in the order that they apply. Each rule is accompanied by a "rule" button. Clicking this button allows the user to show how the graph has been rewritten at that particular point. This functionality serves to debug rewrite rules.
Below the graph window, the semantics are displayed. Below that, the meaning constructors leading to the semantic computation are listed.