SuperScript's Pensieve — situational intelligence - handwriting recognition technology

RELease 1.0, Oct 31, 1991

The word context" is something of a reserved term in the AI world, and it generally refers to an overall model of the world, complex to define and complex to implement in all its nuances. Superscript has demystified this concept into something practical which works within (Pen) Windows and which it should be able to license to a number of pen platform vendors (although it could also be used with an individual application). Superscript founder John Kulp, who was also vp of R&D and a founder of Symbolics, originally planned to build its own high-end pen system based on a Symbolics chip and a proprietary operating/development environment (see Release 1.0, 6-90). But this time around, he has bowed to the rigors of the market - and people's reluctance to adopt nonstandard technolology.

Superscript's PenSieve is about as unobtrusive and standards-oriented as you can get. Implemented as a Windows Dynamic Link Library but written in C and easily portable to other environments, it manages the contexts for an application and provides the appropriate word list for each context in order to enhance the performance of a text recognizer. It's a fairly simple idea, but there are enough tricks and little quirks to give Superscript hope of licensing it to other vendors. Superscript simply has to make it easier and cheaper for others to buy than to make it themselves.

The system doesn't do anything exotic to determine what the context" is; it leaves that up to the application - that is, the application developer. The simplest approach is some static link, such as a defined context for each field on a form. (This is much like a pick list, except that the user doesn't see the list he is picking" from - in reality, matching to. (If the context is very tightly defined - the fifty states, for example you'd probably use a pick list. But if there are 2000 part numbers, it makes more sense to give the computer a list to match against what it thinks the user has typed.)

More elegantly, the application could infer the context from something the user is doing - what he's entered into a previous field, a statistical analysis of words he's used up to that point, or the most recent customer name the system recognized. In fact, determining the context rather than applying it may be the better potential application of AI.

Make me a match

As input, PenSieve then takes the resident recognizer's best guess at the text string the user has entered. (It doesn't deal with the ink directly, nor does it use character-specific logic such as "an 'i" could also be an '1'." Such character-specific intelligence doesn't seem to improve performance much.)

Then PenSieve compares the input string to the context, which is a set of matched pairs of text strings and data elements or objects. The application doesn't need to take the recognized string and then look it up in a table; the pointer to the actual record or object is already there. After all, what the user is entering typically is not just strings of text, but references to objects managed by the application.

How is this different from a dictionary, such as a spell-checker, which is frequently used to aid text recognition? In principle, it's more or less the same idea, but with far more situation-specific word lists. The smaller the range of possibilities, of course, the faster you'll recognize the right answer - or at least the one the user intended.

Find me an object, not just a string

Moreover, as noted, both conceptually and practically the system is not trying to recognize a text string or a simple attribute such as M or F for male or female. It already knows" the objects and is just trying to discern which one the user is referring to - which customer, which appointment, which chapter, which memo.

Obviously, for now PenSievels approach doesn't do much for free-text entry, although we could imagine a cleverer system that could in fact discern the context from what the user had written. But PenSieve can speed up performance and accuracy for the majority of semi-structured tasks, including broad horizontal" ones such as calendars, contact-management and mail, where the user has his own set of familiar objects. Contexts could include dates, people with whom you frequently have appointments, locations, common topics, etc. The application vendor now has to think a little, and provide training opportunities in the application. For example, you may have to prompt the user to specify when he wants to enter a new contact rather than an existing one; he'll probably be willing to print carefully once, if the system will recognize that customer thereafter. Also, you could offer an explicit learning mode to let the user add new items to the context list.

PenSieve is the sort of tool that could be added to any pen operating system. (You could also add it to an application, but it's generic enough that it makes more sense in the platform. Only the contexts are applicationor user-specific.) Sure, most platform vendors will want to do their own, but it makes sense to have a standard API for such a handy, generic technique. Windows, with its DLL capabilities, is open for such additions and more. PenPoint, likewise, can easily accommodate extra modules.