How to determine the total number of passwords that can be generated that look like fake words I recently created a website where users can generate passwords using several different methods.   One of the methods is creating fake words based on vowel, consonant, vowel parts found in real words.  For example it might generate:
sphe + effe + ega + asty = spheffegasty

where the parts are connected by common vowels.   This makes the generated words somewhat readable.
I'm having trouble figuring out how many words this algorithm could generate.  I know that in general it should be the product of the number of possibilities for each part.   The conceptual problem I'm having is that the parts are not completely independent.  Here are the stats about the number of word parts in each list and how many lead to each next type:
"start" is the the list used for the start of the fake word.  Of the items on the start list, 130 of the end in "a" which would mean that the next list used would be the "a" list.
start: length=608, to_a=130, to_e=138, to_i=145, to_o=102, to_u=93

Lists of word parts used in the middle of words.  The list used is based on what vowel the last ended with.  The list used after will depend on the ending vowel of the item chosen from the list.
a: length=430, to_a=82, to_e=129, to_i=89, to_o=77, to_u=53
e: length=362, to_a=67, to_e=103, to_i=89, to_o=63, to_u=40
i: length=276, to_a=56, to_e=87, to_i=55, to_o=44, to_u=34
o: length=282, to_a=50, to_e=100, to_i=65, to_o=36, to_u=31
u: length=244, to_a=48, to_e=85, to_i=55, to_o=35, to_u=21

The lists used for the last part of the word.  They list used depends on the current ending vowel.
a_end: length=262
e_end: length=198
i_end: length=199
o_end: length=186
u_end: length=173

In the worst case, the shortest lists always get chosen.  So the lower bound on the number of passwords created would be: 
608 * 244^n * 186

Ignoring the fact that the word parts are interconnected, the upper bound would depend on the total number of parts available: 
608 * (430+362+276+282+244)^n * (262+198+199+186+173)

I'm currently estimating based the average length of the lists:
261^n

Is this a good heuristic?   What is the proper way to evaluate this?
 A: Let $S$ be the $1 \times 5$ matrix of start values, $[130,138,145,102,93],$ and let $F$ be the $5 \times 1$ column matrix of finish values, $[262,198,199,186,173]^T$ (where the $T$ means transpose). And let $M$ be the $5 \times 5$ transition matrix, whose rows are as in your displayed data. For example row $1$ of $M$ is $[82,129,89,77,53].$
Then the number of words of total length $n+2$, i.e. using a start word,  finish word, and $n$ intermediate words, is the (single) entry of the matrix product $S\cdot M^n \cdot F.$
That this is the right thing is best seen by working out say a $2 \times 2$ example (going to only two vowels), and making a tree diagram to see how things work. The definition of matrix multiplication is exactly what is needed for the right things to get multiplied by other right things, so the ends of the words hook up.
There is good software such as maple to do the large matrix multiplications. I don't know of an easy way to "estimate" the result, based only on the matrix entries.
