Presentation transcript
October 9, 2026 dissertation defense
[00:14] Dan Mailman
Okay, all right. Okay, so thank you to the members of the committee, Dr. Wu, Dr. Liang, Dr. Gao, Dr. Wang, and Dr. Huang.
[00:26] Dan Mailman
Let's get to the right screen here. Okay, so I'm going to talk about my dissertation, which is on gesture-efficient global language input methods, and first I'm going to motivate why this project started in the first place. Then I'm going to define exactly the problem that we are trying to solve, briefly touch on the literature review that all of the articles I had to read in order to do this darn thing. Then.
[00:59] Dan Mailman
Describe how the program works, describe the results of the study, and then indicate what still needs to be done and the conclusions based on the study itself. All right, so the idea is that there are other languages which are hard to type on a QWERTY keyboard, okay, and those are, let's set a timer so I don't go over time here.
[01:32] Dan Mailman
And those, so, and I've used those things and I'm really not very happy with the ones that exist and being a computer software engineer and writer of software I thought I could do better so basically that's it. So Spanish was a language I tried to type before, Japanese was a language I had tried to type before, and Chinese was also a language I had tried to type before. The softwares for doing those work, and so that's good, but I think that they could be better. So being a scientist as well, turn the idea that you can make better software into a hypothesis that can be tested.
[02:08] Dan Mailman
Okay, so the hypothesis that I came up with for this engineering project is that you can do fewer gestures for any language when you're typing individual characters or when you're typing common words and phrases. Okay, and rather than try to prove it.
[02:29] Dan Mailman
Logically, I just build something that is, that uses fewer gestures if I can, and then that proves the hypothesis, and if I can't, that disproves the hypothesis. And then, so how do I do that? You build the thing, IME input method, and you compare the gesture counts with existing IMEs. And if you have fewer gestures, your hypothesis test is proven. If you can't have fewer gestures, then it is not. Not disproven, but not proven either. Okay, scope, you can't test every language. There are tens of thousands of them. So we just pick a few. In this case, I picked three.
[03:14] Dan Mailman
English, Spanish, Vietnamese, and Chinese. And then test the hypothesis on those. So the first one, the first one was Spanish. That's the easiest one.
[04:18] Dan Mailman
Okay, so for Spanish, the normal way to do those characters is to type alt codes. Okay, so for instance, if I'm in Windows and I'm typing Word and I need a Spanish character,
[04:34] Dan Mailman
then you have to hold down the alt key and type 0-2-2-5 if you want an A with an acute accent over it. If you want the capitalized version of that, you hold down the alt key, type 0-1-9-3, and magically your character will appear in Microsoft Word or Microsoft Excel or whatever. And if you're typing Spanish, that becomes kind of a pain in the tuchus because you've got to either look them up or memorize. First, okay, and then you've got to type five characters, five keys, in order to get a single character. So I think we can do better. Okay.
[05:14] Dan Mailman
So it takes, for instance, five keystrokes to type the N with the tilde over it. It takes four keystrokes to type the peseta indicator. That's the Spanish unit of currency. And if you happen to be in Word, it takes six keys.
[05:34] Dan Mailman
So that's bad. Five keystrokes for one character is not desirable. Okay. So the question is, can an IME, an input method, reduce it to one keyboard gesture? And if so, can we make it easily learned? And the theory or the design for doing that for μLex, or for μTeclas, the case study for Spanish on the keyboard only, is that we... That we can notice that the N with the tilde is the same thing as an N. So there's a one-to-one mapping there. We notice that the underline or that the upside-down question mark is similar to the right-side-up question mark. So there's a graphical similarity.
[06:17] Dan Mailman
There's also a graphical similarity between the Spanish quote marks and the greater than and less than signs. And a graphical similarity between peseta and the capital P. But in order to get the... In order to get the euro mark, we have to rely on a semantic and not a visual association. So using each of those keys, we can do a one-to-one interface for both. And basically how μLex works for that is if you hold the key down for just an extra beat, you'll get the target. You'll get the N with a tilde or the... If you hold down the question mark...
[07:01] Dan Mailman
For an extra beat, you'll get the upside-down question mark. Okay. Now, we're not only motivated by the Spanish language, but it turns out that there are other languages for which there's only a one character, one character that looks like one of the QWERTY characters. There are 51 other languages that we can use the same strategy for. So once we write a software for, say, Basque or Albanian, okay, we can... The user will be able to download that software. Be able to hold down the key for an extra beat for whatever character they're looking for and be able to just go on about their business.
[07:38] Dan Mailman
So here we have taken six keystrokes and reduced them to one on programs that run with just the keyboard. Okay. But not everybody wants to just use a keyboard. So for all of those languages, we can also provide a mouse-operated display where you click on what you want and get that as well. Okay. All right. Now, there's a second... The second class of language uses letters as well. Okay. And the second class of... Or the third class of input methods. You can't do that for Vietnamese, which has two times three times six different versions of the letter A.
[08:23] Dan Mailman
Okay. So we need to come up with a system which presents those in a logical manner so that they can be... Walked through. So you can't put up 200 and 200 and some odd characters and expect somebody to be able to find it on the display easily. Okay. So that system... Okay. There are systems already in place. The Windows Vietnamese Telex system, which reduces finding those characters to a memorized set of keys. Okay. And reduces the number of gestures to get those to basically the number of characters plus however many marks. So if you wanted a simple A or a simple N in this system,
[09:08] Dan Mailman
you would use one key. Okay. If you wanted to do a vowel with just the form and not a tone mark, you could use two keys. So for instance, A with an upside down smile over it, you type A-W. If you wanted the hat, you would type A-A. And if you wanted the O with the horn, you would type O-W. Okay. So that... Reduces what would normally be six keystrokes with the alt codes to two or three keystrokes with a set of memorized extra keys for the marks on the vowels.
[09:47] Dan Mailman
So in trying to do better, we really couldn't. We do exactly the same thing, but we use a visual interface instead. So here is an example where for Vietnamese characters, the hypothesis is in fact disproven, at least so far. Because we do exactly the same gestures. I think the interface is better, but that's for somebody else to decide. This is exactly the same gestures as the Microsoft program, but we present it visually. So here we actually have disproved our hypothesis and say, look, we can't do better for Vietnamese characters. Okay. All right. Other languages in the same class. There are 67 of them.
[10:31] Dan Mailman
So we could write a similar piece of software for each of these 67 languages to make it easier for users of those languages to type their language more fluidly. All right. So now it turns out the most interesting, and I didn't think about this, I didn't discover this until about midway through the study, but it turns out that if we concentrate on words and phrases, we can actually make an improvement for English as well. Okay. So this is an example. And I'll demonstrate. I'll demonstrate it later. But if we write our software in such a way that you're inputting words and phrases instead of letter by letter, then you can indeed reduce the number of gestures to get those words and phrases.
[11:16] Dan Mailman
So this is an example where if you use the μWords, that's one of our case studies, to type the word understand, you can do it in two gestures rather than the 10 gestures it would take using a normal QWERTY keyboard.
[11:35] Dan Mailman
These are the statistics for that. I'll go over those later. Other languages in the same class, there are 50 some odd languages that are basically QWERTY and no marks. Okay. So those can be done exactly the same way once we have a corpus that we can analyze in order to determine the most frequent words and phrases, we can present exactly the same kind of interface for these languages. That we do for English and indeed for, well, we'll see later, we can do the same thing for Chinese as well. So not only English, but 56 other languages, if we just take QWERTY into account.
[12:14] Dan Mailman
But it also turns out that there are about 150 other languages that put marks on their letters, but multiple marks on their letters. But if we take, if we compile corpus corpora for those languages, and then do a frequency analysis, we can do a word by word interface for those as well. And so presumably we can reduce the number of gestures from somewhere around 10 to somewhere around four for any of these languages once we've done corpus analysis on them. Okay. So for Chinese, the software that I got frustrated with is illustrated here.
[12:59] Dan Mailman
And this is the Microsoft. Okay. Microsoft input method in order to, for instance, if I wanted to input the Chinese word for father-in-law, I would have to type Y-U-E, and then the software would graciously give me that mark after it to indicate I've finished a symbol, and then I would have to type F-U. So five keystrokes to get to there, and then one more keystroke, the number one, or clicking on this area. In blue would get me that sent to my Word, or my Notepad, or my spreadsheet. Okay. So can we reduce the number of gestures to get words and phrases in Chinese?
[13:44] Dan Mailman
Okay. So that's the question. All right. Okay. Other languages in this class, there are about a dozen of them, and those are listed here. I've actually already done one for Cherokee a while back. I could probably do a better job. That was years ago. And I'm sort of halfway doing one for Japanese here. All right. But those aren't really part of this study. Okay. So those are the problems. Okay. Well, you know, we have a bunch of IMEs out there. I think there's actually an organization in the central Chinese government that keeps
[14:27] Dan Mailman
track of all of the IMEs that have been proposed for.
[14:34] Dan Mailman
So I'm getting ready to add to that. So the goals of this project are to make IMEs, input methods that are immediately usable and easily learned, are compatible with ordinary applications, operating systems, and input devices. That's actually the hardest part of writing the software. And increase user productivity over time. Okay. So now what do we mean by that? We mean by those. Okay. Immediately usable. And you can see that basically these are all what you see is what you get. If you click something, you'll get something. It's for native speakers of those particular languages. These are designed to be immediately accessible. So easily learned.
[15:19] Dan Mailman
And immediately usable. All right. To make compatible with ordinary applications, so on Windows, Microsoft Word, Microsoft Excel, Notepad, et cetera, et cetera, what we call productivity applications. Windows is an operating system. Linux is an operating system. OS X on Apple computers is one. Android is one. Every time we add a particular language, we also would have to write a different version of the software for that language for each OS. So that's really technically the hardest part of getting these into users' hands. Okay.
[15:59] Dan Mailman
For keyboards, the idea of the longpress, the extra beat when you hold down the key, guarantees that we're not interfering with the alt keys and the shift keys and the control keys and the function keys that operating systems and applications sometimes give special meaning to. Okay. So compatibility with applications, operating systems, and input devices. All right. And then. Kind of the most fun part of this was trying to figure out a way to make it so that when people are using the software, they're not only just using the software, but they're getting better at it at the same time. Okay.
[16:40] Dan Mailman
And we do that through arranging the grids in a particular way. And here are three aspects that do that. First, the fact that we have grids at all—the last item, display guidance—makes it very easy for them to just click on what they see and know that that. Thing gets put to their application. We also do not change the grids around. So the same set of cues, whether it's the mouse cues or the keyboard cues, always result in the same target. So if you always type W-A to get the word, I don't know, understand, right? Every time you type W-A when the software is active, you will get “understand” sent to your productivity application. So that's cue target consistency.
[17:26] Dan Mailman
Okay. And then. The other aspect that makes these things easier to use and hopefully faster to use over time is to arrange the targets on the grids in such a way that the most common are easily found in the left to right, top to bottom eye scan. And then the less frequent ones are over sort toward the right left. So most common is upper left. Least common is lower right. And you should be able to find what you're looking for in the top few rows of the grids that are our. Displays. Okay. So now all of that babbling, let's do walkthroughs of the software. So you actually do know what I am talking about. To introduce them, μTeclas—teclas
[18:09] Dan Mailman
is Spanish for keys, uh, is the keyboard only display for letter by letter. When there is a one-to-one mapping of the targets to keys on the keyboard. μLetras is adding a display to that. μVietChu is Vietnamese, which introduces the branching for future choices. Then μWords and μCiYu are there for English words and phrases and Chinese words and phrases. The prototype software that I am going to demonstrate for English uses only 3,000 of 333,000 available words and phrases.
[18:47] Dan Mailman
And for, uh, The Chinese only 5,000 phrases are in the demo and of, of an available 430 some odd thousand. Okay. Okay. These are available on my website if you want to play with me. Okay. So μTeclas, the keyboard only for Spanish. Okay. There's a display and the display there is optional. You don't really need it. It's only there to tell you what key you've hit and when you've, uh, when the extra beat has been crossed. So if you want to type in, well, let me make this bigger, but that's, so I think it's bigger. Okay.
[19:31] Dan Mailman
So, uh, if I hold, if I just type a, I'll get an a, but if I hold down the a key for an extra beat, then I'll get a, with the acute, uh, accent over it. Um, and similarly, if I hold the shift key and an a, the same thing. Okay. So this way you're using the keyboard with a visual cues for what the, for the special characters. Um, and this one, this particular piece of software is only for the keyboard and it's only useful for languages. Which is in which there's a one-to-one mapping, uh, of the target characters and the cue characters, which are on the keyboard. Um, but we have several, um, dozen of those. All right.
[20:14] Dan Mailman
Um, now not everybody always wants to use the keyboard. So the next class of, of, um, IME of input method is μLetras. This is Spanish. Now we're doing letter by letter and the keyboard still works. So I'm here holding down the key. It's here. Um, no normal G just repeats because there's no variation of it. But if I wanted to type the capital N with the tilde. So those are all shortpress and longpress on the keys, but we can also do shortpress and longpress on the letters on the, on the display here and get the thing. Okay.
[20:51] Dan Mailman
So here I do a shortpress and I get an a, I do a longpress and I get an a with the acute, I use the other button and I get a capital a. If I hold. It down and, uh, and a normal a, if I do it for a short period of time. Okay. And the display gives you the feedback that tells you, yes, you've crossed the longpress threshold. Okay. All right. Okay. So that's the second class of IME, which is one-to-one mapping of cues and targets, uh, with and without the display. Okay. All right. The third one, the third case study, μVietChu,
[21:33] Dan Mailman
Um, it should demonstrates how we deal with multiple targets and one cue. Okay. So as I said, there were, uh, 36 variations, not well, 36 times, 72 variations of the letter a possible. Okay. Uh, if you take into account shifting, okay. So for this, you can either the same idea here, the black indicates what you can get immediately. Okay. Into the typing area, the red, which is accessible by longpress. Brings up a further grid and now each of the variations of the letter a, with a single mark is available in one further gesture.
[22:12] Dan Mailman
And each of the variations with two marks are available with a second gesture on a second display. Okay. So in this way, uh, it's essentially one gesture per mark. Okay. Which is the same as, so not better than too bad, uh, than the existing one. Okay. So it's the same as the existing telex windows, uh, IME, okay, but the important thing to know about this, to, to, to sort of carry forward about this is that it does lead to branching and branching leads to new displays and new displays give new possibilities of what you want to choose. Okay.
[22:53] Dan Mailman
And that is exactly the strategy that we take into the English-language words-and-phrases interface, which we are calling μWords.
[23:06] Dan Mailman
So, um, uh, I'm going to have to shrink this one a little bit so that you can see the typing area. All right. Okay. Here we go. Okay. Same idea. What you see in black is immediately, um, accessible just by clicking. Okay. Um, and then what you see in the red with the dots says, I'm going to give you a more choices on a different grid. And you can choose one of those. So in this way, “quarter” is accessible with two gestures.
[23:47] Dan Mailman
And then for user-interface convenience, we hide what is not available. So when you are hovering over this area, you get the grid of Q—of G choices. And when you are hovering over this area, you get the input, the lexeme, and that gets sent to the productivity app. Okay. Uh, so that's where English language now, the same strategy is actually, uh, doable with Mandarin Chinese. Um, and I'll demonstrate that with, um, words and phrases. Here we go. All right.
[24:31] Dan Mailman
So the idea here is that words and phrases are accessible immediately when, oops, let's get the typing area visible here. Sorry. I have to shrink this again. Uh, I wish I could do this bigger, but I can't. Um, so words and phrases immediately accessible. Okay. If you don't see what you want, but you do know the first sound of it, let's go, um, uh, let's see. D. Okay. Then now we have a screen of the most common, or I should say grid of the most common words and phrases, which start with that sound. Okay. So dōu, meaning All or both. Okay.
[25:12] Dan Mailman
Is immediately accessible, but there are some that are also accessible using DB. Okay. Now this is DB is actually going to be the first syllable of a multi character word. So all of these, this one starts with D, and this one starts with B. Okay. So these are all accessible that way. So here we have—let us see, if I want this— débùdào, “unable to get.” So in two gestures, maybe it was three gestures. We are doing three characters, which are normally accessible—one, two, four, maybe seven gestures—using the normal pinyin-based interface.
[25:57] Dan Mailman
Okay. So the, the take home is that the same simple strategy. Okay. Uh, either input something directly or find a grid that gives you further. Inputs is used all the way down. Okay. It is kind of like a card trick that looks really, really hard, but the mechanics of it are fairly easy, as we will see. All right. Okay. So back to the slides. All right. Okay. So again, uh, the, the prototypes that are on there use 3000 of 330,000 available, uh, words and phrases.
[26:39] Dan Mailman
And for Chinese, it's 5,000 of the 430 available words and phrases, the final versions of these will cover those. Okay. All right.
[26:51] Dan Mailman
Okay. Literature—oops. Uh, I had to read a lot of articles in order to get this thing supported and written, uh, and I don't want to go through them individually. So I just want to say the classes of them, uh, several, maybe a dozen articles were on languages and Unicode period, somewhere on usability and performance.
[27:11] Dan Mailman
Some were on other strange devices, which I'm not going to talk about because it's a, it's a sort of, it's not as important to the dissertation, um, but things like one handed input devices and voice input, uh, in certain cases, uh, in order to produce the word and phrase, um, uh, grids, I had to do a lot of corporal corp, corpus studies and frequency lists on the corpus studies. Uh, and then. Several articles were on Mandarin input and Mandarin language, and then, uh, other articles were on input software and platforms.
[27:51] Dan Mailman
So you can see the tawdry list of articles I had to go through, some of which were actually mine. I had a patent on an early version of this, early in this century.
[28:08] Dan Mailman
Um, so too many. Articles. Okay. All right. So, so now the guts of the thing, how does the software actually work? Okay. And this is where, this is where it's a lot simpler than it, than it might seem. Okay. So the, the core of the, of the software for those, for those of us who are computer scientists is that it runs a finite state automaton or a finite state machine, uh, using, uh, tables to say how we get from one state to another. Okay. So, and I'll talk about. A finite state machines after I show how simple the software really is at its core, using the tables that drive it. Okay.
[28:50] Dan Mailman
So for μTeclas, for the keyboard-only interfaces, all we really need to know is: what is the cue, what do we do when we do a shortpress, and what do we do when we do a longpress? Okay. So the table that drives μTeclas has rows in the table that look like this. They tell you the cue is an n. If you shortpress it, you are going to get an n. If you longpress it, you are going to get an n with a tilde. If you hold the shift key down and shortpress it, you'll get a cap, a capital N.
[29:27] Dan Mailman
And if you hit any, if you, uh, uh, longpress it with the shift key down, you'll get a capital N and one shared loop, one event loop. That's the finite state machine handles every single record. Okay. So you can see the. Very simple table, uh, that drives the entire software. Okay. And this is when we add the display, you can actually see that more clearly. The cue is what's in the upper left-hand corner. The secondary target, the primary target is essentially the cue. So you don't need to show that the secondary target is what gets displayed in the middle. Okay. Because that's the character that's special. And that is the one that is hard to get to unless you have the software.
[30:12] Dan Mailman
Whoops. Okay. So shortpress selects n; longpress selects the n with the tilde. For the Viet application, This shows that, uh, we have two, um, two separate targets. One is the primary target and that is the letter a okay. Then we have a label indicating the secondary target, which opens a further grid or leads to a child grid, we can say. And so the indicator gets put here in the cell, to the left center. And when you select it, when you hold down something and release it, uh, you'll get an updated grid. Okay.
[30:56] Dan Mailman
So, uh, and then once you actually do a selection, you'll go back to the, to the home grid. Okay. So, uh, um, similarly, okay. Uh, when we, uh, when we're. Talking about Chinese now, and we're talking about words and phrases, the actual actions are the same actions. Okay. They're either send something to your productivity application and return to the home grid. That's one action. Okay. The other action is open a secondary grid. Okay. So in the case of this cell here, which shows yào and the letter S, if you shortpress, you will get the character yào. It is yào, isn’t it? My eyes are bad. Yeah.
[31:41] Dan Mailman
Um, And if you shortpress, uh, the second that, or longpress that you'll get a further grid, that is the common words and phrases that start with that sound or that letter in pinyin S okay. Um, let's see here. All right. So table on the left, what it looks like when implemented by the software on the right. Okay. And then, oops. Oops. Skipped one. Okay. And similarly for μWords. So this table drives that cell.
[32:22] Dan Mailman
And if you, um, shortpress on that cell, okay. You will get “have,” H-A-V-E, sent to your productivity app. And if you longpress on that cell, it'll open a grid that enables you to, uh, input the most common words and phrases starting with the letter U. Okay. So in this way, we use the letters similarly, but the letters in English are the letters of the spelling. And for Chinese, the letters that you are using on the keyboard are the letters of the pinyin pronunciation system. Okay. All right. So that was, so that's how that's all about tables that run the software. Okay. But how does the software actually run? Okay.
[33:03] Dan Mailman
So there is a very basic, very simple construct in computer science called a finite state machine, or FSM for short. And it basically says, uh, your, your. Your software maintains an internal state that means something. Okay. And it reacts to events and every time it reacts to an event, it may or may not do something. Okay. So I am going to start at the bottom here. There are only three things it can possibly do: change the way the cell looks, send input and return to the home grid, or display a child grid. Okay. So those are the only events.
[33:44] Dan Mailman
Now, I'm sorry, the only actions that, that this particular program implements, okay. And it implements them in, um, Response to only eight things that you can do when you're manipulating the software. If you are on a mouse, you can either hover over a particular cell. You can leave the cell. If you're pressing on the cell, the timer can go off to say when shortpress becomes longpress, and you can release the mouse button or the keyboard. Okay. On the keyboard, there are only, um, five things you can do. You can press down a key, release a key, shift, press down and shift release. Okay.
[34:26] Dan Mailman
So those are the possible events that the software pays attention to. And given those actions and those events, we only need to remember, and this is what the states are for, what the user has done. So the state said, the state says the program knows. Okay. So if I'm the program. I say, okay, I know that I'm ready. Okay. Nothing is happening. Okay. Or I know that the user’s mouse is hovering over my cell. Or I know that he's pressed something without a shift key. So he's getting ready to do the primary key. Oops. Now I know he's pressed the shift key. So now he's getting ready to do a capital N. Okay.
[35:04] Dan Mailman
So when the primary gesture is given, when he holds down the key, we move from Ready to Primary. When he holds down the Shift key, we move to Shifted. When he long presses in either one of those, we move to either of those two states. And then when he releases, we move back to the ready state, ready for the next one. Okay. So all of that's very, very complicated. And the entire, all that babbling I just did is accounted for in this finite state diagram. But really all this whole thing means is: what do you do in response to whatever the user is doing? Okay. So and this is why I said this is the hard part.
[35:48] Dan Mailman
So you do something different if it's a keyboard, if it's a two-button mouse, if it's a one-button mouse, and even if it's a mouse and we've done the sort of split cell thing that we do in the word and phrase interfaces. IMEs, input methods. Okay. So. Now the core question is. How much. How much of the language, whatever that means. Okay. I'm switching from the implementation now to the coverage statistics. How much of the language, whatever that means, can be covered and how few gestures. And this is where the statistical analysis comes in. So not surprisingly, it's one gesture per letter, whether you're talking about English.
[36:34] Dan Mailman
Now, when you're talking about Spanish, it could be as many as two gestures per letter. When you're talking about Vietnamese. It could be as many as three gestures per letter. Okay. So it turns out that in the corpus that I used, the maximum word or phrase was 12 letters. So 12 gestures out of 460— This was all modeled. There isn't actually an IME for this. I just did the mathematical analysis for the entire set. Maximum 12 characters. Covers 460,000 some odd words and phrases. For English. Maximum 12 gestures. For Spanish.
[37:20] Dan Mailman
600. Covers 600 some odd thousand words and phrases. For Vietnamese. 13 gestures. Not surprisingly, because some of those have the extra two marks. But my corpus was only 23,000 words and phrases. Okay. But when we do word by word, okay, it changes. Okay. We actually can cut it in half. And probably even better than that. When we do when we limit the number of words and phrases as we did for the prototypes here. Four gestures covers 3,000 words and phrases in English.
[38:00] Dan Mailman
Four gestures also covers 5,000 words and phrases in Chinese. In Vietnamese. I modeled it. Five gestures would cover 23,000 and probably more words and phrases. And if we take the entire model into account, six gestures will cover 460 some odd thousand words and phrases in English. And six gestures will cover 430 some odd thousand different words and phrases in Mandarin. So the real savings in terms of gestures comes when we treat words and phrases. Okay. All right.
[38:39] Dan Mailman
So for the individual case studies, when we take all of the English language words and phrases into account, we can cover all of them in 99%. But as you can see from this graph, we cover something like, I don't know, 70% in four gestures. Okay. Similarly for Spanish, we cover all of them in 12 gestures. This is letter by letter. Right? Not word and phrase. But we still cover most of them, let's say, by six or seven gestures. Which basically says that most of the words and phrases that we cover in our corpus are seven and eight characters.
[39:24] Dan Mailman
So basically this is an indicator of the number of characters in the word and phrase. Same for Vietnamese. Not surprisingly, it's more. Because of the extra two marks. Okay. On the words and phrases. And let's see. So now we get to the word by word gestures. And it turns out that even for, oh, these are the case, these are the limited case studies. For 3,000 lexemes, it's four gestures. And 75% in two. Which is pretty good. I mean, 75% of your language is covered in two gestures; you are doing pretty well.
[40:07] Dan Mailman
Similarly for the Chinese words and phrases. It's steeper. So 80 some odd percent in three gestures. But quickly we get to 99% in four gestures. When we model all of the Vietnamese, similar sorts of statistics. Except you'll see that it's one extra. For that one extra on average, let's say, one to two. Average mark on the vowel for each lexemes. For each word or phrase. And then now if we're talking about words and phrases now. Not characters. Okay. Words and phrases for English. Six gestures for 99%.
[40:52] Dan Mailman
Even when you're talking about 460,000 some odd words and phrases. And the number of occurrences. Actually nearly 100 million. Let's see. Fairly similar actually for Mandarin. Six gestures covers 99%. Assuming you've done your cue to target. Strategy. In such a way that it minimizes. Okay. So you could come up with a selection strategy that makes this much worse. But the initials of the pinyin work pretty well. So six gestures covers 430 some odd thousand words and phrases.
[41:37] Dan Mailman
Okay. So those are the statistics. They basically.
[41:44] Dan Mailman
We did pretty well in terms of reducing the number of gestures for languages. Especially when we go to words and phrases. We didn't do so well when it's letter by letter. What I'd like to do for each of these pieces of software. Is, is I would like to. For the μLetras One. I would like to split the cells the same way we did in μWords and μCiYu. For μWords, I'd like to do capitalization with secondary gestures. I'd like to add an interface for. Spaces included with the word or phrase. And or punctuation. Following the word or phrase. I would like to. Consider alphabetizing the grids for easier lookup. For the Chinese one.
[42:28] Dan Mailman
I'd like to alternate between. I'd like to be able to hit the. Use the secondary gestures. For traditional characters. And the primary gestures for. For simplified gesture for simplified characters. And then I'd also be able to. I would like to add an interface so that you get the entire pinyin Syllable. And or the individual characters. Conclusions. Human language diversity makes it impossible. To do. All of your hypothesis testing. And then basically these cases suggest that the cue systems can. Can be engineered. So that word and phrase IMEs use. Substantially fewer gestures than letter by letter. IMEs.
[43:13] Dan Mailman
Thank you very much. That's it. That's all I got.