apertium-fin-eng

Finnish–English dictionary for rule-based machine translation

Project maintained by apertium Hosted on GitHub Pages – Theme by mattgraham

Apertium-fin-eng: Finnish–English machine translation rules

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
nominal	`<n.>` `<np.>` `<prn.*>`
nom	`<n.>` `<np.>`
poss	`<det.pos.*>`
prn	`<prn.*>`
num	`<num.*>` `<num>`
will	will`<vblex.>` will`<vbmod.>`
be	be`<vbser.*>`
have	`<vbhaver.*>`
fverb	`<vaux.past>` `<vaux.past.>` `<vaux.pres>` `<vaux.pres.>` `<vbdo.past>` `<vbdo.past.>` `<vbdo.pres>` `<vbdo.pres.>` `<vbhaver.past>` `<vbhaver.past.>` `<vbhaver.pres>` `<vbhaver.pres.>` `<vblex.imp>` `<vblex.past>` `<vblex.past.>` `<vblex.pres>` `<vblex.pres.>` `<vbmod.past>` `<vbmod.past.>` `<vbmod.pres>` `<vbmod.pres.>` `<vbser.past>` `<vbser.past.>` `<vbser.pres.>` `<vbser.pres>`
modverb	`<vbmod.*>`
notverb	`<vaux.>` `<vbmod.>` `<vbser.*>`
isverb	`<vbser.>` be`<vaux.>`
doverb	`<vbdo.>` do`<vaux.>`
sg3stuff	`<np.sg>` `<np..sg>` `<n.sg>` `<np.sg.>` `<np..sg.>` `<n.sg.*>`
pcp	`<vblex.pprs>` `<vbser.pprs>` `<vaux.pprs>` `<vbmod.pprs>` `<vbhaver.pprs>` `<vbdo.pprs>` `<vblex.pp>` `<vbser.pp>` `<vaux.pp>` `<vbmod.pp>` `<vbhaver.pp>` `<vbdo.pp>`
subsverb	`<vblex.subs>` `<vbser.subs>` `<vaux.subs>` `<vbmod.subs>` `<vbhaver.subs>` `<vbdo.subs>`
infverb	`<vblex.inf>` `<vbser.inf>` `<vaux.inf>` `<vbmod.inf>` `<vbhaver.inf>` `<vbdo.inf>`
noun	`<n.>` `<np.>`
adj	`<adj>` `<adj.*>`
det	`<det>` `<det.*>`
prnprs	prpers`<prn.*>`
prnprs-3	prpers`<prn.subj.p3.*>`
prnprs-non3	prpers`<prn.subj.p1.>` prpers`<prn.subj.p2.>`
sent	`<sent>`
to	to`<pr>`
inf	`<vblex.inf>`
ger	`<vblex.ger>`
pr	`<pr>` `<post>`
notadv	not`<adv>` n't`<adv>` not`<adv.>` n't`<adv.>`
gen	's`<gen>` '`<gen>`
on	on`<pr>` on`<adv>`
day	`<num.*>` `<num>`
month	`<num.>` `<num>` January`<n.>` February`<n.>` february`<n.>` March`<n.>` April`<n.>` May`<n.>` June`<n.>` July`<n.>` August`<n.>` October`<n.>` November`<n.>` October`<n.>` November`<n.>` December`<n.*>`
year	`<num.*>` `<num>`

Attributes

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

Attribute set name	Tags
nominaltype	`<prn>` `<n>` `<n.abbr>` `<np.ant.m>` `<np.ant.f>` `<np.cog>` `<np.al>` `<np.al.acr>` `<np.top>` `<np.geo>` `<np>`
a_numtype	`<num.card>` `<num.ord>` `<num>`
a_det	`<det>` `<prn>` `<prn.dem>`
a_adj	`<adj>`
a_comp	`<pos>` `<com>` `<sup>`
a_num	`<sg>` `<pl>`
a_cas	`<nom>` `<acc>` `<dat>` `<gen>` `<loc>` `<ins>` `<abl>`
a_verb	`<vaux>` `<vaux.actv>` `<vaux.pass>` `<vblex>` `<vblex.actv>` `<vblex.pass>` `<vbhaver>` `<vbhaver.actv>` `<vbhaver.pass>`
a_tens	`<cni>` `<pri>` `<pres>` `<past>`
a_pers	`<p1>` `<p2>` `<p3>`

Macros

Macros are helper functions in apertium transfer files.

compare

Parametres: 1


               
                  
                  
                     let 
                     $comparison ≔ <pos>
                  
                  
                  
                     
                        
                        if 
                           

                              
                                 sl[1]['a_comp'] ≟ <comp>
                                 
                              
                            then:
                           
                              
                                 let tl[1]['a_comp'] ≔ <comp>
                              
                              
                                 let 
                                 $comparison ≔ <com>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 sl[1]['a_comp'] ≟ <sup>
                                 
                              
                            then:
                           
                              
                                 let tl[1]['a_comp'] ≔ <sup>
                              
                              
                                 let 
                                 $comparison ≔ <sup>
                              
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $comparison ≔ <pos>

possmangler1

Parametres: 1


               
                  
                  
                     let 
                     $possession ≔ <pxsp3>
                  
                  
                  
                     
                        
                        if 
                           

                              
                                 
                                 sl[1]['a_num'] ≟ <sg>
                                 
                                 
                                 sl[1]['a_pers'] ≟ <p1>
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsg1>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['a_num'] ≟ <sg>
                                 
                                 
                                 sl[1]['a_pers'] ≟ <p2>
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsg2>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['a_pers'] ≟ <p3>
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsp3>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['a_num'] ≟ <pl>
                                 
                                 
                                 sl[1]['a_pers'] ≟ <p2>
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxpl2>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['a_num'] ≟ <pl>
                                 
                                 
                                 sl[1]['a_pers'] ≟ <p1>
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxpl1>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "my"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsg1>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "your"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsg2>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "his"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsp3>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "her"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsp3>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "our"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxpl1>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "their"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $possession ≔ <pxsp3>
                              
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $possession ≔ <pxsp3>

test

Parametres: 1

tensemangle1

Parametres: 1


               
                  
                  
                     let 
                     $conneg ≔ <conneg>
                  
                  
                  
                     
                        
                        if 
                           

                              
                                 sl[1]['a_tens'] ≟ <pres>
                                 
                              
                            then:
                           
                              
                                 let 
                                 $tense ≔ <pri>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 sl[1]['a_tens'] ≟ <cni>
                                 
                              
                            then:
                           
                              
                                 let 
                                 $tense ≔ <pri>
                              
                           
                        
                        
                        elseif 
                           

                              
                                 sl[1]['a_tens'] ≟ <past>
                                 
                              
                            then:
                           
                              
                                 let 
                                 $tense ≔ <past>
                              
                              
                                 let 
                                 $conneg ≔ 
                                 <sg.conneg>
                                 
                              
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $tense ≔ <pri>

personmangle1

Parametres: 1


               
                  
                  
                     
                        
                        if 
                           

                              
                                 
                                 sl[1]['a_pers'] ≟ 
                                    ""
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $pers ≔ sl[1]['a_pers']
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $pers ≔ <p3>
                              
                              
                           
                        
                        
                     
                  
                  
                  
                     
                        
                        if 
                           

                              
                                 
                                 sl[1]['a_num'] ≟ 
                                    ""
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $persnum ≔ sl[1]['a_num']
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $persnum ≔ <sg>

artmangle1

Parametres: 1


               
                  
                  
                     
                        
                        if 
                           

                              
                                 
                                 sl[1]['lem'] ≟ 
                                    "the"
                                    
                                 
                                 
                                 sl[1]['lem'] ≟ 
                                    "a"
                                    
                                 
                                 
                                 sl[1]['lem'] ≟ 
                                    "The"
                                    
                                 
                                 
                                 sl[1]['lem'] ≟ 
                                    "A"
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $determiner ≔ 
                                 ""
                                 
                              
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $determiner ≔ tl[1]['whole']
                                 <2>

numbermangle1

Parametres: 1


               
                  
                  
                     
                        
                        if 
                           

                              
                                 
                                 sl[1]['a_num'] ≟ 
                                    ""
                                    
                                 
                                 
                              
                            then:
                           
                              
                                 let 
                                 $number ≔ sl[1]['a_num']
                           
                        
                        
                        else:
                           
                              
                              
                                 let 
                                 $number ≔ <sg>

Rules

The actual rules concerning stuff.

on day month year -> day+ess month+par year

Matching pattern:

on
day
month
year

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[2]['lem'] 
                                 tl[2]['a_numtype'] 
                                 <sg.ess>
                                 
                              
                              _b

                              
                                 tl[3]['lem'] 
                                 tl[3]['nominaltype'] 
                                 <sg.par>
                                 
                              
                              _b

                              
                                 tl[4]['lem'] 
                                 tl[4]['a_numtype'] 
                                 <sg.nom>
                                 
                              
                           
]_{date
                              <AdvP>}

will be pcp ->

Matching pattern:

will
be
fverb

Action:


               
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  personmangle1(
                     $2
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[3]['lem'] 
                                 tl[3]['a_verb'] 
                                 <pasv.pot.impers>
                                 
                              
                           
]_{futverb
                              <VP>}

PRN-PRS-3 MOD NOT V -> prnpres negv mod infa

Matching pattern:

prnprs-3
modverb
notadv
infverb

Action:


               
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['whole']
                                 
                              
                              _b1

                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b2

                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                              _b3

                              
                                 tl[4]['lem']
                                 tl[4]['a_verb'] 
                                 <actv.infa.sg.lat>
                                 
                              
                           
]_{subjverb
                              <VP.NEG>
                              
                              $pers
                              
                              $persnum}

PRN-PRS-12 MOD NOT V -> negv mod infa

Matching pattern:

prnprs-non3
modverb
notadv
infverb

Action:


               
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b2

                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                              _b3

                              
                                 tl[4]['lem']
                                 tl[4]['a_verb'] 
                                 <actv.infa.sg.lat>
                                 
                              
                           
]_{subjverb
                              <VP.NEG>
                              
                              $pers
                              
                              $persnum}

3SG-stuff VAUX NOT V -> stuff ei voi

Matching pattern:

sg3stuff
notverb
notadv
infverb

Action:


               
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  personmangle1(
                     $2
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem']
                                 tl[1]['nominaltype']
                                 tl[1]['a_num']
                                 <nom>
                                 
                              
                              _b1

                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b2

                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                              _b3

                              
                                 tl[4]['lem']
                                 tl[4]['a_verb'] 
                                 <actv.infa.sg.lat>
                                 
                              
                           
]_{subjverb
                              <VP.NEG>}

is not -> ei ole

Matching pattern:

isverb
notadv

Action:


               
                  
                  tensemangle1(
                     $1 
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b1

                              
                                 tl[1]['lem']
                                 tl[1]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                           
]_{subjverb
                              <VP.NEG>
                              
                              $pers
                              
                              $persnum}

PRNPRS-3 DO NOT V -> EI V

Matching pattern:

prnprs-3
doverb
notadv
infverb

Action:


               
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['whole']
                                 
                              
                              _b1

                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b2

                              
                                 tl[4]['lem']
                                 tl[4]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                           
]_{subjverb
                              <VP.NEG>
                              
                              $pers
                              
                              $persnum}

PRNPRS-3 DO NOT V -> EI V

Matching pattern:

prnprs-non3
doverb
notadv
infverb

Action:


               
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b2

                              
                                 tl[4]['lem']
                                 tl[4]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                           
]_{subjverb
                              <VP.NEG>}

DO NOT V -> EI V

Matching pattern:

doverb
notadv
infverb

Action:


               
                  
                  tensemangle1(
                     $1 
                     )
                  
                  
                  personmangle1(
                     $2
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                  
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b2

                              
                                 tl[3]['lem']
                                 tl[3]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $conneg
                                 
                              
                           
]_{subjverb
                              <VP>
                              
                              $pers
                              
                              $persnum}

prnprs have not pcp -> ei+prs ole pcp

Matching pattern:

prnprs
have
notadv
pcp

Action:


               
                  
                  personmangle1(
                     $1 
                     )
                  
                  
                  tensemangle1(
                     $2 
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                 
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b1

                              
                                 
                                 "olla"
                                 
                                 <vaux.actv.pri.conneg>
                                 
                              
                              _b2

                              
                                 tl[4]['lem'] 
                                 tl[4]['a_verb'] 
                                 <actv.pp.pos>
                                 tl[1]['a_num']
                                 <nom> 
                                 
                              
                           
]_{pcp
                              <V.NEG.PTCP>}

have not pcp -> ei ole pcp

Matching pattern:

have
notadv
pcp

Action:


               
                  
                  personmangle1(
                     $1 
                     )
                  
                  
                  tensemangle1(
                     $1 
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                 
                                 <vblex.neg.actv>
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b1

                              
                                 
                                 "olla"
                                 
                                 <vaux.actv.pri.conneg>
                                 
                              
                              _b2

                              
                                 tl[3]['lem'] 
                                 tl[3]['a_verb'] 
                                 <actv.pp.pos.sg.nom> 
                                 
                              
                           
]_{pcp
                              <V.NEG.PTCP>}

have pcp -> on pcp

Matching pattern:

have
pcp

Action:


               
                  
                  personmangle1(
                     $1 
                     )
                  
                  
                  tensemangle1(
                     $1 
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <actv> 
                                 
                                 $tense 
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv.pp.pos.sg.nom> 
                                 
                              
                           
]_{pcp
                              <V.PTCP>}

nominal have → adessive copula

Matching pattern:

nominal
have

Action:


               
                  
                  tensemangle1(
                     $2
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['nominaltype'] 
                                 tl[1]['a_num'] 
                                 <ade>
                                 
                              
                              _b1

                              
                                 
                                 "olla"
                                 
                                 <vaux.actv>
                                 
                                 $tense 
                                 <p3.sg>
                                 
                              
                           
]_{subjverb
                              <VP.HAVE>}

personal pronoun verb: pro-drop non-3sg, use personal form

Matching pattern:

prnprs-non3
fverb

Action:


               
                  
                  tensemangle1(
                     $2
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                           
]_{subjverb
                              <VP>}

personal pronoun verb p3: no droppings, use personal form

Matching pattern:

prnprs-3
fverb

Action:


               
                  
                  tensemangle1(
                     $2
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['whole'] 
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                           
]_{subjverb
                              <VP>}

SäÄntö: to V-inf

Matching pattern:

to
infverb

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[2]['lem'] 
                                 tl[2]['a_verb'] 
                                 <actv>
                                 <infa> 
                                 <sg> 
                                 <lat> 
                                 
                              
                           
]_{subjverb
                              <V-INF>}

num a n -> spread par

Matching pattern:

num
adj
noun

Action:


               
                  
                  comparison(
                     $2
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_numtype'] 
                                 <sg.nom> 
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['a_adj'] 
                                 
                                 $comparison
                                 tl[3]['a_num'] 
                                 <par>
                                 
                              
                              _b2

                              
                                 tl[3]['lem'] 
                                 tl[3]['nominaltype'] 
                                 tl[3]['a_num'] 
                                 <par>
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

det a n -> spread number

Matching pattern:

det
adj
noun

Action:


               
                  
                  comparison(
                     $2
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 tl[2]['lem'] 
                                 tl[2]['a_adj'] 
                                 
                                 $comparison
                                 tl[3]['a_num'] 
                                 <2>
                                 
                              
                              _b2

                              
                                 tl[3]['lem'] 
                                 tl[3]['nominaltype'] 
                                 tl[3]['a_num'] 
                                 <2>
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

a n -> spread number

Matching pattern:

adj
noun

Action:


               
                  
                  comparison(
                     $2
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_adj'] 
                                 
                                 $comparison
                                 tl[2]['a_num'] 
                                 <2>
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['nominaltype'] 
                                 tl[2]['a_num'] 
                                 <2>
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

num: add sg par

Matching pattern:

num
noun

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_numtype'] 
                                 <sg.nom> 
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['nominaltype'] 
                                 tl[2]['a_num'] 
                                 <par>
                                 
                              
                           
]_{NP
                              <NP>
                              <CD>}

SäÄntö: poss n

Matching pattern:

poss
noun

Action:


               
                  
                  possmangler1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_det'] 
                                 tl[1]['a_num'] 
                                 <gen>
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['nominaltype'] 
                                 tl[2]['a_num'] 
                                 <2>
                                 
                                 $possession
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

SäÄntö: det n

Matching pattern:

det
noun

Action:


               
                  
                  artmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 $determiner
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['nominaltype'] 
                                 tl[2]['a_num'] 
                                 <2>
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

stray have: add spaces just in case because 've is analysed as have

Matching pattern:

have

Action:


               
                  
                  tensemangle1(
                     $1
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              _b0

                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                           
]_{have
                              <V.HAVE>}

SäÄntö: V

Matching pattern:

fverb

Action:


               
                  
                  tensemangle1(
                     $1
                     )
                  
                  
                  personmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <actv>
                                 
                                 $tense 
                                 
                                 $pers
                                 
                                 $persnum
                                 
                              
                           
]_{unkv
                              <V>}

SäÄntö: V-inf

Matching pattern:

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <actv.infa.sg.lat> 
                                 
                              
                           
]_{inf
                              <V-INF>}

pcp

Matching pattern:

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <pasv.pp.pos.sg.nom> 
                                 
                              
                           
]_{pcp
                              <V>}

vbsubs -> infminen

Matching pattern:

subsverb

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <infminen> 
                                 
                              
                           
]_{vbsubs
                              <V-SUBS>}

gerund -> infma ssa

Matching pattern:

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <actv.infma.sg.ine> 
                                 
                                 
                              
                           
]_{ger
                              <V-INF>}

num: add sg noms

Matching pattern:

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_numtype'] 
                                 <sg.nom> 
                                 
                              
                           
]_{num
                              <NumP>
                              <CD>}

det n's -> n+gen

Matching pattern:

det
noun
gen

Action:


               
                  
                  artmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 $determiner
                                 
                              
                              _b1

                              
                                 tl[2]['lem'] 
                                 tl[2]['nominaltype'] 
                                 tl[2]['a_num'] 
                                 <gen>
                                 
                              
                           
]_{np
                              <NP.GEN>}

n's -> n+gen

Matching pattern:

noun
gen

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['nominaltype'] 
                                 tl[1]['a_num'] 
                                 <gen>
                                 
                              
                           
]_{np
                              <NP.GEN>}

SäÄntö: n

Matching pattern:

noun

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['nominaltype'] 
                                 tl[1]['a_num'] 
                                 <2>
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

SäÄntö: a is so lonely

Matching pattern:

Action:


               
                  
                  comparison(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 tl[1]['lem'] 
                                 tl[1]['a_adj'] 
                                 
                                 $comparison
                                 <sg.nom>
                                 
                              
                           
]_{ap
                              <AP>
                              <CD>}

Säätö: prn

Matching pattern:

Action:


               
                  
                  numbermangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['nominaltype'] 
                                 
                                 $number 
                                 <2>
                                 
                              
                           
]_{np
                              <NP>
                              <CD>}

Säätö: pr

Matching pattern:

Action:


               
                  
                  
                     let 
                     $prep-lema ≔ sl[1]['lem']
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['whole']
                                 
                              
                           
]_<PR>

lone det removals

Matching pattern:

Action:


               
                  
                  artmangle1(
                     $1
                     )
                  
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 $determiner
                                 
                              
                           
]_{unkdet
                              <DET>}

stray inf to infa, what cna you do

Matching pattern:

infverb

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['lem'] 
                                 tl[1]['a_verb'] 
                                 <actv>
                                 <infa> 
                                 <sg> 
                                 <lat> 
                                 
                              
                           
]_{verb
                              <V-INF>}

Säätö: stray negation

Matching pattern:

notadv

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 
                                 "ei"
                                 
                                 <vaux.neg.actv.p3.sg>
                                 
                              
                           
]_{unkneg
                              <NEG>}

REGLA: SENT

Matching pattern:

sent

Action:


               
                  
                  Output: 
                     
                        
                        
                           [
                           
                              
                                 tl[1]['whole']
                                 
                              
                           
]_{sent
                              <SENT>}