A simple syllabifier

Assumptions

This simple syllabifier is based on the assumption that there is a close relationship between sonority and syllable structure. It proposes that a continuous phoneme string can be converted into a list of syllables by locating syllable boundaries at positions in the string immediately preceding a point of minumum sonority. (Compare the syllable counter which relied on looking for sonority peaks to identify syllable centres and hence count syllables.)

The sonority of a segment is determined by its place on a sonority scale. Clearly any such scale is controversial and you are free to change the organisation of the list set up here under the name "sonority.scale. You can also change and/or add to the phoneme symbols if you wish, but you will need to update "sonority.scale whenever you do and, of course, you will find problems in replicating a phonetic transcription system - such as the IPA - on a computer. ( Look here for some ways to work around that.)

A minimum of sonority is found in a phoneme string when we discover a segment which has a lower sonority value (according to the scale adopted) than either of its neighbours. We will call such a configuration of three segments a trough.

Tactics

Given the preceding assumptions, a possible syllabification technique might be as follows:

  1. Get hold of the phoneme string to be syllabified (let's just call it the string).

  2. Get hold of an empty syllable box (from an endless supply of such boxes) and call it current syllable box.

  3. Imagine that you are obliged to view the string through a window which allows you to see only three segments at any one time and place the window over beginning of the string.

  4. If the string is empty then stop because your current syllable box holds the last syllable.

  5. If you are looking through the window at a trough then:

  6. If you are not looking at a trough then:

The Logo version

The system is run by typing syllabify "some.word.or.other. Actual words used as inputd must be represented by characters used in the sonority scale (i.e. must be represented 'phonologically').

The sonority scale

A variable called "sonority.scale is set up as a list with elements going from lowest sonority to highest sonority. The choice of characters to represent sound types is, of course, the worst problem and the list, as it stands here, is certainly not fully equipped to deal with English.

make "sonority.scale 
   [ [p t k] [b d j g] [f s] [v z] [m n]  
                   [l r] [h] [y w] [ i u] [e o 3] [a ] ]
The procedure scale (which presupposes that vprint is defined) merely diplays the sonority scale when requested by the user at toplevel for reference.

to scale
cleartext pr [ ] 
pr [sonority hierarchy] 
pr [least sonorous - most sonorous] 
pr [ ] vprint :sonority.scale  pr [ ] 
end

Finding the sonority of a segment

Determining the sonority of a segment is handled by two procedures, though sonority is only used as an interface to the real work done by find.sonority. (Find.sonority requires three inputs, sonority only one. Lessening the input load is a common feature of such interfaces. ) Sonority calls find.sonority with the segment whose value is to be found as input one, the full sonority scale as input two and a counter initialized at 1 as input three.

to sonority :segment
op find.sonority :segment :sonority.scale 1 
end
Find.sonority attempts to find :segment in a sub-list of the sonority scale. If successful, it outputs :sonority. Since the value of :sonority (initially 1) is incremented on each recursive call, the final value is equivalent to the position occupied by the sublist in the scale. An error message is provided to cover the case where the segment does not appear in the scale.

to find.sonority :segment :scale :sonority
if empty? :scale [pr [error. no such segment.] toplevel] 
if member? :segment first :scale [op :sonority] 
op find.sonority :segment bf :scale :sonority + 1 
end

Syllabification

Again there are two procedures involved with one - syllabify - acting as a front end to the real workhorse - syll. Notice that syllabify provides two inputs to syll . The first is the word (i.e. the string of characters) to be syllabified, the second is also a word but an empty word. This second input is initialised as empty because it used to collect the phonemes of the current syllable as it is gradually built up.

to syllabify :word
op syll  :word  " 
end 

to syll  :string :current
if empty? :string [op list :current] 
if trough? :string  [op se word :current first :string syll bf :string " ] 
op syll bf :string word :current first :string 
end
The tactics of syll, line by line, are as follows:

Finding an boundary

An internal syllable boundary is something which shows up as a trough of sonority - i.e. in a sequence of three segments where the middle segment less sonorous than both neighbours. Trough? is a predicate which tests this condition on the first three elements of its input . Trough thus implements not only the crucial test but also the narrow window through which the start of :string is viewed. It outputs "true when a trough is found.
to trough? :string
if 3 > count :string [op "false] 
if and ( sonority first bf :string )  
             <  ( sonority first :string ) 	
                  (sonority first bf :string ) 
                   <   ( sonority first bf bf :string ) 	
                                [op "true] [op "false] 
end

Here is a Logo-loadable version of the procedures

and here are some follow up ideas.



Ron Brasington
Department of Linguistic Science
The University of Reading
Reading
UK

E-mail: ron.brasington@rdg.ac.uk