|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectch.uzh.ifi.attempto.chartparser.Grammar
public class Grammar
This class represents a grammar that is needed to run the chart parser. A grammar can be created either directly in Java or on the basis of a file in the ACGN format.
-->
" by "=>
":
Complex grammar rules in ACGN are different from common Prolog DCG rules in the sense that they are using features rather than arguments with fixed positions. Arguments are not recognized by their position but by their name:vp => v, np. v => [does, not], verb.
Every feature has the formvp(num:Num,neg:Neg) => v(num:Num,neg:Neg,type:tr), np(case:acc). v(neg:plus,type:Type) => [does, not], verb(type:Type).
Name:Value
where Name
has to be an atom and Value
can be a variable or an atom (but not a compound term).
ACGN provides special support for anaphoric references which are used in (controlled) natural languages to refer to objects earlier in the sentence. For example, in the sentence
A country contains an area that is not controlled by the country.the anaphoric reference "the country" refers to the antecedent "a country". Anaphoric references should be introduced only if the previous text contains a matching antecedent that is accessible. For example, in the case of the partial sentence
A country does not contain a river and borders ...one can refer to "a country", but not to "a river" because being in the scope of a negation makes it inaccessible.
In order to define the accessibility information needed for anaphoric references in a declarative way, we
distinguish two types of grammar rules: accessible rules "=>
" and inaccessible rules "~>
".
The following example shows an inaccessible rule:
Inaccessible rules are handled in the same way as accessible rules with the only exception that the components that are in the scope of the rule are not accessible for subsequent anaphoric references.vp(num:Num,neg:plus) ~> v(num:Num,neg:plus,type:tr), np(case:acc).
This can be visualized by the introduction of a special node "~" in the syntax tree whenever an inaccessible rule is used. For the partial sentence introduced before, the syntax tree could look as follows:
In this case, several accessible rules and exactly one inaccessible rule (indicated by the "~"-node) have been used. All preceding components that can be reached through the syntax tree without traversing a "~"-node in the top-down direction are accessible. Thus, "a country" is accessible from the position "*", but "a river'' is not. Furthermore, "a country" would be accessible from the position of "a river" because the "~"-node is in this case traversed only in the bottum-up direction.
The described procedure allows us to determine all possible anaphoric references that can be used to continue a partial sentence. In our example, one can refer only to "a country". The concept of accessible and inaccessible rules is a simple but powerful instrument to define in a declarative way the accessibility constraints for anaphoric references.
The information about which tokens are accessible for anaphoric
references can be retrieved by the method getAccessiblePositions
of the ChartParser
class.
Note that the SWI Prolog command might be different on your machine (e.g. "swipl -s generate_java.pl -g "generate_java('my_acgn_grammar.pl', 'my.package', 'MyJavaGrammar', 'my_start_category')" -t halt
plcon
" or "pl
").
The Prolog DCG file can be generated like this:
Note that the information about accessible and inaccessible rules gets lost in the Prolog DCG file.swipl -s generate_dcg.pl -g "generate_dcg('my_acgn_grammar.pl', 'my_dcg_grammar.pl')" -t halt
Constructor Summary | |
---|---|
Grammar(Nonterminal startCategory)
Creates a empty grammar with the given start category. |
|
Grammar(java.lang.String startCategoryName)
Creates a empty grammar with a start category of the given name. |
Method Summary | |
---|---|
void |
addRule(Rule rule)
Adds the rule to the grammar. |
java.util.ArrayList<Rule> |
getEpsilonRules()
Returns all the rules that have no body categories. |
java.util.ArrayList<Rule> |
getRulesByHeadName(java.lang.String name)
Returns the rules whose head category has the given name. |
Nonterminal |
getStartCategory()
Returns the start category. |
java.lang.String |
toString()
|
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public Grammar(Nonterminal startCategory)
startCategory
- The start category for the grammar.public Grammar(java.lang.String startCategoryName)
startCategoryName
- The name of the start category for the grammar.Method Detail |
---|
public Nonterminal getStartCategory()
public void addRule(Rule rule)
rule
- The rule to be added.public java.util.ArrayList<Rule> getRulesByHeadName(java.lang.String name)
name
- The name of the head category.
public java.util.ArrayList<Rule> getEpsilonRules()
public java.lang.String toString()
toString
in class java.lang.Object
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |