apertium-fin-deu

Apertium bilingual data for Finnish–German machine translation

View the Project on GitHub apertium/apertium-fin-deu

apertium-fin-deu: Finnish–German rules for rule-based machine translation

This is a visualisation of some rules in apertium transfer.

Categories (parts of chunks)

These are the categories Apertium is using in order to chunk, re-order and transfer lexemes.

Category Items
desomalieren2np somalieren <vblex.*>
deadp2np de <pr.*>
dest2np st. <abbr>
soviele2np so viele <det.*>
ex2np ex <adv>
nochein2np noch ein <det.*>
directionlich_pr östlich <pr.*> südlich <pr.*>
um um <cnjsub> um <pr.*> um <pr.acc>
seit seit <pr.*> seit <pr.dat> seit <cnjsub>
bevor bevor <preadv>
an an <pr.*> an <pr.dat>
dem der <det.def.*>
ab ab <adv> ab <pr.*>
bis bis <cnjsub> bis <pr.*>
gegen gegen <pr.*> gegen <pr.acc>
uhr Uhr <n.*> uhr <n.*>
über über <pr.*> über <adv>
nach nach <pr.*> nach <adv> nach <pprep.*>
hinweg hinweg <adv>
leben Leben <n.nt.*> leben <n.nt.*>
gekommen kommen <vblex.pp>
monat Januar <n.*> Februar <n.*> März <n.*> April <n.*> Mai <np.*> mai <n.*> Juni <n.*> Juli <n.*> August <n.*> September <n.*> Oktober <n.*> November <n.*> Dezember <n.*> januar <n.*> februar <n.*> märz <n.*> april <n.*> mai <np.*> juni <n.*> juli <n.*> august <n.*> september <n.*> oktober <n.*> november <n.*> dezember <n.*>
zeitwort Jahr <n.*> Jahrzehnt <n.*> jahr <n.*> jahrzehnt <n.*>
informationwort Angabe <n.*> Ansicht <n.*> angabe <n.*> ansicht <n.*>
weder_cc weder <cnjcoo>
noch_cc noch <cnjcoo> noch <adv>
werden werden <vaux.*> werden <vblex.*>
als als <adv> als <cnjadv>
wie wie <adv> wie <adv.itg>
gehen gehen <vblex.pri.p2.pl> gehen <vblex.pri.p3.sg> gehen <vblex.prs.p3.sg>
es es <prn.pers.p3.nt.sg.*> prpers <prn.*.p3.nt.sg.*>
kein kein <det.ind.*>
daynumber <num.ord>
noun <n.*> <np.*>
abbr <abbr> <n.abbr>
cmp <n.cmp> <n.cmp.*> <n.*.cmp> <n.*.cmp.*> <atp.cmp> <atp.*.cmp>
prn <prn.*>
prnpers <prn.pers.*>
prndem <prn.dem.*>
np <np.*>
nominal <n.*> <np.*> <prn.pers.*>
verbnegation nicht <adv> kein <adv>
infinite <vblex.inf> <vblex.ger.*> <vaux.inf> <vbser.inf> <vbhaver.inf>
perfection <vblex.*.pp> <vblex.pp>
participle <vblex.*.pp> <vblex.pp>
haver <vbhaver.*>
adj <adj.*>
adjvl <adj.*> <vblex.*.pp>
adp <post.*> <pr.*> <post> <pr>
poss <det.pos.*>
art der <det.*> ein <det.*>
det <det.*>
cardinal <num.card> <num.card.*> <num.pl.*> <num>
plural <n.*.pl.*> <np.*.pl.*> <prn.*.pl.*>
num <num.*> <num>
multiplier <num.card> <num.card.*> <num.pl.*> <num> Milliarde <n.*> Hundert <n.*>
verb <vblex.*> <vbser.*> <vbmod.*> <vaux.*> <vbhaver.*>
auxiliary <vbmod.*> <vaux.*>
cnjcoo <cnjcoo>
comma , <cm>
sent <sent>

Attributes

These are the morphological analysis value (tag) sets that can be processed in the transfer.

Attribute set name Tags
a_case <nom> <gen> <acc> <dat> <ine> <ela> <ill> <ade> <abl> <all> <par> <tra> <cmp> <lat>
a_verb <vblex> <vblex.neg> <vbser> <vbmod> <vaux>
a_tense <prs> <pis> <pri> <pii> <past>
a_adj <adj> <num.ord>
a_comp <pos> <comp> <sup>
a_adp <post> <pr>
a_adv <adv>
a_noun <n> <n.acr> <n.abbr> <n.compound-only-L> <det> <np.ant.m> <np.ant.f> <np.ant> <np.top> <np.top.use_blacklist> <np.al> <np> <np.acr> <np.acr.al> <np.top.acr> <np.al.acr> <np.org> <np.cog> <num.card> <prn>
a_nominal <n.acr> <n.cmp> <n.compound-only-L> <n> <np.ant.m> <np.ant.f> <np.ant> <np.top> <np.top.use_blacklist> <np.cog> <np.org> <np.al> <np> <np.acr> <np.acr.al> <np.top.acr> <np.al.acr> <num.card> <det> <prn> <adj.pos>
a_det <n> <num.card> <det> <prn> <adj.pos> <adv>
a_prn <prn>
a_number <sg> <sp> <pl>
a_perf <pp>
a_pers <p1.sg> <p2.sg> <p3.sg> <p1.pl> <p2.pl> <p3.pl>
a_numtype <card> <nocard> <ord>
a_num <num> <num.use_nonstd>
a_inf <inf> <infa> <infe> <infma> <ger>
a_conneg <conneg>

Macros

Macros are helper functions in apertium transfer files.

test

Parametres: 1

  1. let $number ≔ “”

comparison-mangler

Parametres: 1

  1. if tl[1]['a_adj'] ≟ <num.ord> then:
  2. let $comparison ≔ “”
  3. elseif sl[1]['a_comp'] ≟ <comp> then:
  4. let $comparison ≔ <com>
  5. elseif sl[1]['a_comp'] ≟ <sup> then:
  6. let $comparison ≔ <sup>
  7. else:
  8. let $comparison ≔ <pos>

voice-mangler

Parametres: 1

  1. if tl[1]['a_voice'] ≟ <actv> then:
  2. let $voice ≔ <actv>
  3. elseif tl[1]['a_voice'] ≟ <pasv> then:
  4. let $voice ≔ <pasv>
  5. else:
  6. let $voice ≔ <actv>

number-mangler

Parametres: 1

  1. if tl[1]['a_number'] ≟ <sp>tl[1]['a_case'] ≟ <nom>tl[1]['lem'] ≟ “kaikki” then:
  2. let $number ≔ <sp>
  3. elseif tl[1]['a_number'] ≟ <sp>tl[1]['a_case'] ≟ <gen>tl[1]['lem'] ≟ “mikä” then:
  4. let $number ≔ <sp>
  5. elseif tl[1]['lem'] ≟ “koko” then:
  6. let $number ≔ “”
  7. elseif $tense ≟ <pri>tl[1]['a_conneg'] ≟ <conneg> then:
  8. let $number ≔ “”
  9. elseif tl[1]['a_nominal'] ≟ <n.compound-only-L> then:
  10. let $number ≔ “”
  11. elseif tl[1]['a_number'] ≟ <sg> then:
  12. let $number ≔ <sg>
  13. elseif tl[1]['a_number'] ≟ <pl> then:
  14. let $number ≔ <pl>
  15. else:
  16. let $number ≔ <sg>

numtype-mangler

Parametres: 1

  1. if sl[1]['a_numtype'] ≟ <card> then:
  2. let $numtype ≔ <card>
  3. elseif sl[1]['a_numtype'] ≟ <ord> then:
  4. let $numtype ≔ <adj.ord>
  5. elseif tl[1]['a_numtype'] ≟ <nocard> then:
  6. let $numtype ≔ “”
  7. else:
  8. let $numtype ≔ <card>

tensemood-mangler

Parametres: 1

  1. if tl[1]['lem'] ≟ “ei” then:
  2. let $tense ≔ “”
  3. elseif sl[1]['a_tense'] ≟ <pii> then:
  4. let $tense ≔ <past>
  5. elseif sl[1]['a_tense'] ≟ <prs> then:
  6. let $tense ≔ <pri>
  7. elseif sl[1]['a_tense'] ≟ <pis> then:
  8. let $tense ≔ <pri>
  9. elseif sl[1]['a_tense'] ≟ <past> then:
  10. let $tense ≔ <past>
  11. else:
  12. let $tense ≔ <pri>

pers-mangler

Parametres: 1

  1. if sl[1]['a_pers'] ≟ <p1.sg> then:
  2. let $pers ≔ <p1.sg>
  3. elseif sl[1]['a_pers'] ≟ <p2.sg> then:
  4. let $pers ≔ <p2.sg>
  5. elseif sl[1]['a_pers'] ≟ <p3.sg> then:
  6. let $pers ≔ <p3.sg>
  7. elseif sl[1]['a_pers'] ≟ <p1.pl> then:
  8. let $pers ≔ <p1.pl>
  9. elseif sl[1]['a_pers'] ≟ <p2.pl> then:
  10. let $pers ≔ <p2.pl>
  11. elseif sl[1]['a_pers'] ≟ <p3.pl> then:
  12. let $pers ≔ <p3.pl>
  13. else:
  14. let $pers ≔ <p3.sg>

case-mangler

Parametres: 1

  1. if tl[1]['lem'] ≟ “koko” then:
  2. let $case ≔ “”
  3. elseif tl[1]['a_nominal'] ≟ <n.compound-only-L> then:
  4. let $case ≔ “”
  5. elseif sl[1]['a_case'] ≟ <acc> then:
  6. let tl[1]['a_case'] ≔ <gen>1. let $case ≔ <gen>
  7. elseif sl[1]['a_case'] ≟ <dat> then:
  8. let tl[1]['a_case'] ≔ <gen>1. let $case ≔ <gen>
  9. elseif sl[1]['a_case'] ≟ <cmp> then:
  10. let tl[1]['a_case'] ≔ <nom>1. let $case ≔ <nom>
  11. elseif sl[1]['a_case'] ≟ <gen> then:
  12. let tl[1]['a_case'] ≔ <gen>1. let $case ≔ <gen>
  13. elseif sl[1]['a_case'] ≟ “” then:
  14. let tl[1]['a_case'] ≔ <nom>1. let $case ≔ <nom>
  15. else:
  16. let tl[1]['a_case'] ≔ <nom>1. let $case ≔ <nom>

infinite-mangler

Parametres: 1

  1. if sl[1]['a_inf'] ≟ <inf> then:
  2. let tl[1]['a_inf'] ≔ <infa>1. let $case ≔ <lat>
  3. elseif sl[1]['a_inf'] ≟ <ger> then:
  4. let tl[1]['a_inf'] ≔ <infma>1. let $case ≔ <ine>

possessive-mangler

Parametres: 1

  1. if sl[1]['lem'] ≟ “mein” then:
  2. let $prnmaybe ≔ ““1. let $poss ≔ <pxsg1>
  3. elseif sl[1]['lem'] ≟ “dein” then:
  4. let $poss ≔ <pxsg2>1. let $prnmaybe ≔ “”
  5. elseif sl[1]['lem'] ≟ “eure” then:
  6. let $poss ≔ <pxsg2>1. let $prnmaybe ≔ “”
  7. elseif sl[1]['lem'] ≟ “unser” then:
  8. let $poss ≔ <pxsg1>1. let $prnmaybe ≔ “”
  9. elseif sl[1]['lem'] ≟ “sein” then:
  10. let $poss ≔ <pxsp3>1. let $prnmaybe ≔ “hän”<prn.pers.sg.gen>
  11. else:
  12. let $poss ≔ <pxsp3>1. let $prnmaybe ≔ tl[1]['whole']

adp-mangler

Parametres: 1

  1. if sl[1]['lem'] ≟ “in”sl[1]['a_case'] ≟ <dat> then:
  2. let $adpmaybe ≔ ““1. let $adpcase ≔ <ine>
  3. elseif sl[1]['lem'] ≟ “ab”sl[1]['a_case'] ≟ <dat> then:
  4. let $adpmaybe ≔ ““1. let $adpcase ≔ <abl>
  5. elseif sl[1]['lem'] ≟ “in”sl[1]['a_case'] ≟ <acc> then:
  6. let $adpmaybe ≔ ““1. let $adpcase ≔ <ill>
  7. elseif sl[1]['lem'] ≟ “auf” then:
  8. let $adpcase ≔ <ine>1. let $adpmaybe ≔ “”
  9. elseif sl[1]['lem'] ≟ “um” then:
  10. let $adpcase ≔ <abl>1. let $adpmaybe ≔ “”
  11. elseif sl[1]['lem'] ≟ “aus” then:
  12. let $adpcase ≔ <ela>1. let $adpmaybe ≔ “”
  13. elseif sl[1]['lem'] ≟ “über” then:
  14. let $adpcase ≔ <ela>1. let $adpmaybe ≔ “”
  15. elseif sl[1]['lem'] ≟ “bei” then:
  16. let $adpcase ≔ <ade>1. let $adpmaybe ≔ “”
  17. elseif sl[1]['lem'] ≟ “von” then:
  18. let $adpcase ≔ <abl>1. let $adpmaybe ≔ “”
  19. elseif sl[1]['lem'] ≟ “bis” then:
  20. let $adpcase ≔ <ill>1. let $adpmaybe ≔ “”
  21. elseif sl[1]['lem'] ≟ “als” then:
  22. let $adpcase ≔ <ess>1. let $adpmaybe ≔ “”
  23. elseif sl[1]['lem'] ≟ “mit” then:
  24. let $adpcase ≔ <ade>1. let $adpmaybe ≔ “”
  25. elseif sl[1]['lem'] ≟ “zu” then:
  26. let $adpcase ≔ <tra>1. let $adpmaybe ≔ “”
  27. elseif sl[1]['lem'] ≟ “an” then:
  28. let $adpcase ≔ <abl>1. let $adpmaybe ≔ “”
  29. elseif sl[1]['lem'] ≟ “nach” then:
  30. let $adpcase ≔ <ill>1. let $adpmaybe ≔ “”
  31. elseif sl[1]['lem'] ≟ “ohne” then:
  32. let $adpcase ≔ <abe>1. let $adpmaybe ≔ “”
  33. elseif sl[1]['lem'] ≟ “für” then:
  34. let $adpcase ≔ <all>1. let $adpmaybe ≔ “”
  35. else:
  36. let $adpcase ≔ <gen>1. let $adpmaybe ≔ tl[1]['whole']

compstuff-mangler

Parametres: 1

  1. if tl[1]['a_nominal'] ≟ <n.compound-only-L> then:
  2. let $compstuff ≔ “”
  3. elseif tl[1]['a_nominal'] ≟ <n.cmp> then:
  4. let $compstuff ≔ “”
  5. elseif tl[1]['lem'] ≟ “yksityis”tl[1]['lem'] ≟ “ulko”tl[1]['lem'] ≟ “vähimmäis”tl[1]['lem'] ≟ “yhteis”tl[1]['lem'] ≟ “lähi”tl[1]['lem'] ≟ “uudelleen” then:
  6. let $compstuff ≔ <compound-only-L>
  7. else:
  8. let $compstuff ≔ <sg.gen>

conneg-mangler

Parametres: 1

  1. if tl[1]['a_number'] ≟ <sg>tl[1]['a_tense'] ≟ <past> then:
  2. let $conpart ≔ <sg.conneg>
  3. elseif tl[1]['a_number'] ≟ <pl>tl[1]['a_tense'] ≟ <past> then:
  4. let $conpart ≔ <pl.conneg>
  5. elseif sl[1]['a_number'] ≟ <sg>sl[1]['a_tense'] ≟ <pii> then:
  6. let $conpart ≔ <sg.conneg>
  7. elseif sl[1]['a_number'] ≟ <pl>sl[1]['a_tense'] ≟ <pii> then:
  8. let $conpart ≔ <pl.conneg>
  9. elseif tl[1]['a_number'] ≟ <pl>tl[1]['a_tense'] ≟ <pri> then:
  10. let $conpart ≔ <conneg>
  11. elseif tl[1]['a_number'] ≟ <sg>tl[1]['a_tense'] ≟ <pri> then:
  12. let $conpart ≔ <conneg>
  13. else:
  14. let $conpart ≔ <conneg>

Rules

The actual rules concerning stuff.

directionlich2adjgen: German directions are pr for some reason but Finnish maybe adj.gen

Matching pattern:

  1. directionlich_pr

Action:

  1. Output:
  2. directionlich<ADJ.SG.GEN> 1. tl[1]['lem'] <adj.pos.sg.gen>

ex2np: totally broken deu analysis of ‘de’

Matching pattern:

  1. ex2np

Action:

  1. Output:
  2. ex2NP<NP.SG.NOM> 1. “ex”<n.sg.nom>

nochein2np: totally broken deu analysis of ‘de’

Matching pattern:

  1. nochein2np

Action:

  1. Output:
  2. nochein2NP<ADV> 1. “yhä”<adv>

soviele2np: totally broken deu analysis of ‘de’

Matching pattern:

  1. soviele2np

Action:

  1. Output:
  2. soviele2NP<NP.SG.NOM> 1. “yhtä”<adv> 1. blank1 1. “paljon”<adv>

desomalieren2np: totally broken deu analysis of ‘de’

Matching pattern:

  1. desomalieren2np

Action:

  1. Output:
  2. DESOMALIEREN2NP<NP.PL.NOM> 1. “somali”<n.pl.gen>

deadp2np: totally broken deu analysis of ‘de’

Matching pattern:

  1. deadp2np

Action:

  1. Output:
  2. DEADP2NP<NP.SG.NOM> 1. “de”<np.cog.sg.nom>

dest2np: St. mismatched

Matching pattern:

  1. dest2np

Action:

  1. Output:
  2. DEST2NP<NP.SG.NOM> 1. “St.”<np.sg.nom>

weder adj noch adj: negv adj cnjcoo+negv adj

Matching pattern:

  1. weder_cc
  2. adj
  3. noch_cc
  4. adj

Action:

  1. case-mangler($2)
  2. comparison-mangler($2)
  3. comparison-mangler($4)
  4. case-mangler($4)
  5. Output:
  6. AP<CC> 1. “ei”<vblex.neg.actv.p3.sg> 1. blank1 1. tl[2]['lem'] tl[2]['a_adj'] $comparison$number$case 1. blank2 1. “ei”<vblex.neg.actv.p3.sg>“+ka”<enc> 1. blank3 1. tl[4]['lem'] tl[4]['a_adj'] $comparison$number$case

seit ZEIT bevor: AIKOIHIN

Matching pattern:

  1. seit
  2. zeitwort
  3. bevor

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. Output:
  4. AdvP<ADV> 1. tl[2]['lem'] tl[2]['a_noun'] $number<ill>

seit ZEIT: AIKOIHIN

Matching pattern:

  1. seit
  2. zeitwort

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. Output:
  4. AdvP<ADV> 1. tl[2]['lem'] tl[2]['a_noun'] $number<ill>

über ZEIT hinweg: AJAN mittaan

Matching pattern:

  1. über
  2. zeitwort
  3. hinweg

Action:

  1. case-mangler($2)
  2. Output:
  3. AdvP<ADV> 1. tl[2]['lem'] tl[2]['a_noun'] $number<gen> 1. blank2 1. “mittaan”<adv>

nach INFORMATION: TIETOLÄHTEEN mukaan

Matching pattern:

  1. nach
  2. informationwort

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. Output:
  4. AdvP<ADV> 1. tl[2]['lem'] tl[2]['a_noun'] $number<gen> 1. blank1 1. “mukaan”<post>

um N.NN uhr: kello N.NN

Matching pattern:

  1. um
  2. num
  3. uhr

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. numtype-mangler($2)
  4. Output:
  5. UhrP<UHR> 1. tl[3]['lem'] tl[3]['a_nominal'] <sg.nom> 1. blank1 1. tl[2]['lem'] tl[2]['a_num'] $numtype$number$case

um leben gekommen: kuolla

Matching pattern:

  1. um
  2. det
  3. leben
  4. gekommen

Action:

  1. Output:
  2. VP<dead.becoming> 1. “kuolla”<vblex.actv.pp.pos.sg.nom>

gegen N.NN uhr: suunnilleen kello N.NN

Matching pattern:

  1. gegen
  2. num
  3. uhr

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. numtype-mangler($2)
  4. Output:
  5. UhrP<UHR> 1. “suunnilleen”<post> 1. blank1 1. tl[3]['lem'] tl[3]['a_nominal'] <sg.nom> 1. blank2 1. tl[2]['lem'] tl[2]['a_num'] $numtype$number$case

am NN. Monat: NN. kuuta

Matching pattern:

  1. an
  2. art
  3. daynumber
  4. monat

Action:

  1. case-mangler($3)
  2. number-mangler($3)
  3. numtype-mangler($3)
  4. Output:
  5. MonatP<MONAT> 1. tl[3]['lem'] tl[3]['a_num'] $numtype$number<ess> 1. blank1 1. tl[4]['lem'] tl[4]['a_nominal'] <sg.par>

am NN. Monat: NN. kuuta

Matching pattern:

  1. an
  2. dem
  3. daynumber
  4. monat

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. numtype-mangler($1)
  4. Output:
  5. MonatP<MONAT> 1. tl[2]['lem'] tl[2]['a_num'] $numtype$number<sg.ess> 1. blank2 1. tl[3]['lem'] tl[3]['a_nominal'] <sg.par>

NN. Monat: NN. kuuta

Matching pattern:

  1. daynumber
  2. monat

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. numtype-mangler($1)
  4. Output:
  5. MonatP<MONAT> 1. tl[1]['lem'] tl[1]['a_num'] $numtype$number$case 1. blank1 1. tl[2]['lem'] tl[2]['a_nominal'] <sg.par>

N.NN uhr: kello N.NN

Matching pattern:

  1. num
  2. uhr

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. numtype-mangler($1)
  4. Output:
  5. UhrP<UHR> 1. tl[2]['lem'] tl[2]['a_nominal'] <sg.nom> 1. blank1 1. tl[1]['lem'] tl[1]['a_num'] $numtype$number$case

wie geht es: how goes

Matching pattern:

  1. wie
  2. gehen
  3. es

Action:

  1. infinite-mangler($2)
  2. tensemood-mangler($2)
  3. Output:
  4. VP<V>`` 1. `tl[1]['lem']` `tl[1]['a_adv']` 1. `blank`1 1. "mennä"`tl[2]['a_verb']` ```$tense```

NP geht es: adessive goes

Matching pattern:

  1. nominal
  2. gehen
  3. es

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. infinite-mangler($2)
  4. tensemood-mangler($2)
  5. Output:
  6. VP<V>`` 1. `tl[1]['lem']` `tl[1]['a_nominal']` `$number``` 1. `blank`1 1. "mennä"`tl[2]['a_verb']` ```$tense```

ab NN: NN:sta alkaen

Matching pattern:

  1. ab
  2. num

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. numtype-mangler($2)
  4. Output:
  5. NumP<NUM>`` 1. `tl[2]['lem']` `tl[2]['a_num']` `$numtype``$number``` 1. `blank`1 1. "alkaen"``

bis NN: NN:ään asti

Matching pattern:

  1. bis
  2. num

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. numtype-mangler($2)
  4. Output:
  5. NumP<NUM>`` 1. `tl[2]['lem']` `tl[2]['a_num']` `$numtype``$number``` 1. `blank`1 1. "asti"``

adp nominal, nominal und nominal: drop case move case to last N of NP

Matching pattern:

  1. adp
  2. nominal
  3. comma
  4. nominal
  5. cnjcoo
  6. nominal

Action:

  1. adp-mangler($1)
  2. number-mangler($2)
  3. number-mangler($4)
  4. number-mangler($6)
  5. Output:
  6. NP<NP>$adpcase 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$number$adpcase 1. blank2 1. tl[3][‘whole’] 1. blank3 1. tl[4][‘lem’] tl[4][‘a_nominal’] $number$adpcase` 1. `blank`4 1. `tl[5]['whole']` 1. `blank`5 1. `tl[6]['lem']` `tl[6]['a_nominal']` `$number$adpcase 1. blank1 1. $adpmaybe`

adp nominal nominal nominal: drop case move case to last N of NP

Matching pattern:

  1. adp
  2. nominal
  3. nominal
  4. nominal

Action:

  1. adp-mangler($1)
  2. number-mangler($2)
  3. number-mangler($3)
  4. number-mangler($4)
  5. Output:
  6. NP<NP>$adpcase 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$number` 1. `blank`2 1. `tl[3]['lem']` `tl[3]['a_nominal']` `$number``` 1. `blank`3 1. `tl[4]['lem']` `tl[4]['a_nominal']` `$number``$adpcase` 1. `blank`1 1. `$adpmaybe`

adp det nouns propn: move case to first N of reformatted genitive NP

Matching pattern:

  1. adp
  2. det
  3. nominal
  4. np

Action:

  1. adp-mangler($1)
  2. case-mangler($2)
  3. case-mangler($3)
  4. case-mangler($4)
  5. Output:
  6. NP<NP>``$adpcase`` 1. `tl[4]['lem']` `tl[4]['a_nominal']` `tl[4]['a_number']` `` 1. `blank`1 1. `tl[3]['lem']` `tl[3]['a_nominal']` `tl[3]['a_number']` `$adpcase` 1. `blank`2 1. `$adpmaybe`

adp det nouns nouns: drop case, det, move case to last N of compound(?) NP

Matching pattern:

  1. adp
  2. det
  3. nominal
  4. nominal

Action:

  1. adp-mangler($1)
  2. case-mangler($2)
  3. case-mangler($3)
  4. case-mangler($4)
  5. Output:
  6. NP<NP>$adpcase`` 1. tl[3]['lem'] tl[3]['a_nominal'] tl[3]['a_number'] <nom> 1. blank2 1. tl[4]['lem'] tl[4]['a_nominal'] tl[4]['a_number'] $adpcase 1. blank1 1. $adpmaybe

adp det adj nouns: drop case, det, move case

Matching pattern:

  1. adp
  2. det
  3. adj
  4. nominal

Action:

  1. adp-mangler($1)
  2. case-mangler($2)
  3. case-mangler($3)
  4. case-mangler($4)
  5. comparison-mangler($3)
  6. Output:
  7. NP<NP>$adpcase 1. `tl[3]['lem']` `tl[3]['a_adj']` `$comparisontl[4][‘a_number’] $adpcase 1. blank1 1. tl[4][‘lem’] tl[4][‘a_nominal’] tl[4][‘a_number’] $adpcase 1. blank1 1. $adpmaybe`

adp cmp nominal: drop case move case to last N of NP

Matching pattern:

  1. adp
  2. cmp
  3. nominal

Action:

  1. adp-mangler($1)
  2. number-mangler($2)
  3. number-mangler($3)
  4. compstuff-mangler($2)
  5. Output:
  6. NP<NP>``$adpcase`` 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$compstuff`"+"`tl[3]['lem']` `tl[3]['a_nominal']` `$number``$adpcase` 1. `blank`1 1. `$adpmaybe`

adp nominal nominal: drop case move case to last N of NP

Matching pattern:

  1. adp
  2. nominal
  3. nominal

Action:

  1. adp-mangler($1)
  2. number-mangler($2)
  3. number-mangler($3)
  4. Output:
  5. NP<NP>$adpcase 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$number` 1. `blank`2 1. `tl[3]['lem']` `tl[3]['a_nominal']` `$number``$adpcase` 1. `blank`1 1. `$adpmaybe`

adp det nouns: drop case, det, move case

Matching pattern:

  1. adp
  2. det
  3. nominal

Action:

  1. adp-mangler($1)
  2. case-mangler($2)
  3. case-mangler($3)
  4. number-mangler($3)
  5. Output:
  6. NP<NP>$adpcase 1. `tl[3]['lem']` `tl[3]['a_nominal']` `$number$adpcase 1. blank1 1. $adpmaybe`

als adj noun: is essive

Matching pattern:

  1. als
  2. adj
  3. noun

Action:

  1. comparison-mangler($2)
  2. case-mangler($3)
  3. number-mangler($3)
  4. Output:
  5. NP<NP>`` 1. `tl[2]['lem']` `tl[2]['a_adj']` `$comparison``$number``` 1. `blank`2 1. `tl[3]['lem']` `tl[3]['a_noun']` `$number```

dets adjs nouns: share case and pl

Matching pattern:

  1. det
  2. adj
  3. nominal

Action:

  1. case-mangler($3)
  2. number-mangler($3)
  3. comparison-mangler($2)
  4. Output:
  5. NP<NP>$number$case 1. tl[2]['lem'] tl[2]['a_adj'] $comparison$number$case 1. blank2 1. tl[3]['lem'] tl[3]['a_noun'] $number$case

pps nouns: share case and pl

Matching pattern:

  1. participle
  2. nominal

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. Output:
  4. NP<NP>$number$case 1. tl[1]['lem'] tl[1]['a_verb'] <actv.pp.pos>$number$case 1. blank1 1. tl[2]['lem'] tl[2]['a_noun'] $number$case

adjs comp nouns: share case and pl

Matching pattern:

  1. adj
  2. cmp
  3. nominal

Action:

  1. compstuff-mangler($2)
  2. case-mangler($3)
  3. number-mangler($3)
  4. comparison-mangler($1)
  5. Output:
  6. NP<NP>$number$case 1. tl[1]['lem'] tl[1]['a_adj'] $comparison$number$case 1. blank1 1. tl[2]['lem'] tl[2]['a_nominal'] $compstuff”+”tl[3]['lem'] tl[3]['a_noun'] $number$case

adjs nouns: share case and pl

Matching pattern:

  1. adj
  2. nominal

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. comparison-mangler($1)
  4. Output:
  5. NP<NP>$number$case 1. tl[1]['lem'] tl[1]['a_adj'] $comparison$number$case 1. blank1 1. tl[2]['lem'] tl[2]['a_noun'] $number$case

nouns haver: adessive structurise!

Matching pattern:

  1. nominal
  2. haver

Action:

  1. case-mangler($1)
  2. tensemood-mangler($2)
  3. pers-mangler($2)
  4. Output:
  5. NP<N>`` 1. `tl[1]['lem']` `tl[1]['a_nominal']` `tl[1]['a_number']` `` 1. `blank` 1. `tl[2]['lem']` `tl[2]['a_verb']` ```$tense```

perfect verbs: re-order, and re-perfect

Matching pattern:

  1. perfection
  2. haver

Action:

  1. tensemood-mangler($2)
  2. number-mangler($2)
  3. pers-mangler($2)
  4. Output:
  5. VP<V>`` 1. "olla"`````$tense``$pers` 1. `blank` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```tl[1]['a_perf']` ```$number```

als noun: is essive

Matching pattern:

  1. als
  2. noun

Action:

  1. case-mangler($2)
  2. number-mangler($2)
  3. Output:
  4. NP<N>`` 1. `tl[2]['lem']` `tl[2]['a_noun']` `$number```

pp werden: passive construction, kill aux and passivise

Matching pattern:

  1. perfection
  2. werden

Action:

  1. infinite-mangler($1)
  2. tensemood-mangler($2)
  3. Output:
  4. VP<V>`` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```$tense```

aux verbs: re-order, and distribute, persons

Matching pattern:

  1. infinite
  2. auxiliary

Action:

  1. infinite-mangler($1)
  2. number-mangler($2)
  3. tensemood-mangler($2)
  4. pers-mangler($2)
  5. Output:
  6. VP<V>`` 1. `tl[2]['lem']` `tl[2]['a_verb']` ```$tense``$pers` 1. `blank` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```tl[1]['a_inf']` `$number``$case`

verb kein noun: en verb mikään noun

Matching pattern:

  1. verb
  2. kein
  3. noun

Action:

  1. conneg-mangler($1)
  2. tensemood-mangler($1)
  3. voice-mangler($1)
  4. pers-mangler($1)
  5. number-mangler($1)
  6. case-mangler($3)
  7. Output:
  8. VP<V>`` 1. "ei"```$pers` 1. `blank` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```$tense``$conpart` 1. `blank` 1. "mikään"```$number``` 1. `blank` 1. `tl[3]['lem']` `tl[3]['a_nominal']` `$number``$case`

verb neg pcp: ei oltu tehty

Matching pattern:

  1. verb
  2. verbnegation
  3. participle

Action:

  1. tensemood-mangler($1)
  2. voice-mangler($1)
  3. pers-mangler($1)
  4. number-mangler($1)
  5. case-mangler($3)
  6. Output:
  7. VP<V>`` 1. "ei"```$pers` 1. `blank` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```$tense``` 1. `blank` 1. `tl[3]['lem']` `tl[3]['a_verb']` ```$number``$case`

verb negs: to neg conneg

Matching pattern:

  1. verb
  2. verbnegation

Action:

  1. tensemood-mangler($1)
  2. pers-mangler($1)
  3. conneg-mangler($1)
  4. Output:
  5. VP<V>`` 1. "ei"```$pers` 1. `blank` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```$tense``$conpart`

neg verbs: to neg conneg

Matching pattern:

  1. verbnegation
  2. verb

Action:

  1. tensemood-mangler($2)
  2. pers-mangler($2)
  3. conneg-mangler($2)
  4. Output:
  5. VP<V>`` 1. "ei"```$pers` 1. `blank` 1. `tl[2]['lem']` `tl[2]['a_verb']` ```$tense``$conpart`

dets compnouns: case mangle

Matching pattern:

  1. det
  2. cmp
  3. noun

Action:

  1. case-mangler($1)
  2. case-mangler($2)
  3. case-mangler($3)
  4. compstuff-mangler($2)
  5. Output:
  6. NP<N>`` 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$compstuff`"+"`tl[3]['lem']` `tl[3]['a_noun']` `tl[3]['a_number']` `$case`

adp prndem propn: deu fail~prndem is actually det

Matching pattern:

  1. adp
  2. prndem
  3. np

Action:

  1. adp-mangler($1)
  2. case-mangler($2)
  3. case-mangler($3)
  4. number-mangler($3)
  5. Output:
  6. NP<N>$number$case 1. tl[3]['lem'] tl[3]['a_noun'] $number$adpcase 1. blank1 1. $adpmaybe

prndem propn: deu fail~prndem is actually det

Matching pattern:

  1. prndem
  2. np

Action:

  1. case-mangler($1)
  2. case-mangler($2)
  3. number-mangler($2)
  4. Output:
  5. NP<N>$number$case 1. tl[2]['lem'] tl[2]['a_noun'] $number$case

dets nouns: case mangle

Matching pattern:

  1. det
  2. noun

Action:

  1. case-mangler($1)
  2. case-mangler($2)
  3. number-mangler($2)
  4. Output:
  5. NP<N>$number$case 1. tl[2]['lem'] tl[2]['a_noun'] $number$case

prn pers: case mangle and drop mfs

Matching pattern:

  1. prnpers

Action:

  1. case-mangler($1)
  2. Output:
  3. PRNP<PRN> 1. tl[1]['lem'] tl[1]['a_prn'] tl[1]['a_number'] tl[1]['a_case']

adp nominal und nominal: drop case distribute case

Matching pattern:

  1. adp
  2. nominal
  3. cnjcoo
  4. nominal

Action:

  1. adp-mangler($1)
  2. number-mangler($2)
  3. Output:
  4. NP<NP>$adpcase 1. `$adpmaybe` 1. `blank`1 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$number$adpcase 1. blank2 1. tl[3][‘whole’] 1. blank3 1. tl[4][‘lem’] tl[4][‘a_nominal’] $number``$adpcase`

adp nominal: drop case move case

Matching pattern:

  1. adp
  2. nominal

Action:

  1. adp-mangler($1)
  2. number-mangler($2)
  3. Output:
  4. NP<NP>$adpcase 1. `$adpmaybe` 1. `blank`1 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$number$adpcase`

possess nominals: possessive suffix

Matching pattern:

  1. poss
  2. nominal

Action:

  1. possessive-mangler($1)
  2. number-mangler($2)
  3. case-mangler($2)
  4. Output:
  5. NP<N>`` 1. `$prnmaybe` 1. `blank`1 1. `tl[2]['lem']` `tl[2]['a_nominal']` `$number``$case``$possess`

numeral multiplier plural: partitive or stuff

Matching pattern:

  1. cardinal
  2. multiplier
  3. plural

Action:

  1. numtype-mangler($1)
  2. Output:
  3. MeasureP<CountXP> 1. tl[1]['lem'] tl[1]['a_num'] <card.sg.nom> 1. blank1 1. tl[2]['lem'] <num.card.sg.par> 1. blank2 1. tl[3]['lem'] tl[3]['a_noun'] <sg.par>

numeral plural: partitive or stuff

Matching pattern:

  1. cardinal
  2. plural

Action:

  1. numtype-mangler($1)
  2. Output:
  3. MeasureP<CountP> 1. tl[1]['lem'] tl[1]['a_num'] $numtype<sg.nom> 1. blank1 1. tl[2]['lem'] tl[2]['a_noun'] <sg.par>

adp numeral: add case and number

Matching pattern:

  1. adp
  2. num

Action:

  1. adp-mangler($1)
  2. numtype-mangler($2)
  3. Output:
  4. NumP<NumP>$adpcase 1. `$adpmaybe` 1. `blank`1 1. `tl[2]['lem']` `tl[2]['a_num']` `$numtype``$adpcase`

noun compounds: recompound

Matching pattern:

  1. cmp
  2. cmp
  3. noun

Action:

  1. case-mangler($3)
  2. Output:
  3. N<N.CMP> 1. tl[1]['lem'] tl[1]['a_nominal'] tl[1]['a_number'] <gen> 1. tl[2]['lem'] tl[2]['a_nominal'] tl[2]['a_number'] <gen> 1. tl[3]['lem'] tl[3]['a_noun'] tl[3]['a_number'] $case

noun compounds: recompound

Matching pattern:

  1. cmp
  2. noun

Action:

  1. compstuff-mangler($1)
  2. case-mangler($2)
  3. Output:
  4. N<N.CMP> 1. tl[1]['lem'] tl[1]['a_nominal'] $compstuff”+”tl[2]['lem'] tl[2]['a_noun'] tl[2]['a_number'] $case

comps: stray compounds :-(((

Matching pattern:

  1. cmp

Action:

  1. Output:
  2. NP<CMP> 1. tl[1]['lem'] “-“<compound-only-L>

nouns: case mangle

Matching pattern:

  1. noun

Action:

  1. case-mangler($1)
  2. Output:
  3. NP<N.FOOFOO> 1. tl[1]['lem'] tl[1]['a_noun'] tl[1]['a_number'] $case

abbrs to nouns: case mangle

Matching pattern:

  1. abbr

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. Output:
  4. NP<N.ABBR> 1. tl[1]['lem'] tl[1]['a_noun'] $number$case

adjs: add case

Matching pattern:

  1. adj

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. comparison-mangler($1)
  4. Output:
  5. AP<A> 1. tl[1]['lem'] tl[1]['a_adj'] $comparison$number<nom>

prns: case mangle, determine number

Matching pattern:

  1. prn

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. Output:
  4. PrnP<PRN> 1. tl[1]['lem'] tl[1]['a_prn'] $number$case

nums: add case, drop pl to sg

Matching pattern:

  1. num

Action:

  1. numtype-mangler($1)
  2. Output:
  3. NumP<Num> 1. tl[1]['lem'] tl[1]['a_num'] $numtype<sg.nom>

adps: drop case

Matching pattern:

  1. adp

Action:

  1. Output:
  2. AdpP<Adp>sl[1][‘a_case’] 1. tl[1]['lem'] tl[1]['a_adp']

stray negs: just say no

Matching pattern:

  1. verbnegation

Action:

  1. Output:
  2. VP<V>`` 1. "ei"``

stray possessives: ugly genitives

Matching pattern:

  1. poss

Action:

  1. Output:
  2. PossP<Poss> 1. tl[1]['lem'] tl[1]['a_prn'] tl[1]['a_number'] <gen>

stranded articles: don’t want

Matching pattern:

  1. art

Action:

  1. Output:
  2. ArtP<ART> 1. blank

stranded dets: just show them

Matching pattern:

  1. det

Action:

  1. case-mangler($1)
  2. number-mangler($1)
  3. Output:
  4. DetP<Det> 1. tl[1]['lem'] tl[1]['a_det'] $number$case 1. blank1

lost perfect verbs: maybe predicative adj

Matching pattern:

  1. perfection

Action:

  1. tensemood-mangler($1)
  2. Output:
  3. VP<V>`` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```tl[1]['a_perf']` ``

lonely infinitive: map infs and gers

Matching pattern:

  1. infinite

Action:

  1. infinite-mangler($1)
  2. number-mangler($1)
  3. Output:
  4. VP<V>`` 1. `tl[1]['lem']` `tl[1]['a_verb']` ```tl[1]['a_inf']` `$number``$case`

verbs: add activ passif, change past tags

Matching pattern:

  1. verb

Action:

  1. tensemood-mangler($1)
  2. pers-mangler($1)
  3. Output:
  4. VP<V> 1. tl[1]['lem'] tl[1]['a_verb'] <actv>$tense$pers

REGLA: SENT

Matching pattern:

  1. sent

Action:

  1. Output:
  2. sent<SENT> 1. tl[1]['whole']

Documentation for apertium-fin-deu. Generated with Flammie’s apevis-xslt.