Kapittel 3

xfst
====
xfst er eit program som gjer det mogleg å utføre operasjonar på endelege tilstandsautomatar (union, konkatenasjon, iterasjon, interseksjon)

det er også mogleg å utføre analyse ("up") og genererering "down)

vi kan skrive ut heile nettverket ("print words"


Kommandoar for å starte og avslutte xfst
========================================
xfst			startar programmet
xfst -utf8		startar programmet med utf-8 som teiknsett
ctrl-d			avslutt programmet
exit			avslutt programmet
quit			avslutt programmet


Hjelpekommandoar i xfst:
========================
help		hjelp (liste over alle kommandoane
help help	om hjelpefunksjonen
apropos net	alle funksjonane som har med nett å gjere


to måtar å definere regulære uttrykk:
=====================================
define variable regular-expression ;
read regex regular-expression ;

define MinVar [ h u n d | k a t t | h e s t ] ;
define EinTil [ h u n d | u l v ] ;

read regex [ t o r s k | s e i | h y s e ] ;
print words
words
up torsk
up sild

read regex MinVar ;
union
words


Nettverk
========

clear stack
clear
regex a ;
regex "+N" ;
regex %+A ;
regex +V ;

regex a+ ;

up a
up aaaa
up aaab

regex a* ;
up
up a
up aaa

regex ? ;
up a
up b
up å

regex ?* ;
up ioueghipg


regex [l o o k] [i n g] ;
regex [l o o k] [i n g | s ] ;
words


regex [ dog | cat | rat | elephant | pig ] & [ cat | aardvark | pig ] ;
words

regex ~[c a t];
up cat
up cats
up øasdhjfg


3.2.4. Operasjonar på stakken
=============================

LIFO-stakk: last in, first out.

regex a;
regex {cat};
regex [{dog} | {cat} | {elephant} ] ;
words
stack


define utkast [u t | i n n] [ k a s t | h o p p ] [ e t | i n g ( a ) | 0 ] ;  
sigma
net utkast
words utkast



3.2.5 Regulære uttrykk for relasjonar
=====================================

define A {koira};
define B {beana};
regex A .x. B ;


read regex [ 
[ d o g .x. c h i e n ] | 
[ c a t .x. c h a t ] |
[ w o m a n .x. f e m m e ] |
[ m a n .x. h o m m e ] ] ;

regex [{gahpir}
|{gahpira}
|{gahpiran}
|{gahpiras}
|{gahpirat}];


read regex [ s w i:a m | s w i m ] ;
up swim 
up swam
down swim
down swam


define hund [ [ d o g .x. c h i e n ] | [ c a t .x. c h a t ] ] ;
read regex hund ;
words
read regex hund.u ;
words
pop stack
read regex [hund.i].u ;
words
(Poeng: sjå skilnaden mellom upper og inverted upper)

clear
regex [hund.l].r;
words


3.3 Kommunikasjon med operasjonssystemet
========================================

lag ei fil 3.4.regex av det som står mellom strekane:
-----------------------------------------------------------------
! Dette er ei demonstrasjonsfil
! Strekane over og under skal ikkje vere med, dei fortel berre
! at arket startar og sluttar der.
! Utropsteiknet er kommentarteikn.
( r e )                                    ! prefiks
[ l o c k | c o r k | m a r k | p a r k ]  ! rot
[ i n g | e d | s | 0 ] ;                  ! suffiks
------------------------------------------------------------------

xfst -utf8
regex < 3.4.regex
words
save 3.4.fst
clear
words
load 3.4.fst
words



3.6.ord
---------
aardvark
apple
avatar
binary
boy
bucolic
cat
coriander
cyclops
day
----------

3.8.regex
----------
{aardvark}  |
{apple}	    |
{avatar}    |
{binary}    |
{boy}	    |
{bucolic}   |
{cat}	    |
{coriander} |
{cyclops}   |
{day}	    ;
-----------



read regex [ [ d o g %+Noun %+Sg .x. d o g ] | [ d o g %+Noun %+Pl .x. d o g s ] ] ;

read regex [ 
[ d o g %+Noun %+Sg .x. d o g ] 
| 
[ d o g %+Noun %+Pl .x. d o g s ] 
] ;


read regex a:b;   
save ab.fst 
read regex c:d;        
save cd.fst                       
clear
read regex @"ab.fst" | @"cd.fst" ;
upper
lower




3.3.3. scriptfiler i xfst
=========================



Skilnaden mellom scriptfiler of regex-filer er at regex-filene berre inneheld eit regulært uttrykk, mens scriptfiler kan innehalde fleire kommandoar, både regulære uttryk, operasjonar og definisjonar.

fil.regex      = regex-fil
fil.script     = script-fil
fil.xfst

$ symbol for prompten i unix lene$
> symbol for at du står i xfst

$ xfst -utf8
> source script.xfst

utføre, bli ute
$ xfst -utf8 -f script.xfst 
$

gå inn
$ xfst -utf8
>

utføre og gå inn
$ xfst -utf8 -l script.xfst
>



sciptfiler inneheld kommandoen
echo

som er fin til å fortelje kva som skjer, og kor langt programmet har komme.

Forklare dette scriptet:

echo *** Script to build lt.fst ***
clear stack
echo << Creating the lexicon FST >>
read regex < lex.regex
define LEX
echo << Creating the rule FST >>
read regex < rul.regex
define RUL
echo << Creating the lexical transducer >>
read regex LEX .o. RUL ;
save stack lt.fst
echo << Output written to binary file lt.fst >>
echo << End of Script >>

a:b .o. b:c
a:c

a biila+N+Sg+Gen
b bij'laX4

b bij'laX4
c biilla


3.4. Aukande prosessering av nettverk
=====================================
xfst -utf8

define FEE [ a | b | c | d ] ;
define FIE [ d | e | f | g ] ;
define FOO [ f | g | h | i | j ] ;


words FEE
net FEE

define mylang1 FEE & FIE ;
words mylang1

define pref [{un}|{re}];
def rot [{lock}|{cork}];
def suf [{ing}|{ed}|s|0];
regex  pref rot suf ;
words

define pref [ u n | r e ];
def rot [ l o c k | c o r k ];
def suf [ i n g | e d | s ];


xfst
clear stack
read regex d o g | c a t | e l e p h a n t ;
read regex b i r d | s n a k e | h o r s e ;
print stack
union net
print stack
print net
print words





read regex
d o g |
c a t |
e l e p h a n t |
b i r d |
w o r m ;

read regex
b i r d |
s n a k e |
h o r s e |
w o r m ;

read regex
s n a k e |
d o n k e y |
c r a b |
f i s h |
w o r m |
f r o g ;

print stack
intersect net
print stack
print net
print words



LIFO: last in - first out:
Ergo:
- read regex suffiksa
- read regex røtter
- concatenate net
- få ut korrekte ordformer


clear stack
read regex e d | i n g | s | [] ;
print words
read regex t a l k | w a l k | k i c k ;
print stack
print net
print words
concatenate net
print words


Døme: Feil måte:
echo ! This is Wrong !
clear stack
read regex re | un | 0 ;
read regex cork | lock ;
read regex ing | ed | s | 0 ;
concatenate net



echo ! This is clumsy but instructive and it works !
clear stack
read regex re | un | 0 ;
read regex cork | lock ;
read regex ing | ed | s | 0 ;
turn stack
concatenate net



========================
3.5. Regelaktig notasjon
========================

(x er bare tillatt mellom a-er)
read regex x => a _ a ;
up
dog
xylophone
laxative

(a er bare tillatt før b)
regex a < b ;
up rabbi
up abba


3.5.2. Omskrivingsreglar
========================

a -> b
alle a på øvre nivå blir skrive om til b på nedre nivå

(øvre a blir til nedre b)
regex a -> b ;
apply up b
apply up a
apply up kåre
apply up bjørn
gir ajørn, bjørn, fordi nedre b kan ha to kilder i den øvre
representasjonen, den kan ha vært b i utgangspunktet (dvs.
 oppe), eller (øvre) b har blitt til (nedre) a
apply up bjarne
apply down bjarne

regex c -> r ;
apply down cat

(go blir til went mellom ordstart og ordslutt)

regex g o -> w e n t || .#. _ .#. ;
up go
up went
down ago
down go
down went


3.5.3. Regelordning
===================

Den klassiske kaNpat-oppgåva 

arkefonemet nasal N blir realisert som m foran p
N -> m || _ p ;

p som opptrer etter m blir assimilert til m
p -> m || m _ ;

kaNpat
kampat
kammat


clear stack                                # Np
define Rule1 [ N -> m || _ p ] ;           # mp
define Rule2 [ p -> m || m _ ] ;           # mm
read regex Rule1 .o. Rule2 ;	           
								           
								           
                                           # Np
define Rule2 [ p -> m || m _ ] ;           # -
define Rule1 [ N -> m || _ p ] ;           # mp
read regex Rule2 .o. Rule1 ;


To varianter som gir samme resultat
regex e -> i || _ .#. ;
regex t -> s || _ i ;
turn stack
compose
down käte


clear
define ei e -> i || _ .#. ;
define ts t -> s || _ i ;
regex ei .o. ts ;
down käte

regex ts .o. ei ; <== feil!!!

Denne tredje er lik den første:

define ei e -> i || _ .#. ;
regex ei ;
define ts t -> s || _ i ;
regex ts ;

Ikkje alle reglar treng vere ordna (disse to er ikke avhengige av hverandre):
define ht h t -> đ || _ ? [n|t];
define ia i -> á || _ [n|t];
regex ht .o. ia ;
down boahtin

clear 
regex ia .o. ht ;
down boahtin


Parallelle reglar

read regex a -> b .o. b -> a ;
apply down abba

read regex b -> a .o. a -> b ;
apply down abba

(virker samtidig pga komma)
read regex a -> b , b -> a ;
down abba



3.5.4 Øvingar
=============


Uttale av brasiliansk portugisisk


J palatalized d, similar to the phoneme spelled j in English “judge”
C palatalized t, similar to the phoneme spelled ch in “church”
$ alveopalatal sibilant, like the phoneme spelled sh in English
“ship”
L phoneme spelled lh in Portuguese filho (or gli in Italian figlio)
N phoneme spelled nh in Portuguese ninho (like the French gn in
digne)
R phoneme spelled rr inside words, single r at the beginning of
words

Ortografiske konvensjonar i 8-bit-xfst:
------------------

(Netse gong: Bruk lydskrift, for å kunne analysere ekte tekst direkte)
ʒ = J palatalized d, similar to the phoneme spelled j in English “judge”
ʧ = C palatalized t, similar to the phoneme spelled ch in “church”
ʃ = $ alveopalatal sibilant, like the phoneme spelled sh in English “ship”
λ = L phoneme spelled lh in Portuguese filho (or gli in Italian figlio)
ɲ = N phoneme spelled nh in Portuguese ninho (like the French gn in digne)
ɹ = R phoneme spelled rr inside words, single r at the beginning of words


Uttalereglar:
– The orthographical (lexical-side) ç is always pronounced /s/; in other
words, a ç on the upper side always corresponds to an s on the lower side

– The orthographical ss is always pronounced /s/.

– The orthographical c before e or i, or before accented versions of these
vowel letters, is always pronounced /s/.

– The orthographical digraph ch is pronounced /$/.

– Elsewhere (i.e. not ch, and not ci or ce), orthographical c is always
pronounced /k/. No c should appear in surface strings.

– The orthographical digraph lh is realized as /L/.

– The orthographical digraph nh is realized as /N/.

– Elsewhere, h is silent and is simply realized as 0 (zero, the empty
string).

– The orthographical digraph rr is always realized as /R/. Also, the single
r at the beginning of a word is always realized as /R/. Elsewhere,
r:r, i.e. lexical r is realized as /r/.

– The unaccented e is pronounced /i/ at the end of a word, and when it
appears in the context between p and r at the beginning of a word. An
 unaccented e is also pronounced /i/ before an s at the end of a word.
Elsewhere e:e.

– An unaccented o is pronounced /u/ at the end of a word. An unaccented
 o is also pronounced /u/ before an s at the end of a word.
Elsewhere o:o.

– A single s is pronounced /z/ when it appears between two vowels.
  Elsewhere s:s (but see above where s s - s).

– A word-final z is pronounced as /s/. Elsewhere, z:z.

– A d is pronounced /J/ when it appears before a surface phoneme /i/.
(N.B. This change occurs in the environment of any surface /i/, no matter
what that surface /i/ may have been at the lexical level.) Elsewhere
d:d.

– A t is pronounced /C/ when it appears before a surface phoneme /i/.
(N.B. This change occurs in the environment of any surface /i/, no matter
what that surface /i/ may have been at the lexical level.) Elsewhere
t:t.

– The vowels are a, e, i, o, u, á, é, í, ó, ú, ã, õ, â, ê, ô, ü and à. 
  All lexical symbols map to themselves on the surface level by default.
  
testord.txt  
-------  
disse
livro
sabe
verdade
chato
filhos
braços
me
rápido
cantar
peru
parte
cada
casa
vermelho
luz
partes
antes
carro
bicho
pedaço
parede
simpático
braço
gatinho
case
paredes
ninhos
caro
diferentes
----------

Jisi
livru
sabi
verdaJi
$atu
fiLus
brasus
mi
Rápidu
kantar
piru
parCi
kada
kaza
vermeLu
lus
parCis
anCis
kaRu
bi$u
pedasu
pareJi
simpáCiku
brasu
gaCiNu
kazi
pareJis
niNus
karu
JiferenCis



!---------------------------------------
! Portugisisk uttaleskript


echo ******* Portugisisk uttale ********

echo ******* Vi definerer sett ********

define Vok  [ a | e | i | o | u | á | é | í | ó | ú | ã | õ | â | ê | ô | ü | à ] ;


echo ******* Vi definerer reglar ********

define çs ç -> s	;

define ss s s -> s ;

define cs c -> s || _ [ e | i ] ;

define ch c h -> %$ ;

define ck c -> k ;

define lh l h -> L ;

define nh n h -> N ;
 
define  h0 h -> 0 ;
  
define  rr r r -> R ;
  
define  rR r -> R || .#. _ ;
 
define  ei e -> i || _ .#. , .#. p _ r, _ s .#.;
  
define  ou o -> u || _ .#., _ s .#. ;
  
define  sz s -> z || Vok _ Vok ;
  
define  zs z -> s || _ .#. ;
  
define  dJ d -> J || _ i ;
  
define  tC t -> C || _ i ;

echo ******** Vi sett ting saman ********
read regex [ sz
.o.
çs
.o.
cs 
.o.
ch 
.o.
ck
.o.
lh 
.o.
nh 
.o.
h0
.o.
rr
.o.
rR
.o.
ei
.o.
ou
.o.
zs
.o.
dJ
.o.
tC
.o.
ss ].i ;



echo ********* Vi lagrar por.fst ********


save stack por.fst ;

echo ********* ... og den inverse ipor.fst ********

invert net ;
save stack ipor.fst ;

!---------------------------------------





Det mytiske språket bambona
===========================

Lekse til 15.2: Sjå på det mytiske språket bambona, og prøv på ein analyse.
Vi går gjennom bambona og monisk på førelesinga.


!---------------------------------------
! Skript for bambona-morfologi

! B&K s. 158ff
! Dette er fila for morfologi.

echo ****** Bambona-script **********

echo ***** Vi definerer sett ******


define Rot [
{mad} | 
{nat} | 
{posk} | 
{rip} | 
{kuzm} | 
{karj} | 
{zib} | 
{lér} | 
{kóp} | 
{sob} | 
{mélk} | 
{rut} ] ;

define Suff1 [ 
%+Pej:{ak} | 
%+Dim:{et} | 
%+Aug:{ig} 
];

define Suff2 [
%+Obv:{izm} |
%+Prob:{ubap} |
%+All:{ópot}
] ;


define Suff3 [
%+Pl:{it} |
%+Pauc:{ejak} |
%+NoNum:0 
];

define Suff4a [
%+Nom:0  |
%+Acc:{am} | 
%+Dat:{at} | 
%+Abl:{it} |
%+Ben:{ek} ] ;

define Suff4b [%+Gen:{ozk}] ;

define Suff4c [
%+Ine:{én} |
%+Ela:{ót} ] ;

define Suff4d [
%+Com:{ep}];


! Acc | Dat | Abl | Ben | Nom -> #
! Acc eller Dat eller Abl eller Ben eller Nom avslutter ord
! Gen (Inalien) -> #
! Gen kan evt. ha Inalien før ordavslutning
! [ Ine | Ela ] (Int) (#)
! Ine eller Ela kan ha Int etter seg

define Suff4b2 [ %+Inalien:{on} ] ;
define Suff4c2 [ %+Int:{el} ] ;
define Suff4d2 [ %+Neg:{eg} ] ;

echo ****** Vi setter spesielle suffikser sammen med mulige andre suffikser ******
! De med parentes rundt er valgfri
define GenCompl Suff4b (Suff4b2) ;
define LokCompl Suff4c (Suff4c2) ;
define ComCompl Suff4d (Suff4d2) ;

echo ****** Vi setter rot og suffikser sammen ******
define Ordstart Rot (Suff1) (Suff2) Suff3 ;
define Ord Ordstart [ Suff4a | GenCompl | LokCompl | ComCompl ] ;


echo ********* Og så var det fonologien... ***********

echo ***** Vi definerer sett ******
define Ptk [p | t | k] ;

define Vokalregel i -> u, e -> o, é -> ó || Ptk _ ;

read regex [Ord .o. Vokalregel] ;

echo ****** Vi lagrer bambonaord.fst *****
save stack bambonaord.fst ;

! Bambona stoppar her.
!-------------------------------------------------------

!--------------------------------------------------------
! Monish

echo ********* Monish **********


define Rot [
{ruuzod} | 
{tsarlók} | 
{ntonól} | 
{bunoots} | 
{vésiimb} | 
{yääqin} | 
{fesééng} ] ;

# i u
# e o
# é ó
# ä a
# %^U %^O %^Ó %^A


# Rot 

# intensifyer ( [ %+Int .x. [ %^U %^U k ] ] )

# aspect ( [%+Perf .x. [%^O n]] | [%+Imperf .x. [%^Ó m b ]] | [%+Opt .x. [%^U d d ]])  

# confidence 
[ %+True   .x. [%^A n k] ] | 
[ %+Belief .x. [%^A %^A v %^O t] ] |
[ %+Doubt  .x. [%^U %^U z] ] |
[ %+False  .x. [%^Ó q] ] ;

# person/number [[%+1P %+Sg] .x. [%^A %^A b %^A]] | [[%+2p %+Sg] .x. [^Ó m ^A]] | [[%+3P %+Sg]] .x. [[   %+Pl   %+Incl   %+Excl



! Monish stoppar her (men er slett ikkje ferdig!)
! --------------------------------------------------------



3.5.5 Fleire erstatningsreglar

// for å ha kompleks vokalharmoni:


define FV i | e | é | ä ;
define C b|c|d|f|g|h|j|k|l|m|n|p|q|r|s|t|v|w|x|y|z ;
read regex
%ˆU -> i, %ˆO -> e, %ˆÓ -> é, %ˆA -> ä // FV C* _
.o.
%ˆU -> u
.o.
%ˆO -> o
.o.
%ˆÓ -> ó
.o.
%ˆA -> a ;

down totutikeˆUˆUmˆAqrˆOˆOnotunˆUq
down tikewalowoˆUˆUmˆAqrˆOˆOnetiqˆUqˆAmmˆA

(også regex med || og \\)



Variabelen ... for å kopiere venstre side til høgre:

clear stack
read regex [a|e|i|o|u] -> %[ ... %] ;
apply down unnecessarily


clear stack
read regex "ad hoc" -> % ... %<%/latin%> ;
apply down avoid writing ad hoc code


clear stack
read regex [a|e|i|o|u]+ -> %[ ... %] ;
apply down feeling

(også med @-> og @>)


d = determinar
a = adjektiv
n = substantiv
v = verb
p = preposisjon

Regel for å finne NP-ar:

clear stack
read regex (d) a* n+ -> %[ ... %] ;
apply down daanvpdan

Maksimal match:

read regex (d) a* n+ @-> %[ ... %] ;
apply down daanvpdan

(deretter over til lexc)