Difference between revisions of "Apertium-recursive/Formalism"

From Apertium
Jump to navigation Jump to search
(update part 2)
(14 intermediate revisions by the same user not shown)
Line 3: Line 3:
 
=== Basic Rule Syntax ===
 
=== Basic Rule Syntax ===
   
Rules consist of a node type, an optional weight, a pattern, and an output.
+
Rules consist of a node type, an optional weight, a pattern, an optional condition, an optional variable setting, and an output, in that order.
   
NP -> 2.7: det adj.m n.*.sg {3 _2 2 _1 1} ;
+
NP -> det n {2 _1 1};
VP -> 1.0: NP vblex {2 _1 1} |
 
NP vblex adv {2 _2 3 _1 1} ;
 
   
  +
This matches a determiner followed by a noun, combines them into an NP chunk, and at output time produces "noun determiner".
The arrow can be written as either <code>-></code> or <code>→</code>.
 
   
  +
NP -> 1: n {1} |
The first rule matches lexical units or chunks with the sets of tags beginning with <code><det></code>, <code><adj><m></code>, and <code><n><*><sg></code>, respectively. It will then produce a chunk with the part-of-speech tag <code><NP></code> which contains those three nodes and the blanks between them in reverse order (n, adj, det).
 
  +
2: n.*.def {the@det.def.sg _ 1};
   
The second and third rules both produce <code><VP></code> chunks, so that output is written only once and the other components are separated by a pipe character.
+
Here the first rule will match any noun, while the second will match a noun with a <code><def></code> tag. Since the second rule has a higher weight, the first rule will not be applied if they both match.
   
  +
NP -> NP and@cnjcoo NP [$number=pl] {1 _1 2 _2 3};
Patterns are matched LRLM in stages. This is equivalent to applying all rules which can be applied before any rules can be applied to the outputs (see [[User:Popcorndude/Recursive_Transfer/Bytecode]] for the actual algorithm).
 
   
  +
Here the rule specifies that the resulting chunk will be marked with a <code><pl></code> tag.
NP -> n {1} |
 
NP adj {1 _1 2} ;
 
AP -> adj {1} ;
 
   
  +
AP -> adj and@cnjcoo adj ?(1.gender/sl = 3.gender/sl) {1 _1 2 _2 3};
If these rules were applied to an input of <code>n adj</code>, the first rule would match the noun and the third rule would match the adjective and the second rule would never apply because by the time it can match an <code>NP</code>, the next available token is not an <code>adj</code> but an <code>AP</code>.
 
  +
  +
This rule will not apply if the two adjectives have different genders.
  +
  +
The arrow can be written as either <code>-></code> or <code>→</code>.
   
  +
The process by which rules are selected is described [[User:Popcorndude/Recursive_Transfer/Parser | here]].
When there are multiple rules of the same length which all match, the one with the highest weight is applied. If there is a tie, the one that appears first in the rules file is applied. Due to the way the patterns are compiled, if two rules have identical patterns, the first one will always be applied, regardless of weight. If the weight is omitted, it will default to 0. User-defined weights cannot be negative.
 
   
 
=== Attribute Lists ===
 
=== Attribute Lists ===
Line 36: Line 37:
 
gender = (GD m) m f GD;
 
gender = (GD m) m f GD;
   
This defines the <code>gender</code> category as before, but with the addition that if any rule tries to read the gender of a node that doesn't have a gender tag, the result will be <code><GD></code> rather than the empty string. It also creates a rule which will run last (the weight is -1.0) that will replace <code><GD></code> with <code><m></code>.
+
This defines the <code>gender</code> category as before, but with the addition that if any rule tries to read the gender of a node that doesn't have a gender tag, the result will be <code><GD></code> rather than the empty string. It also states that any remaining <code><GD></code> tags will be replaced with <code><m></code> tags in the output step.
  +
  +
An attribute category can include another:
  +
  +
definite = def ind;
  +
  +
! The following are equivalent:
  +
det_type = dem [definite] pos;
  +
det_type = dem def ind pos;
   
 
=== Tag Order ===
 
=== Tag Order ===
Line 46: Line 55:
 
NP: _.number;
 
NP: _.number;
   
Where <code>_</code> represents the lemma and the part of speech tag. Currently these patterns can only be defined based on a single part of speech tag, though it may eventually be possible to match based on multiple tags or to specify a different pattern for particular nodes.
+
Where <code>_</code> represents the lemma and the part of speech tag. Note that it is currently only possible to specify single tags as patterns. However, it is possible to specify that a different pattern should be used (see the output section below). Note also that the lemma queue is automatically appended to the pattern.
   
 
To specify a literal tag in a pattern, put it in angle brackets:
 
To specify a literal tag in a pattern, put it in angle brackets:
   
 
det: _.<def>.number;
 
det: _.<def>.number;
 
At present, chunk tags must also be listed in the rules like so:
 
 
NP.number -> n adj {2 _1 1};
 
 
But this redundancy will hopefully be removed soon.
 
   
 
=== Patterns ===
 
=== Patterns ===
Line 78: Line 81:
   
 
number = (ND sg) sg pl sp ND;
 
number = (ND sg) sg pl sp ND;
NP.number -> n.$number adj {1};
+
NP: _.number;
  +
NP -> n.$number adj {1};
   
 
This rule specifies that the number tag of the NP chunk should be copied from the noun. It will use the target language side if that is available. If not, it will proceed to the reference side, and then the source side. If all three of these are empty, it will use the default value <code><ND></code>. To require that a particular variable be taken from a particular side, put the side after a slash:
 
This rule specifies that the number tag of the NP chunk should be copied from the noun. It will use the target language side if that is available. If not, it will proceed to the reference side, and then the source side. If all three of these are empty, it will use the default value <code><ND></code>. To require that a particular variable be taken from a particular side, put the side after a slash:
   
NP.number -> det.$number/ref n {1 _1 2};
+
NP: number;
  +
NP -> det.$number/ref n {1 _1 2};
   
 
<code>/sl</code> refers to the source language, <code>/tl</code> to the target language, and <code>/ref</code> to anything added by anaphora resolution.
 
<code>/sl</code> refers to the source language, <code>/tl</code> to the target language, and <code>/ref</code> to anything added by anaphora resolution.
Line 88: Line 93:
 
If a pattern element is contributing several tags to the chunk, the following shortcut is available:
 
If a pattern element is contributing several tags to the chunk, the following shortcut is available:
   
NP.number.gender -> %n adj {2 _1 1};
+
NP: _.number.gender;
  +
NP -> %n adj {2 _1 1};
   
 
The <code>%</code> indicates the noun is the source of all chunk tags not elsewhere specified.
 
The <code>%</code> indicates the noun is the source of all chunk tags not elsewhere specified.
Line 94: Line 100:
 
To specify a literal value for a chunk tag, put it in square brackets after the pattern like this:
 
To specify a literal value for a chunk tag, put it in square brackets after the pattern like this:
   
NP.gender.number -> 0: NP cnjcoo NP [$gender=m, $number=pl] {1 _1 2 _2 3} |
+
NP: _.gender.number;
1: NP.f cnjcoo NP.f [$gender=f, $number=pl] {1 _1 2 _2 3} |
+
NP -> 0: NP cnjcoo NP [$gender=m, $number=pl] {1 _1 2 _2 3} |
2: NP.*.sg or@cnjcoo NP.*.sg [$gender=m, $number=sg] {1 _1 2 _2 3} |
+
1: NP.f cnjcoo NP.f [$gender=f, $number=pl] {1 _1 2 _2 3} |
3: NP.f.sg or@cnjcoo NP.f.sg [$gender=f, $number=sg] {1 _1 2 _2 3} ;
+
2: NP.*.sg or@cnjcoo NP.*.sg [$gender=m, $number=sg] {1 _1 2 _2 3} |
  +
3: NP.f.sg or@cnjcoo NP.f.sg [$gender=f, $number=sg] {1 _1 2 _2 3} ;
   
 
That is, treat the gender of the phrase as masculine unless both elements are feminine and the number as singular unless the conjunction is "or" and both elements are singular.
 
That is, treat the gender of the phrase as masculine unless both elements are feminine and the number as singular unless the conjunction is "or" and both elements are singular.
Line 104: Line 111:
   
 
conj_list = and or;
 
conj_list = and or;
  +
NP: _.gender.number;
NP.gender.number -> %NP cnjcoo NP ((2.lem/tl in conj_list) and ~(3.gender = 1.gender)) {1 _1 2 _2 3};
 
  +
NP -> %NP cnjcoo NP ?((2.lem/tl in conj_list) and ~(3.gender = 1.gender)) {1 _1 2 _2 3};
   
This will only match the pattern if it is also the case that the target language lemma of the conjunction is "and" or "or" and the two NPs have different genders. The outermost parentheses are required and order of operations is not guaranteed to make any sense, so please put parentheses around everything.
+
This will only match the pattern if it is also the case that the target language lemma of the conjunction is "and" or "or" and the two NPs have different genders. See below for the syntax of conditions.
   
 
=== Outputs ===
 
=== Outputs ===
Line 133: Line 141:
   
 
These elements can also be prefixed with <code>%</code> to specify that as many tags as possible should be placeholders for tags of the parent chunk.
 
These elements can also be prefixed with <code>%</code> to specify that as many tags as possible should be placeholders for tags of the parent chunk.
  +
  +
These elements can be conjoined using +:
  +
  +
1(gender=f) + 2
  +
  +
This will generate something like <code>^blah<n><f>+bloop<adj>$</code>.
  +
  +
By default, the order of the output tags is based on the output pattern corresponding to the part of speech tag in the pattern. However, it is possible to override this using square brackets:
  +
  +
vblex: _.tense.person.number;
  +
vbinf: _.<inf>;
  +
  +
V -> vblex.inf {1};
  +
! result: ^whatever<vblex><inf><{person}><{number}>$
  +
  +
V -> vblex.inf {1[vbinf]};
  +
! result: ^whatever<vblex><inf>$
  +
  +
Note that the part of speech tag of the output is in all cases the part of speech tag of the input. To avoid this behavior (for example, if you want to change the part of speech tag), write an output rule like the following:
  +
  +
adj: lemh.<adj>.number;
   
 
==== Literal Lexical Units ====
 
==== Literal Lexical Units ====
Line 150: Line 179:
 
==== Output Conditionals ====
 
==== Output Conditionals ====
   
  +
An output conditional evaluates a sequence of conditions and outputs the element corresponding to the first one that evaluates to true. The element to be output can be any of the possibilities listed above, the entire chunk, or another conditional.
It is possible to have multiple output clauses with conditions for which one to use. These conditions are written the same way as those in the patterns.
 
   
  +
NP -> NP cnjcoo NP
mood = ind opt nec inf;
 
VP -> vblex {should@vaux _ 1(mood=inf)} (1.mood = opt)
+
(if (2.lem/sl = and)
{could@vaud _ 1(mood=inf)} (1.mood = nec)
+
{ 1 _1 3 }
{1} ;
+
else
  +
{ 1 _1 2 _2 3 } );
   
  +
Here the rule determines what the final output will be based on the lemma of the conjunction.
Here the third option has no condition and thus functions as an elsewhere case. If multiple conditions are satisfied, the first one will be used.
 
   
  +
PP -> DP ?(1.case in might_get_pr)
=== Attribute Maps (not yet implemented) ===
 
  +
(if (1.prep_flag = none)
  +
{ 1 }
  +
else
  +
{ (if (1.prep_flag = to)
  +
to@pr
  +
else-if (1.prep_flag = at)
  +
at@pr
  +
else-if (1.prep_flag = in)
  +
in@pr
  +
else-if (1.prep_flag = on)
  +
on@pr
  +
else
  +
for@pr
  +
)
  +
_ 1 } );
   
  +
Here the rule determines first whether to add a preposition. If it is going to add a preposition, it creates a chunk and within that chunk, has another if statement to determine which preposition to add.
This would be a way to convert certain sets of tags, either between two languages that have different sets of tenses, or between something like object agreement and number marking. (The following syntax is entirely provisional.)
 
  +
  +
The first clause is labeled "if", the last can be "else" or "otherwise", and intermediate ones can be "if", "else-if", or "elif". These labels follow the same rules as logical operators - that is, capitalization, "-", and "_" are all ignored.
  +
  +
For the output of an if statement to have multiple elements, surround those elements with square brackets. Thus the conjunction rule above can be rewritten as follows:
  +
  +
NP -> NP cnjcoo NP
  +
{ 1 _1
  +
(if (2.lem/sl = and)
  +
[ 2 _2 ]
  +
else [] )
  +
3 };
  +
  +
=== Conditions ===
  +
  +
Conditions are written in parentheses. A condition is a value, an operator, and another value. If the operator is "and" or "or" these values are other conditions, otherwise they are clips or strings. A condition can be negated by writing "not" before the operator.
  +
  +
(1.case = 2.case) ! true if the first and second elements have the same case, otherwise false
  +
(1.case not = 2.case) ! the reverse of the previous line
  +
  +
The full list of operations is as follows:
  +
  +
{| class="wikitable" border="1"
  +
|-
  +
! Name
  +
! Description
  +
! Alternate Spellings
  +
|-
  +
| And
  +
| Evaluates to true if both arguments evaluates to true, otherwise false
  +
| &
  +
|-
  +
| Or
  +
| Evaluates to true if either argument evaluates to true, otherwise false
  +
| <nowiki>|</nowiki>
  +
|-
  +
| Equal
  +
| Evaluates to true if the arguments are identical strings
  +
| =
  +
|-
  +
| IsPrefix
  +
| Evaluates to true if the right argument occurs at the beginning of the left argument
  +
| StartsWith, BeginsWith
  +
|-
  +
| IsSuffix
  +
| Evaluates to true if the right argument occurs at the end of the left argument
  +
| EndsWith
  +
|-
  +
| IsSubstring
  +
| Evaluates to true if the right argument occurs anywhere in the left argument
  +
| Contains
  +
|-
  +
| HasPrefix
  +
| Evaluates to true if the left argument begins with anything in the list named by the right argument
  +
| StartsWithList, BeginsWithList
  +
|-
  +
| HasSuffix
  +
| Evaluates to true if the left argument ends with anything in the list named by the right argument
  +
| EndsWithList
  +
|-
  +
| In
  +
| Evaluates to true if the left argument is a member of the list named by the right argument
  +
| ∈
  +
|}
  +
  +
Any of these operators (besides And and Or) can be made to ignore case by adding one of "cl", "caseless", "fold", "foldcase".
  +
  +
maybe_get_pr = dat obj;
  +
(1.case in maybe_get_pr)
  +
  +
footwear = boot sock shoe sandal;
  +
((1.number = du) and (1.lem/tl in_caseless footwear))
  +
! note that "in-case-less", "incl", "IN-cl", and "__IN_CASE_LESS__" would all also work here.
  +
  +
=== Tag Rewrite Rules ===
  +
  +
This is a way to convert certain sets of tags, either between two languages that have different sets of tenses, or between something like object agreement and number marking.
   
 
object_agr = o1sg o1pl o2sg o2pl o3sg o3pl ;
 
object_agr = o1sg o1pl o2sg o2pl o3sg o3pl ;
Line 167: Line 288:
 
person = p1 p2 p3 ;
 
person = p1 p2 p3 ;
 
 
object_agr > person.number: o1sg p1.sg, o1pl p1.pl, o2sg p2.sg, o2pl p2.pl, o3sg p3.sg, o3pl p3.pl ;
+
object_agr > person: o1sg p1, o1pl p1, o2sg p2, o2pl p2, o3sg p3, o3pl p3 ;
  +
object_agr > number: o1sg sg, o1pl pl, o2sg sg, o2pl pl, o3sg sg, o3pl pl ;
 
 
VP -> @v NP {2(object_agr=1.object_agr) _1 1} ;
+
VP -> @v NP {2(number=1.object_agr) _1 1} ;
   
In this example, if the verb had <o2sg>, the noun would get <code>object_agr=o2sg, person=p2, number=sg</code>, with the first two tags probably being discarded on output.
+
In this example, if the verb had <code><o2sg></code>, it would be converted to <code><sg></code> when it was set as the <code>number</code> attribute of the noun.
 
 
 
tense = farpst nearpst pst prs fut nonpst ;
 
tense = farpst nearpst pst prs fut nonpst ;
Line 180: Line 302:
   
 
Converting from 4 to 3 with something like <pre>tense > tense: farpst pst, nearpst pst ;</pre>
 
Converting from 4 to 3 with something like <pre>tense > tense: farpst pst, nearpst pst ;</pre>
should also work, the unchanged tags not needing to be explicitly mentioned.
+
will also work, the unchanged tags not needing to be explicitly mentioned.
  +
  +
When an attribute category is being mapped to itself, such as in the tense example above, the replacement is always performed. As a result, if a tag appears on the left side of a change and the right side of another, the results may be incorrect. For example:
  +
  +
tense > tense: midpst pst, pst pri;
  +
  +
This rule might convert <code><midpst></code> to either <code><pst></code> or <code><pri></code> in different situations.
  +
  +
However, when a rule maps between different categories, as in the object agreement example, the transformation will not happen invisibly. That is, if you have <code>1</code> in the output, a <code>tense > tense</code> conversion will happen, but a <code>object_agr > number</code> one won't. This is because the compiler does not have enough information to know what attributes that node has which can be clipped and thus does not know what it is converting from.
  +
  +
In order for this to be fully automatic, the <code>number</code> element in the relevant output pattern would have to compile to something which checked <code>number</code> and then every attribute that could map to <code>number</code> until it found one. While this behavior could be added if desired, I initially deemed it too complicated and simply required that in such situations the rule author has to write <code>1(number=1.object_agr)</code> to trigger the <code>object_agr > number</code> conversion.
  +
  +
It is also possible to explicitly convert a value, for example when doing comparisons:
  +
  +
1.object_agr>number
  +
1.object_agr>person
  +
  +
Like attribute category definitions, tag rewrite rules can refer to entire output categories by enclosing them in square brackets. Since the replacement must result in a single value, this can only be done on the source side.
  +
  +
pasts = farpst midpst nearpst;
  +
tense = farpst midpst nearpst past pres fut;
  +
  +
! These are equivalent:
  +
tense > tense : [pasts] past;
  +
tense > tense : farpst past, midpst past, nearpst past;
  +
  +
=== Macros ===
  +
  +
The macro facility is a combination of tag order rules and output conditionals.
  +
  +
det_type = dem def ind;
  +
  +
det_dem: _.<dem>.distance;
  +
det_def: _.definite.number;
  +
  +
det: (if (1.det_type = dem)
  +
1[det_dem]
  +
else
  +
1[def_def]
  +
);
  +
  +
Here we define a "det" pattern which will apply the "det_dem" pattern or the "det_def" pattern to its argument based on whether that argument has a <code><dem></code> tag. Since this is a tag order pattern it will be applied to all <code><det></code>s by default and can also be manually applied to other things with the <code>3[det]</code> syntax.
  +
  +
Macros are only allowed to clip from the input node (referred to as <code>1</code>), including any values passed in.
  +
  +
If a macro specifies a value for an attribute, it will override anything that is passed in. Thus if the above example had <code>1[det_dem](distance=prx)</code> rather than <code>1[det_dem]</code>, invoking it as <code>2[det](distance=dist)</code> and as <code>2[det](distance=med)</code> would make no difference and the output would be have <code><prx></code> regardless.
  +
  +
A macro is not required to function as a tag order pattern and may output anything or nothing, so long as it only accesses attributes of the input node.
  +
  +
If you want to call a macro and what node gets passed in doesn't matter, you can use the symbol <code>*</code> to represent an empty node.
  +
  +
maybe_det: (if (1.definite = def)
  +
[the@det.def.sp _]
  +
elif (1.number = sg)
  +
[a@det.ind.sp _]
  +
else [] );
  +
DP -> n { *[maybe_det](number=1.number, definite=$definite) 1 };
  +
  +
This will insert "the" if the DP is definite, "a" if it's indefinite and singular, and will output only the noun otherwise.
  +
  +
Since a macro needs to be contained in a conditional but not all macros are conditional, they permit the keyword <code>always</code> in addition to <code>if</code>, <code>else</code>, etc.
  +
  +
vaux: (always 1[vblex]);
  +
  +
This macro is essentially an alias of <code>vblex</code>.
   
 
=== Interpolation (not yet implemented) ===
 
=== Interpolation (not yet implemented) ===
Line 198: Line 384:
   
 
I'm not sure whether this will cover all cases, but it should at least cover a lot of them.
 
I'm not sure whether this will cover all cases, but it should at least cover a lot of them.
  +
  +
== Correspondence with t*x ==
  +
  +
number = sg pl;
  +
gender = m f;
  +
pre_adj = gran buen;
  +
  +
n: _.gender.number;
  +
adj: _.gender;
  +
NP: _.number;
  +
  +
NP -> adj n.$number ?(1.number = 2.number)
  +
(if (1.lem/tl incl pre_adj)
  +
{1(gender=2.gender) _1 2}
  +
else
  +
{2 _1 1(gender=2.gender)}
  +
) ;
  +
  +
<transfer>
  +
<section-def-cats>
  +
<def-cat "n">
  +
<cat-item tags="n"/>
  +
<cat-item tags="n.*"/>
  +
</def-cat>
  +
<def-cat "adj">
  +
<cat-item tags="adj"/>
  +
<cat-item tags="adj.*"/>
  +
</def-cat>
  +
</section-def-cats>
  +
<section-def-attrs>
  +
<def-attr n="number">
  +
<attr-item tags="sg"/>
  +
<attr-item tags="pl"/>
  +
</def-attr>
  +
<def-attr n="gender">
  +
<attr-item tags="m"/>
  +
<attr-item tags="f"/>
  +
</def-attr>
  +
</section-def-attrs>
  +
<section-def-lists>
  +
<def-list n="pre_adj">
  +
<list-item v="gran"/>
  +
<list-item v="buen"/>
  +
</def-list>
  +
</section-def-lists>
  +
<section-rules>
  +
<rule comment="adj n">
  +
<pattern>
  +
<pattern-item n="adj"/>
  +
<pattern-item n="n"/>
  +
</pattern>
  +
<action>
  +
<choose>
  +
<when>
  +
<test>
  +
<not>
  +
<equal>
  +
<clip pos="1" side="tl" part="number"/>
  +
<clip pos="2" side="tl" part="number"/>
  +
</equal>
  +
</not>
  +
</test>
  +
<reject-current-rule/>
  +
</when>
  +
</choose>
  +
<choose>
  +
<when>
  +
<test>
  +
<in caseless="yes">
  +
<clip pos="1" side="tl" part="lem"/>
  +
<list n="pre_adj"/>
  +
</in>
  +
</test>
  +
<out>
  +
<chunk name="default">
  +
<tags>
  +
<tag><lit-tag v="NP"/></tag>
  +
</tags>
  +
<lu>
  +
<clip pos="1" side="tl" part="lemh"/>
  +
<lit-tag v="adj"/>
  +
<clip pos="2" side="tl" part="gender"/>
  +
</lu>
  +
<b pos="1"/>
  +
<lu>
  +
<clip pos="2" side="tl" part="lemh"/>
  +
<lit-tag v="n"/>
  +
<clip pos="2" side="tl" part="gender"/>
  +
<clip pos="2" side="tl" part="number"/>
  +
</lu>
  +
</chunk>
  +
</out>
  +
</when>
  +
<otherwise>
  +
<out>
  +
<chunk name="default">
  +
<tags>
  +
<tag><lit-tag v="NP"/></tag>
  +
</tags>
  +
<lu>
  +
<clip pos="1" side="tl" part="lemh"/>
  +
<lit-tag v="adj"/>
  +
<clip pos="2" side="tl" part="gender"/>
  +
<clip pos="1" side="tl" part="lemq"/>
  +
</lu>
  +
<b pos="1"/>
  +
<lu>
  +
<clip pos="2" side="tl" part="lemh"/>
  +
<lit-tag v="n"/>
  +
<clip pos="2" side="tl" part="gender"/>
  +
<clip pos="2" side="tl" part="number"/>
  +
<clip pos="2" side="tl" part="lemq"/>
  +
</lu>
  +
</chunk>
  +
</out>
  +
</otherwise>
  +
</choose>
  +
</action>
  +
</rule>
  +
</section-rules>
  +
</transfer>
  +
  +
{| class="wikitable" border="1"
  +
|-
  +
| <pre>
  +
number = sg pl;
  +
</pre>
  +
| <pre>
  +
<def-attr n="number">
  +
<attr-item tags="sg"/>
  +
<attr-item tags="pl"/>
  +
</def-attr>
  +
<def-list n="number">
  +
<list-item v="sg"/>
  +
<list-item v="pl"/>
  +
</def-list>
  +
</pre>
  +
| It isn't shown in the above example, but each list simultaneously defines an attribute category and a list.
  +
|-
  +
| <pre>n: _.gender.number;</pre>
  +
| (no direct equivalent)
  +
|
  +
|-
  +
| <pre>NP -> </pre>
  +
| <pre>
  +
<tags>
  +
<tag><lit-tag v="NP"/></tag>
  +
...
  +
</tags>
  +
</pre>
  +
| The further contents of <code><tags></code> is determined by <code>NP: _.number;</code>, which indicates that those contents will be a <code>number</code> tag, probably clipped from one of the inputs.
  +
|-
  +
| <pre>n</pre>
  +
| <pre><def-cat n="some_unique_name">
  +
<cat-item tags="n"/>
  +
<cat-item tags="n.*"/>
  +
</def-cat>
  +
...
  +
<pattern-item n="some_unique_name"/>
  +
</pre>
  +
|
  +
|-
  +
| <pre>.$number</pre>
  +
| <pre><clip pos="2" side="tl" part="number"/></pre>
  +
| This determines the contents of <code><tags></code> in the output chunk.
  +
|-
  +
| <pre>?</pre>
  +
| <pre>
  +
<choose>
  +
<when>
  +
<test>
  +
<not>
  +
...
  +
</not>
  +
</test>
  +
<reject-current-rule/>
  +
</when>
  +
</choose>
  +
</pre>
  +
| There is no functionality equivalent to <code><reject-current-rule shifting="yes"/></code>.
  +
|-
  +
| <pre>1.number</pre>
  +
| <pre><clip pos="1" part="number"/></pre>
  +
| In the example rule, the clips are written as being <code>side="tl"</code>, but an unspecified clip will actually check all three sides (target, then reference, then source) until it finds a value.
  +
|-
  +
| <pre>
  +
(if (...)
  +
...
  +
else
  +
...
  +
)
  +
</pre>
  +
| <pre>
  +
<choose>
  +
<when>
  +
<test>
  +
...
  +
</test>
  +
<out>
  +
...
  +
</out>
  +
</when>
  +
<otherwise>
  +
<out>
  +
...
  +
</out>
  +
</otherwise>
  +
</choose>
  +
</pre>
  +
|
  +
|-
  +
| <pre>(... incl ...)</pre>
  +
| <pre>
  +
<in caseless="yes">
  +
...
  +
<list n="..."/>
  +
</in>
  +
</pre>
  +
|
  +
|-
  +
| <pre>_1</pre>
  +
| <pre><b pos="1"/></pre>
  +
|
  +
|-
  +
| <pre>1(gender=2.gender)</pre>
  +
| <pre>
  +
<lu>
  +
<clip pos="1" side="tl" part="lemh"/>
  +
<lit-tag v="adj"/>
  +
<clip pos="2" side="tl" part="gender"/>
  +
<clip pos="1" side="tl" part="lemq"/>
  +
</lu>
  +
</pre>
  +
| <code><lit-tag v="adj"/></code> should actually be <code><clip pos="1" side="tl" part="pos_tag"/></code> where <code>pos_tag</code> is a special attribute that returns whatever the first tag is.
  +
|-
  +
| <pre>{ ... }</pre>
  +
| <pre>
  +
<chunk name="default">
  +
...
  +
</chunk>
  +
</pre>
  +
| It is possible to make the name be something other than default, for example with <code>n.$lem/sl</code> in the pattern.
  +
|}
  +
  +
Technically this would compile to a rule which output an <code>NP</code> chunk containing the input unchanged and also a separate postchunk rule that would do the actual rearranging so that the conditionals can depend on changed values of the chunk tags.
  +
  +
== Example ==
  +
  +
=== Initial Sentence ===
  +
  +
In a hole in the ground there lived a Hobbit.
  +
  +
=== Output of eng-spa-lex ===
  +
  +
^In<pr>/En<pr>$ ^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^hole<n><sg>/agujero<n><m><sg>$ ^in<pr>/en<pr>$ ^the<det><def><sp>/el<det><def><GD><ND>$ ^ground<n><sg>/tierra<n><f><sg>$ ^there<adv>/allí<adv>$ ^live<vblex><past>/vivir<vblex><past>$ ^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^Hobbit<n><sg>/Hobbit<n><m><sg>$^.<sent>/.<sent>$^.<sent>/.<sent>$
  +
  +
=== A Simple Set of Rules ===
  +
  +
gender = m f;
  +
number = (ND sg) sg pl ND;
  +
definite = def ind;
  +
tense = past pres ifi;
  +
person = (PD p3) p1 p2 p3 PD;
  +
  +
tense > tense : past ifi;
  +
  +
n: _.gender.number;
  +
det: _.definite.gender.number;
  +
pr: _;
  +
vblex: _.tense.person.number;
  +
adv: _;
  +
  +
NP: _.gender.number;
  +
DP: _.gender.number;
  +
PP: _;
  +
VP: _.tense.person.number;
  +
  +
NP -> %n { 1 } |
  +
10: %n PP { 1 _1 2 } ;
  +
  +
PP -> pr DP { 1 _1 2 } ;
  +
  +
DP -> det %NP { 1(gender=2.gender, number=2.number) _1 2 } ;
  +
  +
VP -> %vblex DP { 1 _1 2 } |
  +
adv %VP { 1 _1 2 } |
  +
PP %VP { 1 _1 2 } ;
  +
  +
=== Process ===
  +
  +
{| class="wikitable"
  +
|-
  +
! Action
  +
! Result
  +
! Comments
  +
|-
  +
| Read token
  +
| <ol>
  +
<li>^In<pr>/En<pr>$</li>
  +
</ol>
  +
|
  +
|-
  +
| Read token
  +
| <ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li></ol>
  +
|
  +
|-
  +
| Read token
  +
| <ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^hole<n><sg>/agujero<n><m><sg>$</li></ol>
  +
|
  +
|-
  +
| Split
  +
| <ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^hole<n><sg>/agujero<n><m><sg>$</li></ol>
  +
<hr>
  +
<ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^hole<n><sg>/agujero<n><m><sg>$</pre></li></ol>
  +
| Rule 1 (<code>NP -> n</code>) could apply, but it's possible that reading more of the input would make it so rule 2 (<code>NP -> n PP</code>) could apply, so we do both.
  +
|-
  +
| Apply rule 1 (<code>NP -> n</code>)
  +
| <ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^unknown<NP><m><sg>{^hole<n><sg>/agujero<n><m><sg>$}$</li></ol>
  +
<hr/>
  +
<ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^hole<n><sg>/agujero<n><m><sg>$</li></ol>
  +
| Since the rule says <code>%n</code>, the required NP tags (gender and number) are filled in with the values of the noun tags.
  +
|-
  +
| Apply rule 4 (<code>DP -> det NP</code>)
  +
| <ol><li>^In<pr>/En<pr>$</li>
  +
<li>^unknown<DP><m><sg>{^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^unknown<NP><m><sg>{^hole<n><sg>/agujero<n><m><sg>$}$}$</li></ol>
  +
<hr/>
  +
<ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^hole<n><sg>/agujero<n><m><sg>$</li></ol>
  +
| Note that the determiner still has GD as it's gender. Child tags are not modified until the output step.
  +
|-
  +
| Apply rule 3 (<code>PP -> pr DP</code>)
  +
| <ol><li>^unknown<PP>{^In<pr>/En<pr>$ ^unknown<DP><m><sg>{^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^unknown<NP><m><sg>{^hole<n><sg>/agujero<n><m><sg>$}$}$}$</li></ol>
  +
<hr/>
  +
<ol><li>^In<pr>/En<pr>$</li>
  +
<li>^a<det><ind><sg>/uno<det><ind><GD><sg>$</li>
  +
<li>^hole<n><sg>/agujero<n><m><sg>$</li></ol>
  +
|
  +
|}

Revision as of 22:20, 18 July 2019

A proposal for a recursive transfer rule formalism.

Basic Rule Syntax

Rules consist of a node type, an optional weight, a pattern, an optional condition, an optional variable setting, and an output, in that order.

NP -> det n {2 _1 1};

This matches a determiner followed by a noun, combines them into an NP chunk, and at output time produces "noun determiner".

NP -> 1: n {1} |
      2: n.*.def {the@det.def.sg _ 1};

Here the first rule will match any noun, while the second will match a noun with a <def> tag. Since the second rule has a higher weight, the first rule will not be applied if they both match.

NP -> NP and@cnjcoo NP [$number=pl] {1 _1 2 _2 3};

Here the rule specifies that the resulting chunk will be marked with a <pl> tag.

AP -> adj and@cnjcoo adj ?(1.gender/sl = 3.gender/sl) {1 _1 2 _2 3};

This rule will not apply if the two adjectives have different genders.

The arrow can be written as either -> or .

The process by which rules are selected is described here.

Attribute Lists

A list of attributes can be defined like this:

gender = m f GD ;
number = sg pl ND ;

An attribute list can also specify undefined and default values:

gender = (GD m) m f GD;

This defines the gender category as before, but with the addition that if any rule tries to read the gender of a node that doesn't have a gender tag, the result will be <GD> rather than the empty string. It also states that any remaining <GD> tags will be replaced with <m> tags in the output step.

An attribute category can include another:

definite = def ind;

! The following are equivalent:
det_type = dem [definite] pos;
det_type = dem def ind pos;

Tag Order

The order of tags for each type of node must be defined like this:

n: _.gender.number;
adj: _.gender;
NP: _.number;

Where _ represents the lemma and the part of speech tag. Note that it is currently only possible to specify single tags as patterns. However, it is possible to specify that a different pattern should be used (see the output section below). Note also that the lemma queue is automatically appended to the pattern.

To specify a literal tag in a pattern, put it in angle brackets:

det: _.<def>.number;

Patterns

An element of a pattern must match a single, literal part of speech tag. In order to match multiple part of speech tags, create a separate rule which matches each of them:

NOM -> n {1} | np {1};

To match a lemma or pseudolemma, place it before the part of speech tag, separated by @:

NP -> the@det n {2 _1 1};

It is also possible to match a category of lemmas:

days = sunday monday tuesday wednesday thursday friday saturday;
date -> $days@n the@det num.ord {2 _2 3 _1 1};

Tags besides part of speech can be matched as shown above.

Pattern elements can also specify values for the tags of the chunk being output by the rule.

number = (ND sg) sg pl sp ND;
NP: _.number;
NP -> n.$number adj {1};

This rule specifies that the number tag of the NP chunk should be copied from the noun. It will use the target language side if that is available. If not, it will proceed to the reference side, and then the source side. If all three of these are empty, it will use the default value <ND>. To require that a particular variable be taken from a particular side, put the side after a slash:

NP: number;
NP -> det.$number/ref n {1 _1 2};

/sl refers to the source language, /tl to the target language, and /ref to anything added by anaphora resolution.

If a pattern element is contributing several tags to the chunk, the following shortcut is available:

NP: _.number.gender;
NP -> %n adj {2 _1 1};

The % indicates the noun is the source of all chunk tags not elsewhere specified.

To specify a literal value for a chunk tag, put it in square brackets after the pattern like this:

NP: _.gender.number;
NP -> 0: NP cnjcoo NP [$gender=m, $number=pl] {1 _1 2 _2 3} |
      1: NP.f cnjcoo NP.f [$gender=f, $number=pl] {1 _1 2 _2 3} |
      2: NP.*.sg or@cnjcoo NP.*.sg [$gender=m, $number=sg] {1 _1 2 _2 3} |
      3: NP.f.sg or@cnjcoo NP.f.sg [$gender=f, $number=sg] {1 _1 2 _2 3} ;

That is, treat the gender of the phrase as masculine unless both elements are feminine and the number as singular unless the conjunction is "or" and both elements are singular.

The pattern only looks at the source language, but it is possible to add constraints:

conj_list = and or;
NP: _.gender.number;
NP -> %NP cnjcoo NP ?((2.lem/tl in conj_list) and ~(3.gender = 1.gender)) {1 _1 2 _2 3};

This will only match the pattern if it is also the case that the target language lemma of the conjunction is "and" or "or" and the two NPs have different genders. See below for the syntax of conditions.

Outputs

Output elements are written between curly braces and may be any of the following:

Blanks

An underscore represents a single space. An underscore followed by a number represents the superblank after that position, so 1 _ 2 is elements 1 and 2 separated by a space while 1 _1 2 is elements 1 and 2 separated by whatever separated them in the input.

Matched Elements

A number represents the input element in that position with its tags arranged according to the defined output pattern for its part of speech tag. It can be followed by a specification of where those tags should come from.

1
! the first input element

1(gender=f)
! the first input element with the gender tag <f>

1(gender=2.gender/ref)
! the first input element with the gender tag of the reference side of the second input element

1(gender=$gender)
! the first input element with the gender tag set to a placeholder to be filled on output with the gender tag of its parent chunk

These elements can also be prefixed with % to specify that as many tags as possible should be placeholders for tags of the parent chunk.

These elements can be conjoined using +:

1(gender=f) + 2

This will generate something like ^blah<n><f>+bloop<adj>$.

By default, the order of the output tags is based on the output pattern corresponding to the part of speech tag in the pattern. However, it is possible to override this using square brackets:

vblex: _.tense.person.number;
vbinf: _.<inf>;

V -> vblex.inf {1};
  ! result: ^whatever<vblex><inf><{person}><{number}>$

V -> vblex.inf {1[vbinf]};
  ! result: ^whatever<vblex><inf>$

Note that the part of speech tag of the output is in all cases the part of speech tag of the input. To avoid this behavior (for example, if you want to change the part of speech tag), write an output rule like the following:

adj: lemh.<adj>.number;

Literal Lexical Units

A new lexical unit can be inserted like this:

the@det.def.mf.sp

Placeholders can be included using $:

the@det.def.$gender.sp

And clips from other elements can be placed in square brackets:

the@det.def.[2.gender].[3.number/sl]

Output Conditionals

An output conditional evaluates a sequence of conditions and outputs the element corresponding to the first one that evaluates to true. The element to be output can be any of the possibilities listed above, the entire chunk, or another conditional.

NP -> NP cnjcoo NP
         (if (2.lem/sl = and)
             { 1 _1 3 }
          else
             { 1 _1 2 _2 3 } );

Here the rule determines what the final output will be based on the lemma of the conjunction.

PP -> DP ?(1.case in might_get_pr)
         (if (1.prep_flag = none)
             { 1 }
          else
             { (if (1.prep_flag = to)
                   to@pr
                else-if (1.prep_flag = at)
                   at@pr
                else-if (1.prep_flag = in)
                   in@pr
                else-if (1.prep_flag = on)
                   on@pr
                else
                   for@pr
                )
                _ 1 } );

Here the rule determines first whether to add a preposition. If it is going to add a preposition, it creates a chunk and within that chunk, has another if statement to determine which preposition to add.

The first clause is labeled "if", the last can be "else" or "otherwise", and intermediate ones can be "if", "else-if", or "elif". These labels follow the same rules as logical operators - that is, capitalization, "-", and "_" are all ignored.

For the output of an if statement to have multiple elements, surround those elements with square brackets. Thus the conjunction rule above can be rewritten as follows:

NP -> NP cnjcoo NP
         { 1 _1
           (if (2.lem/sl = and)
               [ 2 _2 ]
            else [] )
          3 };

Conditions

Conditions are written in parentheses. A condition is a value, an operator, and another value. If the operator is "and" or "or" these values are other conditions, otherwise they are clips or strings. A condition can be negated by writing "not" before the operator.

(1.case = 2.case)     ! true if the first and second elements have the same case, otherwise false
(1.case not = 2.case) ! the reverse of the previous line

The full list of operations is as follows:

Name Description Alternate Spellings
And Evaluates to true if both arguments evaluates to true, otherwise false &
Or Evaluates to true if either argument evaluates to true, otherwise false |
Equal Evaluates to true if the arguments are identical strings =
IsPrefix Evaluates to true if the right argument occurs at the beginning of the left argument StartsWith, BeginsWith
IsSuffix Evaluates to true if the right argument occurs at the end of the left argument EndsWith
IsSubstring Evaluates to true if the right argument occurs anywhere in the left argument Contains
HasPrefix Evaluates to true if the left argument begins with anything in the list named by the right argument StartsWithList, BeginsWithList
HasSuffix Evaluates to true if the left argument ends with anything in the list named by the right argument EndsWithList
In Evaluates to true if the left argument is a member of the list named by the right argument

Any of these operators (besides And and Or) can be made to ignore case by adding one of "cl", "caseless", "fold", "foldcase".

maybe_get_pr = dat obj;
(1.case in maybe_get_pr)

footwear = boot sock shoe sandal;
((1.number = du) and (1.lem/tl in_caseless footwear))
! note that "in-case-less", "incl", "IN-cl", and "__IN_CASE_LESS__" would all also work here.

Tag Rewrite Rules

This is a way to convert certain sets of tags, either between two languages that have different sets of tenses, or between something like object agreement and number marking.

object_agr = o1sg o1pl o2sg o2pl o3sg o3pl ;
number = sg pl ;
person = p1 p2 p3 ;

object_agr > person: o1sg p1, o1pl p1, o2sg p2, o2pl p2, o3sg p3, o3pl p3 ;
object_agr > number: o1sg sg, o1pl pl, o2sg sg, o2pl pl, o3sg sg, o3pl pl ;

VP -> @v NP {2(number=1.object_agr) _1 1} ;

In this example, if the verb had <o2sg>, it would be converted to <sg> when it was set as the number attribute of the noun.

tense = farpst nearpst pst prs fut nonpst ;

tense > tense: farpst pst, nearpst pst, prs nonpst, fut nonpst ;

In this example, no explicit assignment needs to take place and the 4 tenses of the source language (farpst, nearpst, prs, fut) would be automatically converted to the 2 of the target language (pst, nonpst).

Converting from 4 to 3 with something like

tense > tense: farpst pst, nearpst pst ;

will also work, the unchanged tags not needing to be explicitly mentioned.

When an attribute category is being mapped to itself, such as in the tense example above, the replacement is always performed. As a result, if a tag appears on the left side of a change and the right side of another, the results may be incorrect. For example:

tense > tense: midpst pst, pst pri;

This rule might convert <midpst> to either <pst> or <pri> in different situations.

However, when a rule maps between different categories, as in the object agreement example, the transformation will not happen invisibly. That is, if you have 1 in the output, a tense > tense conversion will happen, but a object_agr > number one won't. This is because the compiler does not have enough information to know what attributes that node has which can be clipped and thus does not know what it is converting from.

In order for this to be fully automatic, the number element in the relevant output pattern would have to compile to something which checked number and then every attribute that could map to number until it found one. While this behavior could be added if desired, I initially deemed it too complicated and simply required that in such situations the rule author has to write 1(number=1.object_agr) to trigger the object_agr > number conversion.

It is also possible to explicitly convert a value, for example when doing comparisons:

1.object_agr>number
1.object_agr>person

Like attribute category definitions, tag rewrite rules can refer to entire output categories by enclosing them in square brackets. Since the replacement must result in a single value, this can only be done on the source side.

pasts = farpst midpst nearpst;
tense = farpst midpst nearpst past pres fut;

! These are equivalent:
tense > tense : [pasts] past;
tense > tense : farpst past, midpst past, nearpst past;

Macros

The macro facility is a combination of tag order rules and output conditionals.

det_type = dem def ind;

det_dem: _.<dem>.distance;
det_def: _.definite.number;

det: (if (1.det_type = dem)
         1[det_dem]
      else
         1[def_def]
     );

Here we define a "det" pattern which will apply the "det_dem" pattern or the "det_def" pattern to its argument based on whether that argument has a <dem> tag. Since this is a tag order pattern it will be applied to all <det>s by default and can also be manually applied to other things with the 3[det] syntax.

Macros are only allowed to clip from the input node (referred to as 1), including any values passed in.

If a macro specifies a value for an attribute, it will override anything that is passed in. Thus if the above example had 1[det_dem](distance=prx) rather than 1[det_dem], invoking it as 2[det](distance=dist) and as 2[det](distance=med) would make no difference and the output would be have <prx> regardless.

A macro is not required to function as a tag order pattern and may output anything or nothing, so long as it only accesses attributes of the input node.

If you want to call a macro and what node gets passed in doesn't matter, you can use the symbol * to represent an empty node.

maybe_det: (if (1.definite = def)
               [the@det.def.sp _]
            elif (1.number = sg)
               [a@det.ind.sp _]
            else [] );
DP -> n { *[maybe_det](number=1.number, definite=$definite) 1 };

This will insert "the" if the DP is definite, "a" if it's indefinite and singular, and will output only the noun otherwise.

Since a macro needs to be contained in a conditional but not all macros are conditional, they permit the keyword always in addition to if, else, etc.

vaux: (always 1[vblex]);

This macro is essentially an alias of vblex.

Interpolation (not yet implemented)

Parsing clitics, such as User_talk:Popcorndude/Recursive_Transfer#Serbo-Croatian_clitics can be done using multiple output units

vbser n -> @n @vbser {2} {1} ;
NP -> @n @det {2 _1 1} ;
! should be able to handle "noun clitic determiner"

Outputting them, however, is more difficult. My current idea is to do something like this:

NP -> @det @n {2 _1 1};
VP -> NP @vbser {(_1 2)>1};

Where (_1 2)>1 means "put the space between the elements and element 2 after the first word of element 1". The corresponding syntax for a right-aligned clitic would be 1<(2 _1). New lexical units could also be put in the parentheses (even if there's only one thing being inserted, the parentheses should, I think, be mandatory for clarity).

I'm not sure whether this will cover all cases, but it should at least cover a lot of them.

Correspondence with t*x

number = sg pl;
gender = m f;
pre_adj = gran buen;

n: _.gender.number;
adj: _.gender;
NP: _.number;

NP -> adj n.$number ?(1.number = 2.number)
          (if (1.lem/tl incl pre_adj)
              {1(gender=2.gender) _1 2}
           else
              {2 _1 1(gender=2.gender)}
          ) ;
<transfer>
 <section-def-cats>
  <def-cat "n">
   <cat-item tags="n"/>
   <cat-item tags="n.*"/>
  </def-cat>
  <def-cat "adj">
   <cat-item tags="adj"/>
   <cat-item tags="adj.*"/>
  </def-cat>
 </section-def-cats>
 <section-def-attrs>
  <def-attr n="number">
   <attr-item tags="sg"/>
   <attr-item tags="pl"/>
  </def-attr>
  <def-attr n="gender">
   <attr-item tags="m"/>
   <attr-item tags="f"/>
  </def-attr>
 </section-def-attrs>
 <section-def-lists>
  <def-list n="pre_adj">
   <list-item v="gran"/>
   <list-item v="buen"/>
  </def-list>
 </section-def-lists>
 <section-rules>
  <rule comment="adj n">
   <pattern>
    <pattern-item n="adj"/>
    <pattern-item n="n"/>
   </pattern>
   <action>
    <choose>
     <when>
      <test>
       <not>
        <equal>
         <clip pos="1" side="tl" part="number"/>
         <clip pos="2" side="tl" part="number"/>
        </equal>
       </not>
      </test>
      <reject-current-rule/>
     </when>
    </choose>
    <choose>
     <when>
      <test>
       <in caseless="yes">
        <clip pos="1" side="tl" part="lem"/>
        <list n="pre_adj"/>
       </in>
      </test>
      <out>
       <chunk name="default">
        <tags>
         <tag><lit-tag v="NP"/></tag>
        </tags>
        <lu>
         <clip pos="1" side="tl" part="lemh"/>
         <lit-tag v="adj"/>
         <clip pos="2" side="tl" part="gender"/>
        </lu>
        
        <lu>
         <clip pos="2" side="tl" part="lemh"/>
         <lit-tag v="n"/>
         <clip pos="2" side="tl" part="gender"/>
         <clip pos="2" side="tl" part="number"/>
        </lu>
       </chunk>
      </out>
     </when>
     <otherwise>
      <out>
       <chunk name="default">
        <tags>
         <tag><lit-tag v="NP"/></tag>
        </tags>
        <lu>
         <clip pos="1" side="tl" part="lemh"/>
         <lit-tag v="adj"/>
         <clip pos="2" side="tl" part="gender"/>
         <clip pos="1" side="tl" part="lemq"/>
        </lu>
        
        <lu>
         <clip pos="2" side="tl" part="lemh"/>
         <lit-tag v="n"/>
         <clip pos="2" side="tl" part="gender"/>
         <clip pos="2" side="tl" part="number"/>
         <clip pos="2" side="tl" part="lemq"/>
        </lu>
       </chunk>
      </out>
     </otherwise>
    </choose>
   </action>
  </rule>
 </section-rules>
</transfer>
number = sg pl;
   <def-attr n="number">
    <attr-item tags="sg"/>
    <attr-item tags="pl"/>
   </def-attr>
   <def-list n="number">
    <list-item v="sg"/>
    <list-item v="pl"/>
   </def-list>
It isn't shown in the above example, but each list simultaneously defines an attribute category and a list.
n: _.gender.number;
(no direct equivalent)
NP -> 
<tags>
 <tag><lit-tag v="NP"/></tag>
 ...
</tags>
The further contents of <tags> is determined by NP: _.number;, which indicates that those contents will be a number tag, probably clipped from one of the inputs.
n
<def-cat n="some_unique_name">
 <cat-item tags="n"/>
 <cat-item tags="n.*"/>
</def-cat>
...
<pattern-item n="some_unique_name"/>
.$number
<clip pos="2" side="tl" part="number"/>
This determines the contents of <tags> in the output chunk.
?
<choose>
 <when>
  <test>
   <not>
    ...
   </not>
  </test>
  <reject-current-rule/>
 </when>
</choose>
There is no functionality equivalent to <reject-current-rule shifting="yes"/>.
1.number
<clip pos="1" part="number"/>
In the example rule, the clips are written as being side="tl", but an unspecified clip will actually check all three sides (target, then reference, then source) until it finds a value.
(if (...)
    ...
 else
    ...
)
<choose>
 <when>
  <test>
   ...
  </test>
  <out>
   ...
  </out>
 </when>
 <otherwise>
  <out>
   ...
  </out>
 </otherwise>
</choose>
(... incl ...)
<in caseless="yes">
 ...
 <list n="..."/>
</in>
_1
<b pos="1"/>
1(gender=2.gender)
<lu>
 <clip pos="1" side="tl" part="lemh"/>
 <lit-tag v="adj"/>
 <clip pos="2" side="tl" part="gender"/>
 <clip pos="1" side="tl" part="lemq"/>
</lu>
<lit-tag v="adj"/> should actually be <clip pos="1" side="tl" part="pos_tag"/> where pos_tag is a special attribute that returns whatever the first tag is.
{ ... }
<chunk name="default">
 ...
</chunk>
It is possible to make the name be something other than default, for example with n.$lem/sl in the pattern.

Technically this would compile to a rule which output an NP chunk containing the input unchanged and also a separate postchunk rule that would do the actual rearranging so that the conditionals can depend on changed values of the chunk tags.

Example

Initial Sentence

In a hole in the ground there lived a Hobbit.

Output of eng-spa-lex

^In<pr>/En<pr>$ ^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^hole<n><sg>/agujero<n><m><sg>$ ^in<pr>/en<pr>$ ^the<det><def><sp>/el<det><def><GD><ND>$ ^ground<n><sg>/tierra<n><f><sg>$ ^there<adv>/allí<adv>$ ^live<vblex><past>/vivir<vblex><past>$ ^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^Hobbit<n><sg>/Hobbit<n><m><sg>$^.<sent>/.<sent>$^.<sent>/.<sent>$

A Simple Set of Rules

gender = m f;
number = (ND sg) sg pl ND;
definite = def ind;
tense = past pres ifi;
person = (PD p3) p1 p2 p3 PD;

tense > tense : past ifi;

n: _.gender.number;
det: _.definite.gender.number;
pr: _;
vblex: _.tense.person.number;
adv: _;

NP: _.gender.number;
DP: _.gender.number;
PP: _;
VP: _.tense.person.number;

NP -> %n { 1 } |
      10: %n PP { 1 _1 2 } ;

PP -> pr DP { 1 _1 2 } ;

DP -> det %NP { 1(gender=2.gender, number=2.number) _1 2 } ;

VP -> %vblex DP { 1 _1 2 } |
      adv %VP { 1 _1 2 } |
      PP %VP { 1 _1 2 } ;

Process

Action Result Comments
Read token
  1. ^In<pr>/En<pr>$
Read token
  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
Read token
  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^hole<n><sg>/agujero<n><m><sg>$
Split
  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^hole<n><sg>/agujero<n><m><sg>$

  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^hole<n><sg>/agujero<n><m><sg>$
Rule 1 (NP -> n) could apply, but it's possible that reading more of the input would make it so rule 2 (NP -> n PP) could apply, so we do both.
Apply rule 1 (NP -> n)
  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^unknown<NP><m><sg>{^hole<n><sg>/agujero<n><m><sg>$}$

  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^hole<n><sg>/agujero<n><m><sg>$
Since the rule says %n, the required NP tags (gender and number) are filled in with the values of the noun tags.
Apply rule 4 (DP -> det NP)
  1. ^In<pr>/En<pr>$
  2. ^unknown<DP><m><sg>{^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^unknown<NP><m><sg>{^hole<n><sg>/agujero<n><m><sg>$}$}$

  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^hole<n><sg>/agujero<n><m><sg>$
Note that the determiner still has GD as it's gender. Child tags are not modified until the output step.
Apply rule 3 (PP -> pr DP)
  1. ^unknown<PP>{^In<pr>/En<pr>$ ^unknown<DP><m><sg>{^a<det><ind><sg>/uno<det><ind><GD><sg>$ ^unknown<NP><m><sg>{^hole<n><sg>/agujero<n><m><sg>$}$}$}$

  1. ^In<pr>/En<pr>$
  2. ^a<det><ind><sg>/uno<det><ind><GD><sg>$
  3. ^hole<n><sg>/agujero<n><m><sg>$