JP3532780B2 - An input system for generating input sequence of phonetic kana characters - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a miniaturized keyboard system, and more particularly to a miniaturized keyboard system for creating text consisting of Japanese hiragana, katakana and kanji characters.

[0002]

2. Description of the Related Art Over the years, portable computers have become smaller and smaller. The key size limiting component for making smaller portable computers is the keyboard. If standard typewriter-sized keys are used, the portable computer must be at least as large as the keyboard.
Miniaturized keyboards are used in portable computers, but it is known that the keys of miniaturized keyboards are so small that the user cannot operate them easily or quickly.

Providing a full size keyboard in a portable computer also prevents true portable use of the computer. Most portable computers cannot operate without placing the computer on a flat work surface so that the user can type with both hands. The user cannot easily use the portable computer while standing or moving. In the latest generation of small portable computers, called personal digital assistants (PDAs) or palm-sized computers, companies are trying to solve this problem by incorporating handwriting recognition software in their devices. The user may enter the text directly by writing on the touch-sensitive panel or screen.
This handwritten text is converted to digital data by the recognition software. Unfortunately, in addition to the fact that pen printing or writing is generally slower than typing, the accuracy and speed of handwriting recognition software has not been adequate to date. This problem is especially difficult for Japanese, where there are many complex characters. Worse, today's handheld computing devices that require text input are becoming smaller. Recent advances in two-way paging, cellular phones, and other portable wireless technologies require small portable two-way messaging systems, especially those capable of both sending and receiving electronic mail (e-mail).

Therefore, it is useful to develop a keyboard that is small and allows a user to enter text into a computer device that is held by one hand while still operable by the other hand. Previous developments have considered the use of keyboards with a reduced number of keys. Many reduced number keyboards use a 3x4 array of keys, as suggested by the keypad layout of touchtone phones. The number of keys in the array is associated with a large number of letters. Therefore, there is a need for a way for a user to indicate which of the characters associated with a given key is the desired character.

One proposed method for unambiguously identifying hiragana characters entered on a keyboard with a reduced number of keys requires the user to enter more than one keystroke to identify each kana. And Keystrokes may be input simultaneously (coding) or sequentially in succession (multi-stroke specification). Neither the coding nor the multi-stroke specification allows the keyboard to have the proper simplicity and efficiency in use. Multi-stroke specifications are inefficient and coding is often complex to learn and use.

Each syllable of the Japanese syllabary consists of one vowel or a consonant followed by a vowel. There are two exceptions: the syllable "n" has no vowels, and the small "tsu" is used to indicate "duration" or "hardening" of the pronunciation of the consonant that follows. These syllables are written as Hiragana (commonly used when writing native Japanese words) or Katakana (usually used when writing foreign words). The term kana is used to represent either hiragana or katakana. The syllables are usually represented as a table of rows or columns (shown in Figure 29), where each row has five Japanese vowels "a", "i", "u",
It has entries in up to five columns corresponding to "E" and "O". A given consonant undergoes a voice change of an entry within a line (eg s (a) → sh (i); t
(A) ta → ts (u); etc.), each row corresponds to the first consonant. The first row consists of 5 syllables corresponding to each 5 vowels without the first consonant. The eighth line consists of palatalized vowels "ya", "yu", and "yo" (YI and YE are not used in modern Japanese). Classification phonetic symbol ""
The and “°” are used to indicate consonant pronunciation changes, which usually indicate unvoiced changes to voiced consonants. Figure 3
Reference numeral 0 indicates a syllable formed by adding the divided phonetic symbols "" and "°" to the syllable of FIG. The smaller versions of the syllables "ya", "yu", and "yo" also have syllables consisting of the corresponding consonants and palatalized vowels (for example, "ki" to display "kya", small "ya" (Successor)
29 and 2 can be used in combination with the syllable in the second row or column "i". These syllables with palatalized vowels are therefore shown in FIG.
Written as a pair of kana as indicated by 1, which includes forms written with a segmented diacritic.

The Japanese dictionary editing order is usually the first column of FIG. 29 (corresponding to vowel A), that is, "a", "ka",
"Sa", "ta", "na", "ha", "ma", "ya",
"La", "I", the order of the syllables of "I" (sequence (Sea
Kens) ), where each of these syllables (except for a particular pronunciation) is the vowel "a" in that order,
It represents a subclass of up to 5 syllables consisting of "i", "u", "e", and "o". Currently, products such as cellular phones that require Japanese text input typically use the multi-stroke specification method, where each of the nine keys is in the first nine rows of each ("A" to "R"). )is connected with. A number of keystrokes are used to indicate which syllable of the corresponding row of syllables is intended, where each additional keystroke is progressively converted into a letter to produce a syllable of FIG. Output to the character that appears in the next column. A key separation or timeout method is used to allow the entry of consecutive codes associated with the same key. The tenth key is the syllable “wa”, “o”, “n”,
Used for Katakana "bo" symbols that indicate vowel-only syllables that repeat the vowels of the preceding syllable. The small “ya”, “yu”, “yo”, and also “ya” keys are related,
Requires additional keystroke selection. Additional keys are commonly used to add a segmented diacritic after the syllable.

Inputting Japanese hiragana (or katakana) using a miniaturized keyboard continues to be a challenging problem. With the current multi-stroke method described above, the generation of one kana syllable requires, on average, at least three keystrokes. Having a palatalized vowel represented by two letters (ie, the second column of FIGS. 29 and 2 followed by the small “ya”, “ju”, “yo”, or “i” column) Syllables need to make up to eight keystrokes. Therefore, it is desirable to develop a miniaturized keyboard system that minimizes the number of keystrokes required for entering hiragana and is easy to use and intuitive.

Typing of standard Japanese text containing Chinese characters (Kanji) in addition to Kana is an even more challenging problem. Text input on a standard computer with all keyboards and a large display usually corresponds to each hiragana syllable as shown in Figure 29-31, which is the letter of the Latin alphabet (called "Roman" in Japanese). Realized by first typing the pronunciation of the desired text. When a character is typed, the input is automatically converted into the corresponding hiragana syllable and displayed on the screen. In many cases, the user will need to translate the text initially displayed as hiragana into the particular textual interpretation desired. The displayed hiragana represents a phonetic reading in which the kanji and the hiragana that the user actually wants to input are combined, and this conveys the meaning intended by the user. Since there are many homonyms in Japanese, there are many combinations that have the meaning of Kanji and Hiragana corresponding to the Hiragana input by the user. On a standard computer, a number of these alternative conversions can be displayed, where for example each alternative conversion is associated with a numeric key, whereby the keystroke is displayed in the hiragana entered. Convert to Kanji interpretation. The limited display size and the small number of keys available add additional complexity when attempting to configure this process for small handheld devices.

An alternative method of identifying hiragana entered on a miniaturized keyboard allows the user to enter each hiragana with one keystroke. Each key on the miniaturized keyboard is associated with a number of hiragana characters. When the user makes a series of keystrokes, there is ambiguity in the resulting output because each keystroke represents one of several hiragana characters. Therefore, the system must provide a means by which the user can effectively indicate which of the possible interpretations of each keystroke is intended. Several methods have been proposed to resolve keystroke sequence ambiguity.

Many proposed methods for determining the exact character order corresponding to ambiguous keystroke order are John L.
Article by Arnott and Muhammad Y. Javad (Probabilistic
Character Disambiguation for Reduced Keyboards Usi
ng Small Text Samples ”Journal of the Internation
al Society for Augmentative and Alternative Commun
ication (hereinafter referred to as "Anott's literature"). Annot's reference notes that the majority of disambiguation methods use known related-language character-order statistics to resolve character ambiguity in a given context. That is, existing disambiguation systems statistically analyze clear keystroke groups as they are entered by the user to determine the proper interpretation of the keystrokes. Annot's article also notes that some disambiguation systems attempt to use word-level clarity for decoding text from a miniaturized keyboard. The process of disambiguating at the word level completes a word by receiving a clear code (letter) signifying a possible ending and then comparing the entire sequence of received keystrokes with a possible match with a dictionary. To do. Annot's literature discusses the drawbacks of many word-level disambiguation techniques. For example, word-level ambiguity often fails to correctly decode words due to the limitations of identifying rare words and the inability to decode words that are not in the dictionary. Due to decryption restrictions,
To eliminate word-level ambiguity, we do not provide error-free decoding in unlimited English text, which is the efficiency of one keystroke per character. Therefore, Annot's literature concentrates on disambiguating at the character level rather than disambiguating at the word level, and eliminating character-level ambiguity seems to be the most promising technique for disambiguating. Is indicated. However, in contrast to alphabetic languages, Japanese hiragana characters represent syllables rather than the single character that is essentially a phoneme.
For this reason, character-level clarity is inefficient in Japanese because there are almost no restrictions on the possible order of hiragana, and the probability distribution of hiragana order is not well-fitted effectively by this method.

Yet another proposed method is IH Witten
Textbook by (“Principle of Computer Spee
ch ”, Academic Press, 1982 (hereinafter“ Witten method ”
And))). Witten is 24,500
Approximately 92% of English dictionaries of words recognize that there is no ambiguity when comparing keystroke sequences to dictionaries. However, when ambiguity occurs, Witen notes that these must be resolved with each other by a system that presents the ambiguity to the user and requires the user to make a selection with multiple ambiguous inputs. . Therefore, the user must respond to the system's prediction at each ending. Such a response slows the efficiency of the system and increases the number of keystrokes required to enter a given text segment.

In the case of Japanese, a user of word processing software must select a subsequent word entry from a large number of ambiguous interpretations because of the large number of homonyms in the language. The same order of kana can often be translated into two or more different kanji interpretations. Therefore,
After entering the kana order, the user is typically required to select the desired Kanji translation from a set of possible choices, and often it is also necessary to ensure that the correct translation is selected. When hiragana is entered using a miniaturized keyboard, there is ambiguity about what the user actually intended as the order of hiragana converted to kanji. As a result, the number of possible interpretations is greatly increased.

Disambiguation of ambiguous keystroke sequences continues to be a challenging problem. As noted in the above-referenced article, a satisfactory solution that minimizes the number of keystrokes required to enter a segment of text is required to be acceptable for use in a portable computer. You cannot get efficiency. Therefore, it is desirable to develop a disambiguation system that resolves keystroke ambiguities that are simple and that are entered within the easy context of the user interface while minimizing the total number of keystrokes required. Such systems thereby maximize the efficiency of text entry.

An effective miniaturized keyboard input system in Japanese must meet all of the following criteria:
First, the arrangement of Japanese syllables (kana) on the keyboard and the way they are generated should be easy for Japanese speakers to understand and learn how to use. Second
In addition, the system must minimize the number of keystrokes required to enter text, thereby enhancing the efficiency of miniaturized keyboard systems. Third
In addition, the system must reduce the cognitive burden on the user by reducing the amount of attention and decisions needed during the input process. Fourth, this method should minimize the amount of memory and processing resources required to make a practical system.

Kisaichi et al. [JP 8-314920; US 5,786,776; E
P 0 732 646 A2] is the keypad 1-0 of the telephone keypad, with Hiragana syllables {Aueo}, {Kakikukeko},
{Sashisuseso}, {Tachitsuteto}, {Nanunnene},
Disclosed is a method labeled with {ha hifuheho}, {mamimumemo}, {yayuyo}, {rarirelero}, {waon}. This is key 1 on the phone keypad
9 are hiragana syllables "a", "ka", "sa",
It supports the de facto standard of Japanese telephone keypads labeled "ta,""na,""ha,""ma,""ya," and "ra." One hiragana represented on each key corresponds to the entire row of hiragana found in Figure 29, where one hiragana is displayed in the first column, of the complete set assigned to that key. It represents Hiragana. The 0 key is often explicitly labeled as {Won}.

Kisaichi et al. Disclose a method of disambiguating word-level ambiguity, where the user blurs the order of characters (hiragana) by pressing a key where each character is associated once (time). To enter. At the end of each input sequence, the user presses the "translate / next candidate" key to display the first verbatim interpretation of one of the possible hiragana sequences for the input key sequence. Kisaichi describes a dictionary structure in which all verbatim interpretations of a given input key sequence are stored consecutively in adjacent blocks of memory. When the "transform / next candidate" key is additionally pressed, the key displays the next verbatim interpretation stored in the dictionary, if it exists.
If there is no verbatim interpretation, an error message is displayed and optional anomalous processing may be performed. When the desired verbatim interpretation is displayed, a special "confirm" key must be pressed to ensure that the desired text is being displayed before the user can continue entering the next text object. .

The method described by Kisaichi et al. Has many drawbacks. One is to specify the hiragana string,
Due to the fact that there is ambiguity both in the transformation of each possible hiragana candidate string, there are likely to be many possible verbatim interpretations in a given key sequence. This requires the user to go through multiple interpretations using the "transform / next candidate" key to find the desired interpretation. Further, through the possible interpretation steps, the user observes different Kanji and / or Hiragana strings corresponding to different Hiragana strings due to input ambiguity. This is tedious and requires additional attention from the user trying to find the desired interpretation. Further, the word-for-word interpretation database is such that all data consist only of complete words, and all data of all key sequences of a given length are also stored contiguously in memory. Kisaichi
Et al. Do not describe how to make it possible to display the appropriate stems corresponding to long, but incomplete words at these points in the input sequence that do not correspond to any complete word. At these points during input, Kisaichi et al.'S system can only display default instructions for each key entered, such as numbers or default letters or signs. This confuses the user and does not provide effective feedback to the user to confirm that the desired key is being entered. Eventually, the user will have a “confirmation” for each word input.
A key press is required and an additional keystroke must be entered for each input. Therefore Kisaic
The system disclosed by hi does not meet the above criteria.

Another important challenge facing applications that eliminate word-level disambiguation is to do this properly on the kind of hardware platform that is most convenient to use. As mentioned above, such devices include two-way pagers, cellular phones and other handheld wireless communication devices. These systems are battery powered and consequently are designed to be as economical as possible in hardware design and resource utilization.
Applications designed to operate in such a system should minimize both processor bandwidth usage and memory requirements. These two factors usually tend to be contradictory and related. A system that eliminates word-level disambiguation requires a large database of words to work, and it must respond quickly to input keystrokes to give a proper user interface, so the processing time required to use it It is very effective to be able to compress the required database without significantly affecting the. For Japanese, additional information must be included in the database to assist the user in converting the kana order to the desired kanji.

Another important challenge facing applications that eliminate word-level disambiguation is to give the user sufficient feedback about the keystrokes entered. With a typical typewriter or word processor, each keystroke represents a particular character that can be displayed to the user immediately upon typing. But,
To eliminate word-level ambiguity, this is often not possible because each keystroke represents a large number of letters and any order of keystrokes matches a large number of words or word stems. Therefore, it is desirable to develop a system for disambiguation that minimizes the ambiguity of entered keystrokes and maximizes the efficiency with which a user can resolve the ambiguity that occurs during text entry. One way to increase user efficiency is to provide appropriate feedback for each keystroke, which involves displaying the most probable word for each keystroke, which is the current keystroke. If the order does not correspond to a complete word, display the most probable stem of a word that has not yet been completed.

[0021]

In order to manufacture an effective miniaturized keyboard input system for Japanese, a system must be designed that meets all the above criteria. First, the arrangement of Japanese (kana) syllables on the keyboard and the way they are generated should be easy for the Japanese to understand and learn to use. Second, the system needs to minimize the number of keystrokes required to enter text. Third
In addition, the system needs to reduce the amount of attention and decisions needed during the input process and reduce the cognitive burden on the user by providing appropriate feedback. Fourth, the method described herein requires minimizing the amount of memory and processing resources required to implement a practical system.

[0022]

SUMMARY OF THE INVENTION The present invention provides a miniaturized keyboard using word-level disambiguation techniques to resolve keystroke ambiguity and enter text in Japanese. . The keyboard may consist of full size mechanical keys, such as on a standard telephone keypad, preferably twelve keys arranged in 3 columns by 4 rows. Alternatively, the keyboard can be configured with a touch sensitive display panel, where touching the display surface produces an input signal to the system corresponding to the touched position.

A plurality of kana characters or symbols are assigned to at least some of each key, so that the user's keystrokes are ambiguous. The user enters a keystroke sequence, each keystroke intended to enter a one-character kana. Therefore, each keystroke sequence is intended to represent a phonetic representation of a word or common phrase (hereinafter referred to as "reading" in Japanese). Since individual keystrokes are ambiguous, the keystroke order potentially matches one or more readings with the same number of pseudonyms.

In order to match the order with the corresponding readings,
The keystroke order is processed by comparing it with one or more stored vocabulary modules. The various readings associated with a given key sequence are stored in the vocabulary module in an order determined by the predicted frequency of use in common use, and the predicted frequency of reading is common use (hereinafter, It is calculated as the sum of the usage frequencies of all possible word-for-word interpretations of its reading (including words consisting of Kanji, Hiragana, Katakana or combinations thereof) in the Japanese "headword"). In another preferred embodiment, the readings and headwords are initially stored in an order determined by their predicted frequency of occurrence in common use,
This order is changed to reflect the actual frequency of use by system users. The most frequent readings that match the keystroke sequence and correspond to at least one complete word or phrase are automatically identified and shown to the user on the display as each keystroke is received. If there is an incomplete word or phrase whose reading does not match the order of the keystrokes, the most commonly used keystrokes of the incomplete word or phrase are automatically identified and shown to the user on the display. . The term "selection list" is commonly used to mean any list of verbatim interpretations (readings or lemmas) generated by the system, corresponding to an input keystroke sequence. On devices that have sufficient display area available (hereinafter referred to as "large screen devices"), the selection list may be shown (wholly or partially) in the "selection list area" of the display. On such a device, when each keystroke is received,
The different readings corresponding to the input order are simultaneously presented to the user in a list on the display, in the order of predicted highest to lowest selection list area. On devices with limited display area, the selection list is maintained internally and the text objects of the list are displayed one at a time in response to the activation of the selection keys described below. For each reading or headword in the stored vocabulary module associated with one or more alternative verbatim interpretations, the headwords are stored in order of decreasing expected frequency of use in common use, and thus are most common. The headwords used by are shown first. As briefly mentioned above, in an alternative embodiment, the system retains a memory of the headwords that the user has selected to output most frequently,
Reorder the display to show the most frequently selected headwords first.

According to one aspect of the invention, the user presses the unambiguous select key to define the sequence of keystrokes entered. After receiving the select key, the disambiguation system automatically selects the most frequently occurring reading and appends a kana to the constructed text as the user continues to enter additional text. By default, the reading is shown on the display in the form of hiragana, except when the kana is not one of several katakana that does not have a corresponding hiragana (eg "V"). In another embodiment,
The readings are displayed in katakana form, or in some alternative keyboard layouts or romaji forms described below.

According to another aspect of the invention, the select key pressed to define the end of the keystroke sequence is also used to select a reading that is less common. If the most commonly used reading shown on the display is not the desired reading, the user presses the Select key again to transition from the most frequently read to the next most used reading, which Replace the displayed reading. If this is not the desired reading, the user again presses the select key to move to the third most frequently used reading. By repeatedly pressing the select key, the user selects the desired reading from the stored vocabulary module. According to another aspect of the invention, when the last reading found in a stored vocabulary is reached,
The first and most frequent reading is displayed again and the cycle repeats.

In accordance with yet another aspect of the invention, each keystroke in the input sequence is also interpreted as a number associated with that key, whereby the last item displayed for the associated reading corresponds to the input key sequence. Is the number to do. This number is selected for the output, thus eliminating the need for a separate number mode in the system.

According to another aspect of the present invention, once the user selects the desired reading corresponding to the input key sequence, the desired entry word is the same as the selected reading and is already displayed on the display as a kana text. , (Ie no conversion is required), the user simply presses and holds the key corresponding to the next desired text to be entered. No additional commit or conversion keystrokes are required and the selected text has already been temporarily sent to the display for output, which has been explicitly changed (eg by additional pressing of the select key). If not, it remains as part of the output text. The user can immediately continue to enter additional trailing text, move the text cursor position, or select some other system function. If the desired headword is not the selected reading on the display, ie the desired headword consists of Kanji, Kanji + Hiragana or Katakana,
The user presses the conversion key until the desired entry word is displayed. First (default) displayed after key sequence is entered
If the reading of is the desired reading, the user does not need to press the selection key, but may immediately press the conversion key to obtain the desired entry word.

The present invention discloses a method for explicitly generating Japanese syllables from ordered keystroke pairs on a miniaturized keyboard in such a way as to meet the above two criteria. First, the arrangement of Japanese (kana) syllables on the keyboard and the way they are generated is easy for the Japanese to understand and learn to use.
Second, this arrangement minimizes the number of keystrokes required to unambiguously enter Japanese syllables. In this aspect of the invention, the order of the two keystrokes is entered to unambiguously identify each syllable, including the syllable having the palatal vowel shown in FIG. 31, which is written in two kana. It

The input sequence of keystrokes is interpreted as a pair of keystrokes in which a character is selected according to the position of the two-dimensional matrix. The first keystroke of each ordered pair identifies the row of the matrix in which the desired character appears and the second keystroke of each pair.
The keystroke of specifies a column. First of the matrix
The organization of the characters in the five columns is based on the method in which the Japanese syllabary is learned and conceptualized by a Japanese speaker as shown in FIG. Corresponding to a natural model of the manner in which syllables with palatal vowels (each combination of two kana) are formed, which are usually considered as separate matrices from the basic syllabary (FIG. 31). In the method, two additional rows may be organized. First
Two additional columns may be added to handle the two special cases (small "tsu" and "n") that do not fit the simple pattern of the eight columns of. These two characters may be managed somewhat differently in various alternative embodiments. The simplicity and logical organization of this matrix method is
Allows the matrix to be used even when there is no display available to give feedback to the user. When the display is enabled, the matrix can be used to organize the manner in which feedback is provided to perform system operations transparent to the user.

The Japanese syllabary has 108 syllables (small "tsu", "ya", "ju", and "yo" are written in different ways and are pronounced differently. "Ya",
"Yu" and "yo" are counted as different syllables). The vowel syllable "a" mainly used in katakana,
There are some additional syllables that are less used, such as the small syllables of "i,""u,""e," and "o." These less used syllables may also be easily generated using the matrix system as described above. Thirty-seven of the 108 syllables are generated by simply adding one of the diacritical marks (") or the semi-voiced marks (°) that are segmental phonetic symbols to the other 71 syllables. These 71 syllables without piecewise diacritics can be logically organized into a single matrix of 9 or 10 rows and 8 to 10 columns.
The keys on the miniaturized keyboard of the present invention are labeled with two kana, one representing a consonant for a given matrix row and a second kana representing a vowel for a given matrix column.

This organization is logical in 106 out of 108 syllables and intuitive to the Japanese speaker, and the method of generating the remaining two syllables, namely the small "tsu" and "n" is simple and learned. It's easy to do. Every syllable, including a syllable with a palatal vowel represented by two separate kana, is generated by a pair of keystrokes. This allows for a much smaller number of keystrokes on a miniaturized keyboard than required by the multi-keystroke methods currently used to enter Kana. Accordingly, the present invention provides a miniaturized keyboard that is easy for the Japanese to understand and learn quickly, which is effective in reducing the length of the input keystroke sequence.

In another aspect of the invention, both the ambiguous or unambiguous method of identifying syllables as described above,
The input methods may be combined to achieve greater effectiveness. In a preferred embodiment, the first syllable of each word or phrase generated is unambiguously specified by entering a pair of ordered keystrokes using the matrix method as described above, The remaining syllables of the word or phrase are ambiguously identified by one keystroke at each syllable using a method of disambiguating at the word level.

In yet another aspect of the invention, multiple interpretations of the keystroke sequence are provided to the user in a selection list. The keystroke sequence is interpreted as forming one or more words, where the most frequently used corresponding word is displayed, and other corresponding words may be displayed in the selection list. At the same time, keystroke sequences are interpreted as numbers (as described above), as words entered using the two-stroke method of the present invention or the well-known multi-stroke identification method, and as stems of incomplete words. To be done. On large screen devices, multiple interpretations are simultaneously presented to the user in a selection list area for each keystroke in the keystroke sequence entered by the user. On any device, the user may select from different interpretations by pressing the select key multiple times.

In yet another aspect of the invention, a database of words and phrases used to clarify the input key order is stored in the vocabulary module using a tree data structure. The word corresponding to a particular keystroke sequence consists of data stored in a tree structure in the form of instructions. An instruction is a direct preceding keystroke order (ie a specific keystroke order except the last keystroke)
Change the set of words or the stem of the word, thereby generating a new word set and word stem for the keystroke sequence to which the current keystroke has been added. The construction of words in this way reduces the storage space of the vocabulary module, since the instructions for building the word stem at the top of the tree structure are stored only once and shared by all words made up of word stems. The tree structure significantly reduces the need for processing, as no search is required to locate stored objects, ie words and word stems. The objects stored in the tree data structure may include frequency or other ranking information indicating which objects are initially displayed to the user, further reducing the need for processing. Moreover, when the database is used to retrieve objects related to the keystroke order, this tree data structure does not incur any additional processing burden, and this tree data structure has a special algorithm to further compress the total dimensions required for the database. May be changed using.

In yet another aspect of the present invention, the tree data structure includes two types of instructions. The first instruction produces a reading of a word or phrase stored in a vocabulary module consisting of a kana order corresponding to the pronunciation of the word or phrase. This corresponds to each reading is the list of the second instruction, and generates the entry word for each reading. Each reading is generated by a first instruction that modifies one of the readings with respect to the immediately preceding keystroke sequence. Similarly, each lemma is generated by a second instruction that modifies one of the lemmas with respect to the reading modified by the first instruction with which the second instruction is associated.

The internal logical representation of the keys in the preferred embodiment need not reflect the physical arrangement represented by the actual key labels. For example, in a database configured to represent the Japanese vocabulary module, four additional letters (I, U, E, O) are associated with a key labeled with only one letter "a". May be. Similarly, letters with special diacritics such as dakuten and semi-dakuten ("and °) can also be associated with one key. For example, letters (ki, ku, ke, ko, ga, gi, gu, ge,
5) may also be associated with a key that is labeled with only one letter "ka". This allows the user to easily recall and type words that contain letters with diacritics, one character at a time by simply activating the logically related physical key of the associated glyph character. Perform key activation only once.

Further, in another aspect of the present invention, greater database compression efficiency is achieved by storing each Kanji character only once in the database structure for any particular associated reading. In general, a database contains multiple different examples of the same Kanji with the same reading (eg, "animal" (animal) and "plant" (shokubu) kanji "object" (read as "butsu")). I'm out. In a preferred embodiment, starting from the root portion of the tree structure, each reading for a given Kanji is included in the database, with all identifications of the Kanji code. Other Kanji that have the same reading in the database (not starting directly at the root of the tree structure) are limited by indirect criteria, which is a list of headwords for readings that start directly at the root of the tree structure. Identify the relative positions of well-specified kanji.

Assigning a large number of letters to keys, defining a word using the select key, selecting the desired reading using the select key and optionally following the desired headword using the transform key. Selection, display of the word or word stem most commonly used as the first word of the selection list, containing multiple interpretations in the selection list, and ordering by the first keystroke of subsequent words. Automatic addition of selected words, the ability to compress large databases for clarity without incurring significant processing penalties, and segmented pronunciation by typing keys associated with letters without diacritics The effect, combined with the ability to generate words with signed letters, has yielded astounding results: in Japanese, 99% of the words seen across text material displays are non- It can be typed in the system at a high efficiency. On average, one for each possible basic pseudonym (ie, 50 keys, including the keys shown in Figure 29, and the small "tsu", "ya", "yu", "yo"). When using the miniaturized keyboard of the present invention, which has only 12 additional keys with only 0.61 additional keystrokes per word compared to typing text on all keyboards including keys. Needed for. On average, the system actually requires fewer keystrokes compared to a typical keyboard where kana is entered by spelling out the desired word using romaji. Additional keystroke savings can be realized when words include letters with diacritics.
When words are presented in order of frequency of use, the desired word is most often the first presented word and often the only presented word. The user can continue to enter the next word without the need for additional keystrokes.
Therefore, high speed entry of text is achieved using a keyboard with a small number of keys.

The miniaturized keyboard disambiguation system described herein reduces the size of the computers or other devices that make up the system. Due to the reduced number of keys, the device can be configured so that the user can move with one hand while holding it with the other hand. The described system is particularly convenient for cellular phones, PDAs, two-way pagers, or other small electronic devices that benefit from accurate and fast text entry. The system effectively compresses large databases for unambiguous keystroke sequences without the need for additional processing bandwidth when using compressed databases. When configured into a touch screen based device or a device with a limited number of mechanical keys with a limited display screen area, the system can provide both efficiency and simplicity.

[0041]

DESCRIPTION OF THE PREFERRED EMBODIMENTS (Description of Blocks Shown in Flowcharts) Before describing the embodiments of the present invention, the blocks of the flowcharts in the attached drawings will be described. Figure 7: 150 ... Wait for key input 151 ... Is the key input a mode selection key? 152… Is the key input a selection key? 152A ... Is the key input a conversion key? 152B ... Is the selection list empty? 153 ... Is the keypad mode flag set? 154 ... Add keystrokes to keystroke sequence 156 ... Identify corresponding reading object in vocabulary module 158 ... Prioritize between object lists from different vocabulary modules according to system mode of operation 160 ... Same vocabulary module 163 prioritize objects from ... Is the selection list empty? 165 ... Display the selection list, tentatively select the first reading, and display it in the selection list and the insertion point 166 ... Is there an item selected in the selection list? 167 ... Accepts the provisionally displayed entry as an interpretation of the previous keystroke sequence in the text area and converts it to normal text 168 ... The keypad mode and the output of obvious characters based on the keystroke 169 ... The keypad mode is Will it be changed automatically? 170 ... Return the keypad mode flag to the previous value 171 ... Update the display as needed for the new mode 172 ... Set the keypad mode flag 173 ... Has the keypad mode changed? 174 ... Marks the first reading in the selection list as the selected item and tentatively displays text at the insertion point 175 ... Waits for key input 176 ... Is the key input a selection key? 177 ... Is the key input a conversion key?

FIG. 8: 178 ... Proceed to next reading in selection list and mark as selected item 179 ... Temporarily display reading selected in selection list and at insertion point 180 ... Temporarily displayed entry 184 is accepted as the keystroke sequence interpretation for the text area 184… Clear the old keystroke sequence 190… Mark the first headword associated with the current reading as the selected item in the selection list and enter the headword text. Display at insertion point 191 ... Wait for key input 192 ... Is the key input a selection key? 193 ... Is the key input a conversion key? 194 ... Go to next headword associated with current reading and mark as selected item 195 ... Temporarily display selected headword in selection list and at insertion point 196 ... Currently selected heading Go back to the reading associated with the word and mark it as the selected item

FIG. 20: 600 ... Retrieval of object retrieved from vocabulary module by key operation list (RETRIEVE) Subroutine start 602 ... CLEAR new object list 604 ... Point to root node of tree 606 ... Get first keystroke 608 ... Call subroutine to process key entered with current key 610 ... All keystrokes processed? 612 ... Get next key input 614 ... Return to new object list

FIG. 21: 620 ... Subroutine start 621 for processing key input ... 621 ... Read valid key bit field of current node 622 ... Is key input valid? 624 ... Return to old object list 626 ... Copy new object list for old object list 628 ... Call first valid key instruction 630 ... NEW_INDEX = 1 632 ... Referenced instruction to call old object list Using the OBJECT-LIST-INDEX field of 634 ... Directive using the LOGICAL-SYMBOL-INDEX field,
Add a symbol (SYMBOL) from the current key to the called object 636 ... Enter a new object list at the NEWS-INDEX position Accumulate changed (MODIFIED) objects 638 ... STOP-FLAG Did you give instructions? 640 ... Call a new valid instruction 642 ... Increase NEW-INDEX 644 ... Follow a pointer for a child node 646 ... Return to new object list

FIG. 22: 650 ... Start 652 ... Specify additional ambiguous symbols for their associated keys 654 ... Count the frequency of use of symbols in the vocabulary list 656 ... their logic by decreasing frequency Order of symbols by dynamic key 658 ... Build a tree from vocabulary list 660 ... Enter tree folding subroutine 662 ... All unused child nodes for most used nodes Point to the pointer. 664 ... Using Hoffman Encoating, specify a bit length pattern with a minimum length indication and address. 666 ... Writing data to file 668 ... End

FIG. 23: 670 ... Initiate FOLDING subroutine 672 ... NODE-A is shown at the first node after the root node (POINT). 674 ... The subroutine tree searches the instruction and SUB-NODES for the node with the highest redundancy associated with NODE-A. 676 ... Did you find the purpose (DESTINATION)? 678 ... NODE-A and its S in Ricoh Sively
680 to merge UB-NODES for the purpose ... Is the NODE-A point the last node? 682 ... NODE-A is shown as a node in the next tree 684 ... Return

FIG. 24: 690 ... Start of tree search subroutine for maximum redundancy Redundancy (ARGUMENT): NODE-A 692 ... MAX-SAVINGS = 0 694 ... NODE-B shown as root node 696 ... NODE-A and NODE-B Redundancy calculation subroutine 698 ... Is redundancy greater than MAX-SAVINGS? 700 ... BEST-NODE = NODE-B, MAX = SAVINGS = REDUNDANCY 702 ... NODE-B was shown at the last node? 704 ... NODE-B is shown at the last next tree node 706 ... Return to MAX-SAVING and BEST-NODE

FIG. 25: 710 ... Redundancy calculation of two nodes: NODE-A, NODE-B subroutine start 712 ... SAVED_INSTRUCTIONS = 0 714 ... LET KEY_INDEX = 1 716 ... Input instruction from the (KEY_INDEX) key 718 ... Enter in the LIST-B from the (KEY_INDEX) key of the NODE-B 720 ... Is both lists empty? 722 ... Get instructions from each list 724 ... Ignore STOP-FLAGS and agree to give instructions? 726 ... Return to failure 728 ... Increase SAVED_INSTRUCTIONS 730 ... Done with last key? 732 ... Increase KEY_INDEX 734 ... LET KEY_INDEX = 1 736 ... Get pointers from (KEY_INDEX) key of NODE-A and NODE-B 738 ... Both pointers are empty? 740 ... Recourse for calculating child node redundancy (RECURS
E) Do 742 ... Did comparison fail? 744 ... Return to failure 746 ... Store SAVED_INSTRUCTION 748 ... Last key done? 750 ... Return to SAVING 752 ... Increase KEY_INDEX

(System Configuration and Basic Operation) Referring to FIG. 1, a keyboard device according to the present invention for allocating two or more characters to one key to reduce the ambiguity and to reduce ambiguity is provided. Mobile phone 5 with
The components incorporated in 2 will be described. The mobile phone 52
Comprises a miniaturized keyboard 54 implemented by the buttons of a typical telephone. For the purposes of this application, the term "keyboard" is defined broadly to include all input devices, including touch screens with delimited input keys, discrete mechanical keys, membrane keys, etc. ing. The preferred pin arrangement on each key on keyboard 54 is shown in FIG. 1 and corresponds to the de facto standard for Japanese phones.

The keyboard 54 is in comparison with a standard QWERTY keyboard or FIG.
"Kana" in the basic Japanese character table shown in 9.
Note that there are fewer data entry keys than a keyboard with at least 46 keys, each of which has one key assigned to it. More specifically, the preferred keyboard shown in this embodiment has ten data keys, numbered 1 to 0, arranged in 3 columns and 4 rows, along with a select key 60 and a convert key 62. Is equipped with. Also optionally, the keyboard has a Clear key 64 to erase the previous keystroke,
Mode key 6 for entering a mode for entering unambiguous letters, numbers, or symbols
7, or a diacritic key 68 for adding a dakuten or a semi-dakuten as previously input may be provided.

Data is disambiguated via a keystroke on a miniaturized keyboard 54 (disamb system).
iguation system). In the first preferred embodiment, the text is displayed on the display 53 of the telephone as the user makes successive keystrokes using the keyboard. When the system is implemented in a device with limited display space, such as the cellphones shown in FIGS. 1 and 2, the currently selected or most likely words Only displayed at insertion point 88 in the text being generated. When the keys are pressed in succession to enter the desired word, the most probable word corresponding to the sequence of inputs is displayed in some characteristic form. In the preferred embodiment shown in FIG. 1, the currently entered word is displayed with a dotted underline. As described in more detail below, the dotted underline changes to a solid underline after the select key 60 or the convert key 62 is pressed.

In the second preferred embodiment shown in FIGS. 5 and 6, two areas are defined on the display 53 for displaying information to the user. Text area 6
6 displays the text input by the user as described in the first embodiment, and serves as a buffer for inputting and editing the text. As shown in FIGS. 5 and 6, the normal text area 66
The selection list area 77, located below, displays a list of words and other interpretations corresponding to a series of keystrokes entered by the user. The selection list area allows the user to view the most frequent interpretations of the sequence of keystrokes entered, along with other less frequent interpretations, in descending order according to frequency, from the keys entered by the user. Helps resolve input ambiguity.

Block Diagram of Hardware of Disambiguation System Using Reduced Keyboard
(diagram) is shown in FIG. The keyboard 54 and the display 53 are connected to the processor 100 via appropriate interface circuits. Alternatively, the speaker 102
Is connected to the processor. The processor 100 receives input from the keyboard and manages all output to the display and speaker. The processor 100 is connected to the memory 104. This memory includes a combination of temporary storage media such as random access memory (RAM) and fixed storage media such as read only memory (ROM), floppy disk, hard disk, or CD-ROM. Memory 104 contains all software routines for managing system operations. Preferably, this memory is the operating system 106 and the disambiguation software 10
8 and a vocabulary module 11 discussed in more detail below
Including 0. Optionally, this memory may contain one or more application programs 112, 114. An example of this application program is
There is a language / processor, software dictionary, and foreign language translation software. Speech synthesis software may also be installed as an application program, which allows the disambiguation system using a reduced keyboard to function as a communication assistant.

Returning to FIG. 1, the miniaturized keyboard that eliminates ambiguity allows the user to quickly enter text and other data with only one hand. The data is input using the miniaturized keyboard 54. Each data key from 1 to 0 has multiple meanings represented on the key by letters, numbers, and other symbols. (For those disclosed herein, each data key is identified by the numbers and letters displayed on the data key. For example, the upper right data key is identified by "3"). Keys have multiple meanings, so consecutive keystrokes are ambiguous in meaning.
As the user enters data, various interpretations of keystrokes are displayed in multiple areas on the display to help the user resolve ambiguities. On devices with large screens, a selection list of possible interpretations of entered keystrokes is displayed to the user in the selection list area.
The first entry in the selection list is selected as the default interpretation, and the text area 66
Is displayed at the insertion point 88 of. In the preferred embodiment, this entry is displayed with a dotted underline drawn below it at the insertion point 88 (and within the selection list area on devices with large screens). This form implies that this object is implicitly selected by being the most frequent object in the current selection list. The display is shown in Figure 5.
If it includes a selection list area as shown in FIG. 3, this form also visually associates the object at insertion point 88 with the object displayed in selection list area 77. In FIG. 1, the selection list is not displayed, only the default objects (the objects that would first appear in the selection list before the selection key is activated) or some objects are explicitly selected. If so, only the selected object is displayed at the insertion point 88.

The selection list of possible interpretations of the entered keystrokes may be ordered by various methods. In normal mode of operation, keystrokes are initially interpreted as kana entries that spell the reading corresponding to the desired word (hereinafter "word interpretation"). For example,
As shown in FIG. 5, continuous key inputs of “K”, “K”, and “K” are input by the user. As the keys are entered, the vocabulary module is referenced to find a reading that matches the continuous keystrokes. Readings are sorted within the vocabulary module based on frequency of use, with the most commonly used readings listed first in the reading list. Taking the previous example of continuous keystrokes, the readings "Kakaku", "Kikuku", and "Kikoku" are identified by the vocabulary module as the three most promising readings corresponding to that keystroke. . Of the eight identified readings in the selection list, "hiding" is the most frequently used. Therefore, it is treated as the default interpretation and is provisionally placed at the insertion point 88 as Hiragana text. As shown in FIG. 1, before the select key 60 is pressed, this first reading is treated as a default interpretation and is placed at the insertion point 88 using a unique format. This form indicates that instead of initiating a new keystroke, the next keystroke by one of the data keys is appended to the current key sequence. For example, as shown in Figure 1, this particular form is
It consists of displaying the reading as hiragana text with a dotted underline. A list of other possible readings is stored in memory and sorted according to their relative frequency of use.

In the preferred embodiment, the user simply presses the select key 60 following the entry of successive keystrokes corresponding to the desired reading. Insertion point 88
The dotted underline under "How to read the initial value" displayed in is replaced with the solid underline. When the reading of the displayed initial value is not the desired reading, the selection key 60 is repeatedly pressed until the desired reading appears. In one preferred embodiment, after all the readings that match the keystrokes in memory have been displayed by repeated activation of the select key 60, the keystrokes are interpreted as numbers,
Each keystroke produces a number printed on each key. This allows numbers to be entered without a separate numeric mode, and also serves as an easily recognizable display of the end of the reading interpretation selection list. Further pressing of the select key 60 will return to the first reading of the select list.

Once the desired reading is displayed and the desired "entry word" is actually the same as the "reading" already displayed in Hiragana, the user may wonder if it is the first reading of the next reading to be entered. Continue pressing the corresponding data key. On the other hand, if the desired “headword” is composed of kanji, kanji and hiragana, katakana, or a combination thereof, the user presses the conversion key 62. This replaces the displayed reading with the most frequently occurring lemma associated with that reading in the vocabulary module. When the conversion key 62 is repeatedly pressed,
The displayed headwords are replaced with those with a high frequency from those with a low frequency. Also in a preferred embodiment,
When all the "headwords" in the memory associated with the selected "reading" are displayed by repeatedly activating the conversion key 62, the selected "reading" is displayed in katakana. This makes it possible to generate katakana without using a separate mode, and
It serves as an easy-to-recognize indication of the end of the selection list for the "headword" interpretation. In another preferred embodiment, if the user desires to associate the default reading associated with a keystroke, the conversion key 62 is immediately pressed so that the desired entry word first selects the selection key 60. It is related without pushing.

Either the selection key 60 or the conversion key 62 1
By pressing one or both one or more times and then pressing any data key, the special form of "reading" or "headword" (in this preferred embodiment, the solid underline) is removed, The first keystroke of the new key sequence will be interpreted by the system.
No special keystrokes are required to confirm the interpretation of the preceding keystroke sequence.

In the preferred embodiment described above, pressing the select key 60 cycles forward through the readings in memory associated with the current key sequence (descending frequency). In another embodiment, select key 60
By continuously pressing for more than a predetermined time threshold value, the readings in the memory are cycled in ascending order of frequency. That is, if a numeric interpretation is included at the end of a series of associated readings in memory, as described above, immediately pressing and holding the select key prior to the normal press of the select key causes immediate Return to numerical interpretation. When the pressing of the selection key 60 is continued, the associated readings are cycled in the reverse direction in ascending order. Similarly, by continuously pressing the conversion key 62, the entry words associated with the currently selected reading are circulated in the reverse direction in ascending order. Similarly, the first conversion key press-continuation operation prior to the normal press of the conversion key 62 immediately causes a backward cycle of katakana interpretation.

With further reference to FIG. 1, in another preferred embodiment, upon entry of a data key, the clear key 64 may be pressed to delete the entered data key. Clear key 6 if all data keys in the current keystroke sequence have been deleted as a result.
Pressing 4 deletes the character on the text display 53 to the left of the insertion point 88 and displays the standard text cursor if the current selection list is empty. By pressing either the selection key 60 or the conversion key 62 or both one or more times, and then pressing the clear key 64,
Replaces the currently selected textual interpretation at insertion point 88 with the "reading" interpretation of the initial value of the current keystroke, but does not delete any of the data keys from successive keystrokes. In other words, if the clear key 64 is pressed after pressing the select key 60 and / or the convert key 62 several times, all the activations of the select key 60 and the convert key 62 are canceled and the select key 60 or the convert key 60 is canceled. Returns the system to the state just before the first key input. In another embodiment, if the select key 60 is pressed after the conversion key 62 is pressed one or more times, the “headword” currently selected at the insertion point 88 is associated with the “headword”. Replace with the read "How to read". When the selection key 60 is further pressed, another "reading" in the memory associated with the current key input continues to cycle from that position in the forward direction (descending order of frequency).

Also, in other embodiments, other means of generating unambiguous characters (such as typing in a special symbol mode or pressing a key explicitly associated with a single particular character). The activation of <?> Serves to terminate the current keystroke. As a result, the special form of "reading" or "headword" displayed at the insertion point 88 (dotted underline or solid underline in the above embodiment) is deleted, and the particular unambiguous character is deleted. Appended to the output word at the new insertion point 88.

By tentatively arranging the selected headword or reading at the insertion point 88 of the text area, the user can pay attention to the text area without referring to the selection list. When the first input of the selection key 60 (or the conversion key 62) is accepted by the user's selection, the “reading” (or “entry word”) provisionally placed at the insertion point 88 (in the vertical direction or the horizontal direction) ) It may be expanded to show a duplicate of the current selection list. The user can select the maximum number of words to appear in the duplicate of this selection list. Alternatively, the user
You may choose to have the selection list always displayed at insertion point 88, even before the first activation of the selection key. This disambiguating system uses the start of the next word (informed by the activation of an ambiguous data key or the generation of clear and unambiguous characters) as an affirmation that the selected input is the desired input. Interpret. Therefore, the selected word is the insertion point 8 as the user's choice.
Remaining at 8, the underline is completely gone and the word is redisplayed as normal text with no special formatting.

In most text inputs, continuous keystrokes are intended by the user as a form of kana reading. However, it will be appreciated that the multiple letters and symbols associated with each key may provide multiple interpretations for each keystroke or sequence of keystrokes. In this reduced keyboard disambiguation system, consecutive keystrokes are interpreted and displayed to the user as a list of words, while at the same time different interpretations are automatically determined and displayed to the user. .

For example, consecutive key inputs are interpreted in terms of the stem corresponding to a series of kana considered to be entered by the user (hereinafter "stem interpretation"). Unlike word interpretation, the stem is an incomplete word. By displaying the possible interpretations of previous keystrokes, the stem allows the user to easily see if he or she has typed the correct keystroke, and also if the user's attention is distracted while entering a word. You can also restart input. Suppose you have a sequence of keystrokes that corresponds to partial entry of a long word or phrase but not a complete word or phrase. In such cases, the most useful feedback that can be provided to the user is to display the kana corresponding to the stem of the word entered up to that point. In the example of FIG. 5, consecutive keystrokes "ka, ka, ka" can be interpreted as forming the stem "kakuki" (preceding the word "kakkin"). Therefore, this stem interpretation is provided as an entry in the selection list. Desirably, the stem interpretations are sorted according to the synthesis frequency of all possible word combinations that can be generated from each stem by the next keystroke with the data key. As a result, some of the stem interpretations may not be displayed.
When listing stem interpretations in the choice list, stem interpretations that overlap with the words displayed in the choice list are omitted.
However, if the stem is omitted, the word corresponding to the omitted stem may be marked with a symbol that indicates that there is a longer word that has the stem as the stem. The stemming provides feedback to the user by confirming that the correct keystrokes leading to the desired word entry have been made.

FIGS. 7 and 8 illustrate the ambiguity of processing selection lists and determining what is displayed at insertion point 88 to assist the user in unambiguous ambiguous keystroke sequences. It is a flow chart which shows the main routine of resolution software. Block 150
At, the system is waiting for a key input from keyboard 54. When the key input is received, the decision block 15
At 1, a test is made to determine if the received keystroke is a mode select key. If so, block 172 sets the flag to the current system mode.

At decision block 173, a test is made to determine if the system mode is changing. If so, at block 171, the display is updated as needed to reflect the current system mode.

If at block 151 it is determined that the key input is not a mode selection key, block 15
Moving to 2, a test here is made to determine if the keystroke received is a select key.
If the keystroke is not the select key, block 152A is entered where a test is made to determine if the received keystroke is a transform key. If the received key input is not a conversion key, block 153 is entered. The tests here are performed to determine if the system is in a special character mode, such as symbolic mode. If so, proceed to block 166, where a test is made to determine if there is a temporary selection item in the selection list.
If so, block 167 is entered and the item is accepted and output as normal text. Then, the process proceeds to block 168, and the character that matches the key input is output to the text area. Then,
Moving to decision block 169, a test here is made to determine if the system mode should be changed automatically, as in the symbol mode. If so, then block 170 is entered and the system mode returns to the previous active mode, else execution returns to block 150. If block 15
If explicit character mode is not active at 3, then at block 154, the keystroke is added to the stored keystroke sequence. At block 156,
The object corresponding to the keystroke sequence is identified from the vocabulary module in the system. The vocabulary module is a library of objects associated with a keystroke sequence. The object is a part of the accumulated data extracted based on the input key operation. For example, the objects in the vocabulary module are numbers, letters, words, stems, phrases, or system functions and macros. Each of these objects is
The following table briefly describes them.

[0068]

[Table 1]

As mentioned above, while preferred vocabulary objects are considered, other objects may also be considered. For example, a graphic object is associated with a stored graphic image, and a speech object is associated with a portion of a stored speech. Spell objects can also be envisioned as relating common misspellings or typos to the correct spelling. To simplify processing, each vocabulary module preferably comprises similar objects. Similar objects are recognized, but various objects may be mixed within the vocabulary module.

7 and 8, at block 156, those objects corresponding to the received keystroke sequence are identified in each vocabulary module. At blocks 158 through 165, the objects found by examining the keystrokes in the vocabulary module are prioritized to determine the order in which the objects are displayed to the user. To determine the order of the objects displayed in the selection list, priorities are established among each vocabulary module and among the returned objects from each vocabulary module.

Block 1 to prioritize the list of objects identified from the various vocabulary modules.
At 58, the mode of operation of the reduced keyboard disambiguation system is examined. As mentioned above, in the normal mode of operation, the word interpretation (reading and lemmas) is first displayed in the selection list. Therefore, object lists from vocabulary modules will be assigned higher priority than object lists from other vocabulary modules. Conversely, if the disambiguation system is in the numerical mode of operation, the numerical interpretation will be assigned a higher priority than other vocabulary modules. The mode of the disambiguation system thus determines the priority among the vocabulary module object lists. It will be appreciated that in some modes an object list from a vocabulary module may be omitted from the selection list entirely.

The object list generated from the vocabulary module may contain only a single entry, or they may contain multiple entries. At block 160, prioritization among objects from the same vocabulary module is resolved if the object list contains multiple entries. Objects that match a particular keystroke sequence examined in a given vocabulary module are also given priority to determine their relative rating with respect to each other. As explained above, the preferred standard presentation order is by reducing the priority of the most commonly used alternatives. The priority data associated with each object is used to order the objects in the selection list.

A number of details associated with the display of objects examined in the vocabulary module are programmable by the user by accessing the appropriate system menus. For example, the user can specify the order of individual objects or the desired class of the selection list. The user may also set priority levels that define priorities among vocabulary modules and among the objects identified from each vocabulary module.

After the priorities among the objects have been determined, at block 165 a selection list is assembled from the identified objects and presented to the user. As an interpretation of the ambiguous key input sequence initial value entered by the user, as shown in FIGS. 1 and 2, the first entry in the selection list is provisionally placed at the insertion point 88 in the text area 53 and highlighted. To be done. The disambiguation software routine then returns to block 150 to wait for the next keystroke.

If the detected key input is the select key 60, the “yes” option moves from block 152 to block 163. Here it is tested whether the current selection list is empty. If so, the process returns to block 150. If, at decision block 163, the selection list is empty,
It becomes a "no" option and proceeds to block 174. At block 174, the dotted underline below the default reading displayed at the insertion point 88 where it was temporarily posted is replaced with a solid underline. At block 175, the system then waits to detect the next keystroke entered by the user. Upon receipt of the key input, at block 176 a test is performed to determine if the next key input is a select key. If the next key press is a select key, then at block 178 the system will step through the select list to the next reading and indicate it as the current select item. At block 179, the currently selected entry is temporarily displayed at the insertion point with a solid underline. Routine then block 1
Returning to 75, the next keystroke input by the user is detected. It will be appreciated that the loop formed by blocks 175 to 179 allows the user to select different reading interpretations of the ambiguous keystroke sequence entered, but less frequently used. Will. This means that the frequency of use will decrease as the user presses the selection key many times.

If the next key input is not the select key,
At decision block 177, a test is made here to determine if the next keystroke is a conversion key. If the detected keystroke is a conversion key,
Proceed from block 177 to block 190 through the “yes” option. If the detected typing key is a conversion key, select the "yes" option and block 17
7, the first "headword" related to the latest "reading" is marked as a selection item and the "headword" text is temporarily displayed by a solid underline at the insertion point 88. Move to 190.
At block 191, the system is waiting for the next key press by the user. The test at block 192 is performed upon receipt of a key input to determine if the next key input is a select key. If the next keystroke is a select key, block 196 returns the currently selected item to the associated reading of the currently selected entry. Further display it as the selected item and proceed to block 179. If at block 192 the next key input is not the select key, then a test at block 193 is performed to determine if the next key input is a conversion key. If it is a transform key, then at block 194, the currently selected object is advanced to the entry word associated with the current reading and displayed as the selected item. At block 195, the currently selected midashigo is temporarily displayed at the insertion point 88 with a solid underline. The system also returns to block 191 to detect the next keystroke entered by the user.

If at block 177 and 193 the next key input is not a conversion key, the routine proceeds to block 180 where the temporary input displayed here is selected as the key input, or Displayed as normal text in the text area. At block 184, previous keystrokes are erased from system memory, and if an indeterminate key is entered after the select or convert key, the system will begin entering the next indeterminate entry at the beginning. Like If a new key entry has been made, block 154 begins a new key entry translation. Since the most frequently used reading candidate is shown as the default selection, the number of times the user presses the selection key can be minimized, and the text can be efficiently input.

(II. Unambiguous Text Entry System) Similarly, the miniaturized keyboard for Japanese input according to the present invention can specify the desired kana of each input request desired by the user. The Japanese syllabary has 108 syllables (small "tsu", "ya",
"Yu" and "yo" are "tsu" of normal size,
It exists as a character different from "or", "yu", and "yo", and is written and pronounced.) Furthermore, as syllables that are rarely used, small "a", "i", "u",
"E" and "O" exist. These are originally used only as katakana. These lesser used syllables can also be easily input from the system of the present invention, as described below. Of the 108 standard syllables, 37 can be entered by a diacritic or by simply adding one "" or "°" to one of the other 71 syllables. These 71 syllables without diacritics can be organized in a logical 9 matrix, or in 10 rows and 8-10 columns, described below. Most of the keys on the keyboard of the present invention are marked with kana. One that represents the consonants related by a matrix of a column and one that represents the vowels related by a column of the matrix 2
Classified with the second kana.

The structure is logical, and 106 syllables out of 108 syllables are intuitive to a native Japanese speaker, and the remaining two syllables (small "tsu" and "n").
Is simple and easy. Every syllable is two separate
It is created by a pair of key inputs, including palatalized vowels (eg, KYA, KYU, and KYO). For some keystrokes, the conversion results are displayed according to the commonly used input methods currently used. As described above, by using the keyboard of the present invention, a native Japanese speaker can be easily learned, and the time required for key input can be efficiently shortened.

In the embodiment of the present invention, 71 syllables in the Japanese syllable table are composed of the Japanese syllabary shown in FIG. In FIG. 32, when including all 69 syllables appearing in the first 8 columns, the first keystroke of the matching pair determines the consonant of the syllable to be output, and the second
The key input of determines the vowel. The remaining two syllables (small "tsu" and "n") are exceptional cases described next. The remaining 37 syllables not shown in FIG. 9 are displayed by generating the matching base syllables in the Japanese syllabary of FIG. 9 and then adding diacritical marks using individual keys. . In the schematic view of a mobile phone having a limited screen area shown in FIG. 2, an embodiment of the present invention relating to Japanese input is incorporated into a keypad (membrane keyboard). The ten keys on the keyboard, the respective keys 121 to 130 of the kana touched in the upper left of FIG. 2, correspond to “Key1” in FIG. 32, and the kana touched in the lower right corresponds to “Key2”. . In the embodiment of the present invention, the first key input is input at the upper left kana arranged in rows, and the second key input is input at the lower right kana arranged in vertical columns. As a result, the syllable in FIG. 32 is input. As shown in FIG. 2, there is shown a keyboard in which ten general keys are arranged in the upper left of the ten keys 121 to 130. The first five vertical rows of kana represent the lower right corner of the keys 121 to 125. The small “ya”, “yu”, and “yo” are the following three 126-128
Assigned to the key. Finally, a small "tsu"
Is assigned to the 129 key, and “n” is assigned to the 130 key. The diacritical mark can be input by adding a diacritic mark "" or "°" with the 131 key. When inputting diacritics with vowels (vertical column “I” in Table 4)
When a small "ya", "yu", or "yo" follows the
(Represented by two kana), the diacritical marks are immediately added and displayed after the two kana.

Thus, the first key operation that matches determines the consonant of the syllable and the second key operation determines the vowel. In another embodiment, the display is used to provide feedback to the user. Upon receipt of the first keystroke, the various syllables that can be confirmed and generated by the second keystroke are displayed. Keystrokes are associated by filtering each key associated with a number or other input key, such as a kana. Instead,
A syllable can be displayed (with a conversion candidate number, or
Don't connect). For example, in a device such as a cell phone with a text display, syllables can be displayed in a 3-by-3 matrix, such as an array of 1 to 9 telephone keys. When the display uses this method, the vowel syllables are small "a", "i",
You can easily enter rarely used syllables such as "u", "e", and "o". For example, in FIG.
As shown in FIG. 3, the matrix is used to match the vowels in the upper row of FIG. , “I”, “U”, “E”, “O” are displayed,
Small “a”, “i”, “u”, “ee”, “ぉ” are 6
It is associated with the ~ 0 key.

FIG. 3 shows a mobile phone having a text display, which is an embodiment of a keyboard miniaturized in Japanese. All the keys of the numeric keys 121 to 130 are
Based on FIG. 33, the kana is shown in the middle of the key. As shown in FIG. 3, ten columns of kana are displayed on the keys 121 to 130. Also, FIG.
Is a key whose display is 122 (“ka”,
"Ki", "ku", "ke", and "ko" are associated with each other to indicate an activated state.
In the embodiment, the syllable shown in FIG.
Displayed when a key with a kana over the active column key is operated. On the display, the second input keys for the conversion of the kana to be converted are displayed together. The vertical columns in FIG. 33 are represented by numbers on the keys of the mobile phone as shown in FIG. For the embodiment,
Three syllables including vowels (Kya, Kyu, Kyo) are 127-1
It is associated with 29 (in the key display, 7, 8,
(Assigned to 9), these can be displayed in rows and columns. This allows the user to associate these related syllables with the keys for ease of input and not only to associate the syllables with the numeric representation of the keys, but also with the syllables on the display and keys on the keypad. Can be associated with a matrix of 3 rows and 3 columns. Also, as mentioned above, the diacritical marks are 131
Pressing the key once adds "", and pressing it twice adds "°". When a diacritic is added with a vowel (a second key is associated on keys 127-129, as shown in FIG. 3), the diacritic is added immediately after the kana. Is displayed.

As shown in FIG. 5 and FIG. 6, in the embodiment of the present invention, when incorporated as a keyboard displayed on a touch screen of a portable computer,
The conversion candidates can be displayed. As shown in FIG.
The keyboard 150 can display the first key input in advance. As shown in FIG. 6, the keyboard 17
0 is "ka", "ki" as the first key input,
The "ku", "ke", "ko" can be displayed after the activated keystroke of the key 152 of FIG.

As shown in FIG. 6, keys 171 to 179.
Will be displayed along with the translated kana when the key is activated. The arrangement of keys and syllables uses a matrix of 3 rows and 3 columns as shown in FIG. 3, and as shown in FIG. 33, associating a syllable with a key can transform the syllable in advance. it can.

In another embodiment, as shown in FIG. 9, nothing is input by operating a key associated with an empty cell, and an error sound can be smoothed by the user's option setting. In another embodiment,
As shown in Fig. 2 (the key with a small "tsu" displayed), by pressing the key 129 twice, the small "tsu" is displayed.
Is entered. Also, in another embodiment, a small "tsu" key is used to input a small "tsu". Similarly, in another embodiment, the key labeled "n" inputs "n". Various transformations can be formed without changing the sound, for the purposes of the invention of FIGS. 32 and 4b.

For example, small "tsu" and "n" are exceptional cases, such as assigning them with a separating key that produces a small "tsu" when pressed once and a "n" when pressed twice.
It is specified by a wide variety of methods. Further, the important point of the present invention is that the first eight lines of FIG. 32 (or 1-5 of FIG. 33).
This is the detailed usage of syllables in lines 7 and 9).

Even if the assignment of the row label kana and the column label kana of the keys in the embodiment shown in FIG. 2 is the most natural, it is possible to use other combinations without departing from the scope of the present invention. It will be apparent to those skilled in the art that other embodiments of assigning key row row kana and column label kana are possible. 9 and 10 show some of many other possible implementations where the row and column label kana are assigned to keys by other arrangements.

In another embodiment, the system of the present invention may incorporate a keyboard having only nine keys, as shown in FIG.

68 of the 71 distinct syllables of FIG. 32 can also be constructed as shown in FIG. 34, where the row corresponding to the row label "or" is deleted. In such a nine-key system, three syllables "ya", "yu",
The "yo" is generated from a specified pair of key sequences, where the first key is the row label "a" corresponding to the cell in the first row of the table. The small "tsu" and "n" are generated from the key sequence corresponding to the cells of the last column, which includes the last two columns of FIG. 32 combined with each other.

Further, in another aspect of the invention, the system treats the next keystroke as a designated first pair of keystrokes (determination of the vowels of the output syllable).
Or provide the user with an indication of whether to be treated like a designated pair of second keystrokes (determination of consonants of the output syllable). For example, this indication is implemented as a pair of labeled LEDs that are alternately lit.
Instead, the two icons are displayed alternately on the display. It will be apparent to those skilled in the art that many other alternative embodiments of such instructions are possible without departing from the scope of the invention.

The effect of the combination of proper label placement on the keys as shown in FIGS. 2 and 6, the generation of syllables by the indicated pair of keystrokes, the designation as shown in FIGS. 3 and 6. Providing proper feedback following a pair of first keystrokes, a natural correspondence between key label organization and standard order and Japanese syllabary, and the next keystroke is a syllable consonant. Including instructions to the user whether to correspond to the kana of the row labels that identify the or the kana of the column labels that identify the vowels is useful for clear text input, and the correct input by the native Japanese speaker. With this, there is an effect that easy understanding and quick learning can be done. Typing text quickly can therefore be achieved by using a keyboard with a small number of full-sized keys, which is easy to learn and use.

III. Ambiguous and unambiguous keystrokes
Further, in another aspect of the present invention, a more efficient input method can be realized by combining both ambiguous and unambiguous syllables (ambiguous). In one embodiment, at user selection, the first syllable of the word to be entered is unambiguously identified using the two keystrokes. For syllables with vowels pronounced in the palate, these first two keystrokes are 2
Note that this results in the identification of three hiragana characters (including the small “ya”, “yu”, and “yo” that represent the vowels pronounced in the palate). The syllables of the remaining words or phrases are ambiguously specified with one keystroke for each syllable. For short words of one or two syllables, this combination method significantly reduces the conversion confirmation work on input, and consequently reduces the number of candidates that need to be tested to find the desired reading for the user. be able to. In yet another alternative embodiment, multiple stroke identification methods known in the art can be used to unambiguously identify only the first syllable of a word or phrase, and the remaining syllables are ambiguous. Will be confirmed.

In yet another embodiment using the ambiguous identification method of the present invention, the two-input method is for identifying a desired syllable of either a word or a phrase (rather than just the first part). Can be used. For example, pressing a key and passing it for a certain amount of time is a two-input two-key input to allow a direct keystroke to unambiguously identify the desired syllable.
Will indicate the second. This has two advantages. The first is that any syllable (rather than only the first syllable of a word or phrase) is unambiguously determined. The second is that the user can choose to unambiguously identify syllables only if this is considered to increase the efficiency of the input. , For all non-common words and phrases (and especially for short words) when all syllables are ambiguously specified,
The default display for the most commonly used words and phrases is
Multiple actions of the select key may be required to select the desired reading. In such a case, the user only needs to select from among the readings that share the same unambiguous, unambiguous syllable at the same position, so that the unambiguous identification of at least one syllable is sufficiently small. The result is that the request produces the desired reading.

IV. Text entry based on ambiguous keystrokes
A database structure of words and phrases used to define the input-order structure that supports force is stored in a vocabulary module using a tree data structure. The words that correspond to a particular keystroke order are stored in the tree data structure in the form of instructions that modify the word stem associated with the keystroke order with the word set and the new keystrokes associated with it. It is composed of data. Thus, each new keystroke of the sequence is made so that the set of instructions associated with that keystroke has a stem associated with the keystroke sequence having the word and its associated new keystroke. Used to create a new set. In this way, words and stems are obviously not stored in the database, and they will be constructed based on the key sequence used to access them.

For Japanese, there are two types of instructions in the tree data structure. The first instruction creates a reading of the words and phrases stored in a vocabulary module that is organized in a kana order that matches the pronunciation of the words and phrases. There is a second list of instructions that creates a headword associated with each reading corresponding to each reading. Each reading is created by a first instruction that modifies one of the readings associated with the immediately preceding keystroke sequence. Similarly, each lemma is created by a second instruction that modifies one of the lemmas associated with the reading modified by the first indication having a combination with the second indication.

Since each first instruction refers to a known key, the information associated with the special kana is stored as a logical index in the set of kana associated with the key. A typical diagram of a single key 540 is shown in FIG. The internal logical representation of the keys in the example need not reflect the physical arrangement. For example, 541 is the preferred logical notation for the key that is combined with the "" 2 "" key in the Japanese vocabulary module.The added notation (ki, ku, ke) shown at 542 in FIG. ,
This is also the one associated with the key. In addition, these characters are appropriately indexed in 543 of FIG. 11 in the order of decreasing frequency of use in the Japanese dictionary (ku, ki, ko, ke). The table shown in FIG. 12 shows the priorities displayed on the keys, and Japanese is used to confirm the input. By extension, FIG. 12 is a preferred table for a logical symbol index for a key index for unambiguous use in a Japanese keypress.

FIG. 12 shows a table corresponding to the preferred embodiment described in FIG. 1, which is a separate distinguished key 6.
It has 8 and is used when inputting a dakuten or a semi-dakuten in the previous character. Depressing the distinguished key 68 is ambiguous with respect to entering either the dakuten or the semi-dakuten before the kana. In another embodiment, the distinguished key 68 is unambiguous and to enter a dakuten, the distinguished key 68 is pressed once and twice consecutively at the semi-voiced point. In other methods, all kana (including characters with or without dakuten) are assigned to one fixed key and are shown in the same line in the character table. This means that the system that uses the database is key 6
Allow the use of 8 to be set arbitrarily.
In such a system, if the selection requiring the use of the distinguished key 68 is not made, the distinction key 68 is distinguished until it is pressed once (voiced point) or twice (semi-voiced point). No instructions are given to specify the addition of the.

Word Object Vocabulary Module 101
A typical view of 0 is shown in FIG. The data tree structure is used to place the conversion candidates in the vocabulary module based on the corresponding keystroke sequence. As shown in FIG. 18, each node of the vocabulary module tree, N001, N
002 and N011 represent a typical key input sequence. The nodes displayed in the tree are P001 and P0.
02 and P011 are connected. In the unambiguous system embodiment, there are 11 ambiguous data keys, so each parent node in the vocabulary module tree is connected to the eleven further child nodes below.

Nodes connected by a path indicate a valid key input order, while those without a path from a node indicate an invalid key input order. That is, it does not match any of the stored words. It should be noted that in the event of an invalid keystroke sequence, the example system can create and display a numerical display of the keystroke sequence entered. Displaying a numerical description (without pressing the select key) at the character conversion insertion point indicates that the word corresponding to the input key was not included in the vocabulary module.

The vocabulary module tree changes in a zigzag manner according to the received key input order. For example, when the second data key is pressed at the root node 1011, the data combined with the first key will be extracted from the inside of the root node 1011 and evaluated. Then, it moves to the node N002 through the path P002. Then, again pressing the second data key will cause the data associated with the second key to be retrieved from node N002 and evaluated, after which the path P to node N102.
Move to 102. Further, as will be described in detail below, each node is associated with a number of objects corresponding to the keystroke sequence. When the key input is received and the corresponding node is processed, an object list for the objects corresponding to the key input order is generated. The object list of each vocabulary module is used by the main routine of the unambiguous system to generate the selection list.

FIG. 13 is a block diagram of a data structure 400 associated with each node. The data structure is
It has the link information of each node in the vocabulary module tree and the child nodes below it. The data structure also includes information (instruction) for identifying an object represented by a node and associated with a typical keystroke sequence.

The first field in the node data structure 400 is a valid key bit field 402 indicating the number and identity of child nodes connected to the parent node, and the 11 valid key parent nodes are represented by nodes. The information (instruction) for identifying (structuring) the object associated with the specified key input sequence. In the embodiment of the present invention, since there are 11 data keys, at most 11 child nodes can be connected to any parent node, and thus 11 valid key information indicates the presence or absence of child nodes. Is provided in the valid key info field for. Each valid key information is a pointer field 404a, 404b having a pointer to a respective child node data structure in the vocabulary module,
... is associated with 404n.

Since the child node only indicates whether the keystrokes associated with the child node effectively continue the keystroke sequence associated with the parent node, the number of pointer fields is Varies for each node. For example, the valid key information in field 402 indicates that only 6 of the 11 possible keystrokes lead to valid child nodes. Because there are only 6 valid paths, 6 pointer fields are included in the data structure for the parent node. Field 402
Valid key information of the is used to verify the authentication of the pointer field contained within the node data structure. If the keystroke did not lead to a valid child node, the associated pointer field is omitted from the node data structure to save the amount of memory space needed to store the vocabulary module.

Each node is associated with a large number of objects corresponding to the key input order represented by the node. Each object is associated with a particular valid key as indicated by the bit pattern in the valid key bit field 402 contained in the node data structure.
It is described by the instruction in 406 in the packet 408.

Each instruction in each packet 406 describes one of the objects corresponding to the key input order expressed by each node. Object description requires continuation of two object lists. FIG. 19 shows a representative object list dynamically created by unambiguous software processing from the parent and child of the vocabulary module tree. The object list 430 is an object 1 associated with a node represented by two key inputs.
Is an object list that contains a -N _1. The object list 440 is an object list including the objects 1-N ₂ associated with the node represented by three key inputs. Each object list has a list of all objects associated with each node. The object list 430 is associated with a parent node expressing the key input sequence “2” or “2” from the keyboard of FIG. The object list 440 is
It is associated with a child node expressing the key input sequence “2?”, “2?”, “2?”. It will be appreciated that the size of the object list will change considering the actual number of objects associated with each node.

Each reading object associated with the child node is constructed using the first instruction to add kana characters to the object constructed by the parent node. Each instruction in the packet of the instruction 406 in FIG.
Therefore, the object used to construct the child node object is identified from the parent node object list in the OBJECT-L field 556 shown in FIG.
Has IST-INDEX. For example, referring to FIG. 19, the third object “Kika” in the old object list 430 is 2 in the new object list 440.
Used to form the second object "wood". OBJECT of previous object identification field 556
-LIST-INDEX therefore provides a link to the registration in the old object list to identify the old object used to form the new object.

Instruction 558 indicates the sign to add to the recognized object to create a new object, so LOGICAL-SYMBOL-I in field 555.
Including NDEX. The LOGICAL-SYMBOL-INDEX field therefore specifies the character from the last key in the key sequence of the node being added to form the new object. The letters are specified using a table as shown in FIG. For example, as shown in FIG. 19, the first object “Kakaku” in the new object list 440 uses the fourth object “Kaka” in the old object list 430 and an additional key that explicitly indicates “Ku”. Formed by adding inputs. In the logical symbol index table of FIG. 12, "ku" is the second logical character of the key "" or "2", and therefore, the logical symbol index table field of the object "kakaku" generated instruction is a table. It is set to 2 to indicate the second character of the.The encoding of the object by this method significantly reduces the storage space required for each vocabulary module, so that for each node and set of characters for a known key. Use a known and combined key order.

The vocabulary encoding technique also allows access to the vocabulary module's registry without searching. As each new valid key is entered, the system executes the instructions associated with the key at the current node to form a new object from the old object, and a single pointer for the optimal child node is added. To follow. Also, rather than having to store all objects in the vocabulary module, new objects are specified using the LOGICAL-SYMBOL-INDEX field which adds to the old interpretation. Thus, the stem shared by multiple objects in the module is stored only once and then used to create all objects. The disclosed storage scheme requires maintaining an object list from the parent node in the vocabulary module for forming the child node's object list.

Registration in the logical symbol look-up table as shown in FIG. 12 does not require a single symbol, any registration can be used in any order. For example, the word "I did not hear"
Add the kana order “was” to the third object “Kika” from the old object list to form In such a method, the length of the keystroke sequence entered need not directly match the length of the associated object. The series of characters stored as entries in the code look-up table will allow the vocabulary object to be specified by any key order. That is, it will be stored at an arbitrary position in the vocabulary module.

The Object Type field is also included in each directive 558 of FIG. 14 to specify additional information about the constructed object. The object type field contains a code that identifies whether the generated object is a word, stem, or other object. Therefore, the object type field allows for different types of objects to be combined within a given vocabulary module. Moreover, the object type field holds the information necessary to form a portion of the information or a number of variations and refraction endings of words in the language (speech). A miniaturized unambiguous keyboard system can use additional information to perform syntax analysis to improve unambiguous processing by using a vocabulary module that holds portions of linguistic information. Also, the object type field is
It can hold a unique code for the transmission of text in compressed form. The unique code is
Instead of sending the entered keystroke sequence or the associated unambiguous characters, it will be sent to the remote terminal.

One of the key features of the preferred vocabulary module tree data structure is that the objects corresponding to each node are stored in the node data structure 400 based on their frequency of use. That is, the object constructed by the first instruction in the packet of instruction 406 is constructed by the second instruction (if present) in 406 that has a higher frequency of use than the third instruction (if present). It has a higher frequency of use than the object being played. In this method, objects are automatically placed in the object list and are recorded as usage decreases. For the purposes of this description, the frequency of use of a word object is related to the likelihood of using a given word in a typical cluster of uses, which is proportional to the number of hours each word appears in that cluster. In the case of a stem object, the usage frequency is determined by the sum of the usage frequencies of all words having the same stem.

Storing frequency of use or other rank information at each node avoids the need to determine and sort each object's rank when the system is in use. This is of significant relevance in the word object glossary, as accumulated objects can contain stems that are shared by many longer words.
Determining the relative ranks of those stems dynamically requires a detailed consideration of the tree of child nodes and the stored information of each stem, which adds a significant processing load to the portable computer. Predetermining this information and storing it in the vocabulary data reduces the processing burden. Furthermore, the frequency of use or the rank of the objects created by the node is implicitly expressed by the instructions of the instructions 406 that create them, and no additional storage space for this information is required.

It will be appreciated that while objects are preferably stored in the node data structure 400 in order according to their frequency of use, a frequency of fields of use is associated with each indication. The frequency of use field will include a representative number corresponding to the frequency of use of the associated object. The frequency of usage between different objects will be determined by comparing the frequency of the usage field of each object. The advantage of using a later configuration that associates a frequency-of-use field with each object packet is that the frequency of frequency-of-use can be changed by the unambiguous system. For example, this system can
The frequency of the usage field can be changed to reflect the frequency of a given object in the vocabulary module used by the user.

FIG. 20 is a flow chart of a subroutine 600 for analyzing a keystroke received for confirmation of a corresponding object in a special vocabulary module. Subroutine 600 constructs an object list for a particular keystroke sequence. Block 602 in the flow chart clears the new object list. Block 604 is the root node 1011
The processing of the tree 1010 shown in FIG. 18 is started. Block 606 will receive the first keystroke. Blocks 608-612 form a loop to process all available keystrokes.

As shown in FIG. 21, block 608 calls subroutine 620. Decision block 610 determines if any keystrokes have been processed. If any keystroke remains unprocessed,
Block 614 returns to the completed object list.
If the main routine has more than one non-last key, all non-last keys are the same as in the previous execution, and repeatedly calls the subroutine 600 in the new keystroke order, block 602. It may be appropriate to bypass the initialization of 604 and 604 if subroutine 620 is called directly to handle only the most recent keystrokes.

FIG. 21 is a flow chart for calling the subroutine 620 from the subroutine 600. As explained above, the unambiguous system begins the process with a copy of the previous object list to construct a new object. At block 626, therefore, the list of objects from the previous node is stored so that it can be used to build a new object list.

In the main routine shown in FIGS. 7 and 8,
Keystrokes are detected by the system at block 150. When a valid path is on a child node that corresponds to a keystroke, the result of receiving a new keystroke causes a downward movement in the dictionary module tree. In block 621 of FIG. 21, the corresponding packet 408 consisting of pointer fields such as instructions 406 and 404a.
The appropriate key bit field is tested to determine if is present in response to the entered key input. If no valid packet matches the keystroke, then at block 624 the previous object list is returned to the main routine to generate the selection list.

The key entry received is part of an invalid key entry sequence that does not match any object in the dictionary module, so the key entry is ignored and the current object list is the object list from the dictionary module. Then, it is returned to the main routine again. Therefore, the branch of subroutine 620 that includes blocks 622 and 624 ignores any invalid keystroke sequences and returns to the object list generated at the parent node for inclusion in the unambiguous system-made selection list.

At decision block 622, if there is a corresponding packet matching the received keystroke, then
The subroutine proceeds to block 626 where the new object list is copied to the previous object list. Block 628 retrieves the first applicable indication associated with the given key. Block 630 so that the first instruction creates the first item in the new object list.
Repeatedly initializes NEW-INDEX to 1. The subroutine then enters a loop containing blocks 632 through 642 to build the object list associated with the applicable instruction. At block 632, OBJECT-LIST-
The INDEX field 556 is tested and the corresponding object is loaded from the previous object list. At block 634, the logical symbol index (LOGICAL-
SYMBOL-INDEX) field 555 is examined and the appropriate symbol (associated with the keystroke received via the logical symbol look-up table, such as 550 in FIG. 12).
Is added to the end of the identified object.

If the given key 551 and the input to the symbol table 550 at the logical symbol index 552 preserve the character order, more than one character is in block 63.
It will be appreciated that it will be added to the object identified in 4. At block 636, the associated objects and symbols are stored as new objects in the new object list. At block 638, a test is performed to determine if the subroutine processed the last valid instruction associated with the given key at the given node. If the last valid instruction was not processed, block 640 retrieves the next valid instruction. At block 642, the NE
W-INDEX is added.

If the test at decision block 638 indicates that all of the objects have been constructed for the node, the subroutine proceeds to block 644 and follows the pointer associated with the child node. At block 646, the new object list is returned to the main routine to create the selection list. It will be appreciated that the subroutine 600 in FIG. 20 for generating the object list associated with each node is formed for each Keith input received from the user. Since each keystroke simply advances the subroutine one level in the vocabulary module tree, the "search" of the vocabulary module is not done by the user entering a new keystroke sequence. Since no search is done for each Keith entry, the vocabulary module returns a list of objects associated with each node with the least processing load.

FIG. 2 operating on the tree data structure 1010 illustrated by FIG. 18, which is unique in relation to Keith input to the object identification software process.
Subroutine 620, designated by 1, arranges some novel means of retrieving a larger vocabulary of objects, while storage for the vocabulary module is not used without the increased processing time of subroutine 620.

A logical symbol index table 550 for a given vocabulary module based on their frequency of use in the input dictionary.
All the nodes 4 in the tree data structure 1010 are organized by organizing the symbols in each column of (FIG. 12).
Most of the 00 indications 558 (FIG. 14) are made to have their logical symbol index field 555 equal to one. Similarly, the instructions 558 of all instruction packets 406 at all nodes 400 are arranged so that the stem and word objects are created in the object list 440 (FIG. 19) in order of decreasing their use in the language. By doing so, the majority of the indications 558 of all nodes 400 in the tree structure 1010 have their OBJECT-LIST-INDEX field 556 equal to one.

Thus, most of the data in tree 1010 is redundant. Much less nodes than the original tree by systematically checking for redundancy and removing them by reducing the paths that link from parent nodes to child nodes, and by removing child nodes that are no longer referenced, Derives a highly maintained and overlapping data structure that contains far fewer instructions, and far fewer links, yet retrieves all retrievable objects from the original tree.

Furthermore, the instruction is the object list 44.
A clear case of a path through an original tree that produces similar objects to 0 is a common path in a folded tree that acts forward as a generalized (for a particular) object construction rule. To allow for a much reduced structure to create much more objects than were originally used to define the tree 1010 of a given vocabulary module. For example, an unfolded vocabulary tree generated from a list of 30,000 English words would contain over 78,000 instructions in the preferred embodiment.
The modified tree has a maximum of 29 after being retained by the preferred embodiment of the retention process as indicated above,
000 instructions, the modification process is performed in the preferred manner in the flowchart of FIG. 20, and given an ambiguous keying order and search process, a structure with less than the number of word objects can be searched. .

A noteworthy and novel result is that each instruction modifies one object in the object list 430 of FIG. 19 by adding a symbol in response to a keystroke. This is a result of a maintained tree and software search process that reuses a common order of instructions as a general object construction rule. A further feature of the modified tree structure is the automatic identification of generalized rules for associating objects with Keith input order. Such a rule, vocabulary module, with a high probability of success, can tie keystroke sequences to words and stem objects that were not originally used in creating it. For example, the input word list for building the vocabulary module would include the words "sun", "run", and "running" rather than the word "sunning", but retained by the algorithm. The tree structure will create the word "sunning" as one of the objects in the select list that follows the key order.

The node shown in FIG. 17 is an example. The corresponding key field 562 “0101000000
Node 560 has two corresponding keys, as indicated by the "1" number in the "0". In the preferred embodiment, the "1" th position is the path to which the 2nd and 4th keys correspond. And has a packet of pointers and pointers to child nodes that associate them with 566 and 568, respectively. Packet 566 is followed by pointer "P", which is linked to child node 560. The next three instructions,
It includes “(1,1,0)”, “(1,2,0)”, and “(2,1,1)”. Subroutine 60 of FIG.
If 0 has processed the list of keystrokes leading to node 560, subroutine 620 of FIG. 21 is called to process the "2" key, which is the "2" key in the preferred embodiment that will follow. . Instruction 561 will append the first logical symbol of the key "2?"("?") To the old object at index 1 to create a new object at index 1.

The third field "0" of 561 is STOP-F
It is the false value of LAG 557 (FIG. 14), which indicates that the next indication 563 is interpreted because it is not the last indication of the current packet. Instruction 563 will append the first logical symbol of the "2" key ("?" In FIG. 12) to the old object at index 2 to create a new object at index 2. The index of the new object created is 2 because the index of the new object created is implicit in the order of the instructions themselves, ie the second instruction always forms the second object.
Will. The third field of the instruction 563, "0", is
Wrong value for STOP-FLAG 557, the next instruction 567 is interpreted. Instruction 567 uses the second logical symbol (key “ku” in FIG. 12) to index 1 to create a new object at index 3.
Will be added to the old object of. The third field "1" of instruction 567 is the true value of STOP-FLAG 557, which is the last instruction of the current packet, so execution of subroutine 620 is at block 638 through block 644. Indicates a deafness.

It is possible to associate two or more nodes containing different indication packets 408 with one node that can serve the same purpose as separate multiple nodes, which means that one node in the vocabulary tree 1010 is new. It means that the sense is redundant. For the purposes of this invention the word "redundant"
Is used for two nodes such that the operation of the software processing that will be described below with respect to the preferred embodiment shown in FIGS. 22-17 eliminates the need for one node.

For example, compare node 560 shown in FIG. 17 with node 574. Instruction packets 566 and 571
The key "2?" Matches exactly, but at node 56
The instruction 570 on the key "4ta" of 0 conflicts with the instruction 572 on the key "4ta" of the node 574, neither of which can do other work, and two nodes do both jobs. It cannot be combined into one. Compare node 560 with node 576. Instruction packets 566 and 577
Exactly matches each node and is associated with the key "2?". Instructions 569 and 578 are their STOP
-Although they differ in the setting of the FLAG field 557, the differences do not cause them to conflict. The essential result of the object retrieval process of subroutine 620 in FIG. 21 is a new object list created by executing the set of instructions on the node for a key. Without determining the correct treatment of any of the child nodes,
Additional objects can be added to the end of the object list.

Thus, no error is triggered in the processing of child nodes of node 576 by executing additional instructions after 578. The process body can be disabled only if the wrong instruction is executed or if the instruction is rarely executed. Similarly, node 5
The presence of the corresponding key for the key "9," of 76 does not conflict with the absence of the corresponding "9," key at node 560. Thus, nodes 560 and 576 are redundant and can implement the net effect of both, and can be merged into a new node 582 that acts as the parent node of both children. It can be appreciated that pointers also play a role in defining redundancy.

At the last keystroke in the order in the tree associated with a word that does not continue to form the stem of a longer word, the pointer in the corresponding key packet 408 indicates that there are no further child nodes. To
It has a special value, NULL, in the preferred embodiment.
Such a node is called a "terminal node". For two nodes that have child nodes associated with the corresponding key in both nodes, there will be no descendants in the corresponding key sequence common to the nodes being compared to or in contact with the terminal node. Up to, each child node must be redundant because each parent node is redundant, and so is the node transmitted from the child node.

22-17 are a flow chart and a preferred embodiment of a software process for compression.
It shows folding of a vocabulary module tree similar to 010. FIG. 22 is a flowchart of a preferred embodiment of a software process for forming a module of compressed vocabulary. FIG. 1 for the Japanese vocabulary module at block 652.
Like 1, the dictionary is scanned to identify any necessary additional ambiguous symbols other than those that appear in the physical key. At blocks 654-656, as in the embodiment of FIG. 12, symbols are assigned their logical index to their respective keys in order of decreasing frequency of their use in the input dictionary. It will be apparent to those skilled in the art how block 658 creates the vocabulary tree of form 1010 by providing a dictionary of objects with frequency of use. At block 660, the redundant nodes are identified and merged with each other to minimize duplication of data, and then the isolated single object is associated with a generalized rule to retrieve multiple objects. Return to the designated order. This process is shown in detail in FIG. Block 662 shows all remaining NUs from the terminal node.
Check the LL pointers and change them to point to nodes with multiple parents.

Assigning a null pointer to a child node may result in other rules being applied, and such rules may be dynamic based on factors related to the keystrokes processed. It will be appreciated that this will be applied when searching for objects. At block 664, each unique so that they may be coded as a unique pattern of bits with shorter bit patterns assigned to addresses and addresses more frequently to save space. Instruction 558 (FIG. 14) and pointer 404a (FIG. 1).
If 3) remains, it is counted. As known in the art, the preferred embodiment is Huffman coding. In addition, nodes that are child nodes of multiple parent nodes are specially ordered to facilitate their fast lookup and to minimize the number of bits needed to address them. May be stored in orderings. While building the tree at block 658,
When selecting the indication 558, accumulated and shown objects, and when the objects are words or stems, their character order may be advantageously used in the tree 1010 to increase node redundancy. It will be appreciated that it may include additional data.

For example, not all pairs of kana in the Japanese language are necessarily common sense, and for example, "ma" is accompanied by "su" in common sense. Kana pair statistics or cryptanalysis (bigram
s) can be used to predict the most likely next kana in an object from the previous kana. For such predictions, the logical symbol index 34 of FIG.
The logical designation of the ambiguous symbol at 50 can be dynamically changed to further optimize the use of the first position. Predictions are kana and trigram (triplet) kana
s), and general n-grams.

FIG. 23 shows a tree 10 of vocabulary modules.
6 is a flow chart of a preferred embodiment of the software process for bending 10. Block 670
Is input from block 660 of the flowchart of FIG. Block 672 initializes the process to begin at the first node 1010 of FIG. 18 after the root node 1011. Block 674 is a subroutine 690 represented in the preferred embodiment in the flowchart of FIG. 24 for installing a node, if maximally redundant with the current node.
Call. If the destination node is found, block 676 is a block 67 where redundant nodes have been merged together.
From the overlapping tree that allocates and covers 8 processes,
Duplicate data is eliminated, and at this time, there is a separate case for shared order. This is a general rule for the key order associated with an object. If block 676 fails, then block 680 tests whether the process is complete. If there are nodes to process further,
In the flow, proceed to block 682.

FIG. 24 is a flowchart of a preferred embodiment of a software process for discovering in tree 1010, the node with the highest redundancy for a node. Block 692 is shown in FIG.
3 from the block 674 of the flowchart.
Block 692 initializes the placeholder MAX-SAVINGS for the measured redundancy. Block 694 is the root node 1 of the tree 1010 of FIG.
Initialize the process to start at 011.
Block 696 calls a subroutine 710 represented in the flowchart of the preferred embodiment in FIG. 25 to calculate a node's redundancy with respect to the current node. Block 698 tests if more than MAX-SAVINGS redundancy has been detected. If so, block 700 records, as MAX-SAVINGS, the most redundant for the node, the BEST-NODE coincidence of the temporarily detected node, and the reported measurement of redundancy. Block 702 tests whether all nodes have been evaluated. Block 7
All nodes up to 04, if not, flow proceeds from the current node to the next node. Block 70
From 4, flow returns to block 696. If the result of block 702 is that the last node was evaluated, then block 706 returns a match with the most redundant node, and if so, FIG.
The node is provided to block 674 of subroutine 670 of.

FIG. 25 is a flow chart of the preferred embodiment of the software process for calculating numerical redundancy between two identified nodes. Block 7
10 is input from block 696 of the flowchart of subroutine 690 of FIG. Block 712 is
Initializes the count of replication instructions. Block 714
Initializes KEY-INDEX to 1. Block 716
Reads the instruction packet 406 in which the key is associated with the KEY-INDEX key from the first of the two nodes 400 specified as parameters to the subroutine, and puts them into a temporary list, LIST-A. Put in. If KEY
-If the INDEX key is not a valid key, no instructions will be read. Block 718 is the second KEY-INDEX of the two nodes 400 specified as a parameter to the subroutine.
Read the instruction packets 406 associated with the keys and place them in a temporary list, LIST-B. If the KEY-INDEX key is not a valid key, no instructions will be read. Block 720 determines if either LIST-A or LIST-B is empty. If not, reduce the number of instructions that stay in each by twisting,
In block 720, block 722 is LIST-A and LIST-B
If one is taken from both, then each one leaves a reduction in the order. Block 724 is their LOGICAL-SYMBOL-INDEX and OBJECT-LIST-INDEXf.
In ields, test if the instructions are the same. If not, failure for no redundancy
The code is returned to block 696 of subroutine 690.

If the determination at block 724 is yes, then block 728 returns a SAVED-INSTRUCON
Increase the count of. If the test at block 720 is true, then control is taken to go to block 730, which tests to see if the two nodes have been compared for all. If not, block 732 provides control to increment KEY-INDEX and proceed to block 716. Block 736 tests the pointer associated with the KEY-INDEX key of the two nodes. Block 738 tests whether either pointer is empty. If none of the pointers are non-empty, then control is taken to go to block 740 and the iterative subroutine 710 is used to determine if the child node is pointed to by the two non-empty pointers being redundant. Test. The result of block 740 is block 74.
Tested at 2. If the two child nodes are detected as not redundant, an error code is returned.

In another method, the two children are in block 74.
Redundancy is detected by a solid numerical score accumulated by 6. The decision block 748 is tested for the pointer associated with the last key (key 9 in the preferred embodiment). If not, block 752 increments KEY-INDEX,
Control is made to proceed to block 736. If the decision of block 748 determines that all pointers have been checked, the subroutine returns to block 710.
The redundantly stored numerical measurements of the two nodes originally identified are returned when input at. To account for additional factors such as the number of branches that exist at each node, and the number of parent nodes, the computation of redundant numbers may be burdened on a node as a child node. It will be recognized that it is not possible.

If the two nodes are not redundant due to the indication of the indication associated with a key, then the order of the indication associated with the infrequent word in the input dictionary.
It will be appreciated that the (order) will be reordered without conflicting with the priority for the instructions associated with the higher frequency objects, thus increasing the redundancy of the tree. In order to reduce the size of the tree by eliminating redundant nodes, the method described above was described with respect to the tree consisting of the initial instructions. Associating each first command with a list of zeros, or a second directive, helps to increase the fusion of object complexity, while the disclosed process reveals It is possible,
Then, the redundancy in the tree that includes both the first and second instructions can be eliminated. Moreover, its primary and secondary indications stored in the same physical tree in memory are not necessary. The two sets of instructions are
Up to the sequence of the first instruction of the first instruction tree node that matches the nodes of the second instruction tree and matches the order of the second instruction set can be stored in a separate tree. Similarly, when the first and second instructions are stored in the same physical tree of memory, they are such that each first instruction is immediately followed by a series (zero or more) of associated second ones. Mixed (combined?)
can do. Instead, all of the first directives in the node follow the second order of contiguous blocks in the same order as the first directive (contiguou
s) the order in blocks, which can be stored in each block containing (zero or more) associated second indications.

In this alternative format,
Nodes that are redundant with respect to their first indication are joined
Two or more separate sets of related second instructions may be merged. Then, in each parent node, jump to the merged node, which is a small sum of additional information to identify which of the alternating sets of second instructions should be executed. Need only be added.

Furthermore, yet another aspect of the invention.
In, the greater efficiency in database compression is by accumulating only once in the database structure for each special related reading only each kanji character associated with a particular reading. Is achieved. In general, a database contains several different examples of the same Kanji with the same reading, for example, Kanji in animals (animals) and plants (shokubutsu),
It is a thing (read as an object). Unusual names not explicitly included in the database to facilitate entry of various unusnal combinations of Kanji characters,
Or, like words, for example, each Chinese character should be able to be identified with the desired associated reading only input. Thus, in the preferred embodiment,
Each reading of a given Chinese character, starting immediately from the root of the tree structure, is included in the database and, along with the second instruction, contains the specification of the code for the associated Chinese character.
This instruction is determined by another instruction in the same second instruction list as the same reading and as the same specified relative frequency of the presence of a special Kanji character associated with another text object associated with it. Are stored in the second instruction list in the order. In all such cases, at the root of the database tree, we have constructed associating the start of reading, after the node ordering, the second matching instruction attaches Kanji to the invalid text object. in this way,
All the second instructions for adding Kanji to invalid text objects have a distinctive format (the index is not needed to identify the index of the previous lemma), and the Kanji character code is specified. The number of bits used to do is well achievable and discernible in the majority of the valid Chinese characters represented in the database.

Correspondingly, when a Kanji character appears in a word or phrase somewhere in the database as the first character in the word or phrase more than in others, the associated second indication is The second object list for matching readings in one object is added Kanji to the existing entry word text object that was previously added in the first object list of the immediately preceding node. Thus, in this case, the instruction format must include a field in which the index of the second entry text object is identified. Similarly, at the last node, when an existing headword has to be "saved" in order to allow kanji to be added, or kana (clarified in the first instruction). The second object index field must be included in the indication if Thus, the format of these two types of second indications, one not the second object index and the other such index, to minimize the size of the database. In addition, it should be distinguished.

In the latter case, that is, when the second object index in the instruction is non-zero and a kanji is added to the entry word, the reading associated with the added kanji is determined by the system. To be done. This is because the system keeps track of the syllable being added to the associated reading in the first object list from the character and the last-added track in the entry word text object identified by the index in the instruction. . As explained above, each reading of each Kanji is stored in a database starting at the root of the tree and is fully identified in the associated code for the Kanji. Thus, "Kanji has been added to previously existing headwords."
In the instruction, the kanji is stored with a well-specified kanji, that is, an index corresponding to the position of the kanji represented in the second object list of the determined reading starting from the tree structure root. Be specified. This attempt allows the majority of Chinese characters to exist in the database, which is specified in far fewer than is generally required, and the accumulated index is determined when the database is created. It will be erased within a fairly limited range of values that can be achieved.

For example, in the database, about 89,
000 words are stored, and about 8 in Kanji conversion
Nine percent are stored this way.

In one embodiment, as shown in FIG. 15, there are four types of second indications, each starting a 2-bit format field set corresponding to one of four distinct values. For example,

[Table 2]

Therefore, as shown in FIG. 15, the directives 5600 to 5602 with the format field 5610 set to 00, 01, and 10 are all existing headword indexes in the list generated by the immediately preceding node. Field 5611 that identifies the secondary-object-list-index (SECONDARY-OB
JECT-LIST-INDEX) is included. "PRESERVE" command 5
At 600, the indexed lemma is maintained in the list, which is 1 or 2 of the next node.
It can be modified by the above command. In the "Kana" directive 5601, the indexed entry word is modified by adding the Kana specified by the associated first (primary) directive. In the "Indirect Kanji" command 5602, the kana for calling the added Kanji is determined from the order of the preceding commands along with the first (primary) command with which the command 5602 is associated. The added kanji is "kanji-index-from-root (kanji index from the root)".
Specified by (KANJI-INDEX-FROM-ROOT) field 5613, which is the index of the instruction in the secondary instruction list, associated with the primary instruction, determined from the order starting from root node 1011. It is added to the last kana that is played. The "DIRECT Kanji" command 5603 includes a larger "KANJI-CODE""bit field 5614" that contains sufficient information to reproduce the full encoding of a given Kanji. Formats 5600-5604 also include a "stop flag" field 5612 that helps to distinguish the last command of a group associated with a given primary command.

Examples of these various cases are shown in FIGS.
And shows a representative list of possible directives in the three nodes of the database tree structure. For convenience of explanation, FIGS. 26 and 27 show the primary command in a decoded form, and further, the logical symbol index actually stored in the database command (see FIG. 12).
, But the actual kana to be added is shown. Also, for convenience of description, the list object created by each instruction is shown in the brackets on the right side of the instruction. 26 and 27 partially show a list of primary commands and secondary commands of the node corresponding to three consecutive operations of the "2?" Key (for example, the key 122 of FIG. 3). The left-hand column indicates the directive for the first level node (ie, starting from the root of the tree structure) and the text object generated as a result of the first keystroke in the sequence. The following two columns show commands by the second and third key operations. Each primary command in the list is Y1, ..., Y
n (“Y” is an acronym for “reading YOMIKATA”), each primary command is shown with a list of associated secondary commands, and each secondary command is M1, ...
.., Mn (M is an acronym for the headword Midashigo). 26 and 27, Y0 and M0 are
Represents a "null" text object. Therefore, as expected, at the root level (level 1)
In, all of the primary commands specify Y0, and all of the secondary commands specify M0. Therefore, the secondary directives represented at this level are the "direct Kanji" directives (ie, the second object-list-index-field (SECONDARY-OBJECT-LIST-INDEX) is not included), and The character code for each Kanji character "X", indicated by "M0 + X" in FIGS. 26 and 27, is fully specified in the "Kanji code" field of the command. If such a directive appears below (before) the first level of the tree, the "DIRECTKANJI" directive is only used to identify the Kanji that appears as the first character of a lemma. Even, no previous hold order is needed. Therefore, directives of the form "M0 + P" do not appear at level 1 because they are inferred, and there is no need to maintain a "null" empty "text object. For example, in the middle column (level 2), the primary command Y1 adds the kana "ku" to the reading Y1 of the previous level ("ka"), thereby adding the reading object "ku" to the second level. To generate. The fifth secondary command M5 is a direct Kanji command, so
Corresponds to the complete reading "hiding" including all kana added from the root node to the current level. The command also contains enough information to determine the correct output code for the character "stroke." This same Kanji character is part of the entry word generated by the secondary command M1 associated with the level 3 primary command Y2. The primary command Y2 adds the kana "ku" to the reading Y11 of the preceding level (that is, "kika"), and thus generates the reading object "kikaku" of the third level. The secondary command M1 associated with this primary command Y2 is "M5 +
[M5] ”is displayed. This command is an "indirect kanji" command, and therefore (see "M5
SECONDARY-OBJECT-LIST-I that identifies the value of 5 (shown as "+")
NDEX) field. This refers to the fifth entry word object associated with Y11 (referenced by the OBJECT-LIST-INDEX field of the primary command) in level 2 above. This level 2 entry word object is generated by the primary command Y11, that is, "Y9 +?" And the second command M5, that is, "M7 + P" associated with it, and the command M7 of the reading Y2 at the previous level (level 1).
It is shown that the lemma object "enter", created and completely specified by, is copied (held) as the fifth lemma object in the current level (level 2) list. This "held" directive serves as a placeholder and indicates that the kana "ka" added at this level is the beginning of the reading of the kanji for being appended by a later directive. It is known that the reading associated with the indexed Kanji [M5] will be the "ka" held at level 3 (plus) plus the "ku" added by Y2. If so, the level 3 “Indirect Kanji” instruction (Y2: M1:
"M5 + [M5]"). If the index [M5] leads to a fully specified kanji "ga", by checking the reading "ku" starting from the root, level 1 Y1
Be led to. Adding this to the retained lemmas from level 1 produces a fully specified lemma “plan”.

In another preferred embodiment, another method is used to perform the function provided by the "hold" command (format code 00 in the previous embodiment). In this alternative embodiment, as shown in FIG. 16, the alternate command format 5604 with format code 00 is similar to command format 5602,
It identifies the index of the existing headword, Kanji-INDEX-FROM-root (KANJI-INDEXFROM-RO
Both the OT) field 5613 and the second SECONDARY-OBJECT-LIST-INDEX field 5611 are specified. However, in this modified embodiment, the second object-list-index (SECONDARY-OBJECT-LIST-INDEX) does not refer to the previous node, but rather than the current node.
A node preceding by one more than the number of nodes specified by the "NUMBER-OF-KANA" field 5615 is referred to. The reading corresponding to the Kanji to be added is determined by tracing back the chain of primary commands from the referenced node to the associated primary command referenced at the current node. The advantage of this approach is that no split "hold" commands are required at intermediate nodes, which allows the database to be more compact. The disadvantage is that multiple object lists from the previous node must be maintained to compute the keystroke order, and only one list from the previous node is not enough. Similarly, in the alternate form of Kana directive 5605, the second-object-list-index (SECONDARY-OBJECT-LIST-INDEX) is
Reference the node that precedes the current node by the number specified by the "NUMBER-OF-KANA" field 5615. The order in which one or more pseudonyms are added is determined by tracing back the chain of primary commands from the referenced node to the associated primary command referenced at the current node. The same advantages and disadvantages as above apply to the alternative "hold" directive. As will be appreciated by those skilled in the art, the "Format Code" field, "Second Object-List-Index".
The field and the "NUMBER-OF-KANA" field can be combined in various ways, for example:
Greater compression can be achieved in the stored instructions by using the Huffman encoding method.

In another preferred embodiment of the present invention, further compaction of the database is accomplished through the mechanism described below with substantially no additional processing load. In many cases, if the reading appears in a non-initial position in a word, the reading associated with a given Kanji is changed. In quite a lot of such cases,
This change in reading is a result of the common phonetic effect of the pronunciation of the previous Kanji and causes the first consonant of the first Kanji to change from non-occurrence to occurrence, or
Causes the change of fricatives (consonants such as f, v) to plosives (consonants such as p, b, t, d, k, g). This corresponds to adding a dakuten or a semi-dakuten to the first kana in the reading of non-initial kanji. In the data storage and retrieval schemes described above, additional items are generated in the database and stored in alternate readings (with dakuten or semi-dakuten added) in the order of nodes starting from the root of the tree structure. Stores the associated fully encoded Kanji.

In the preferred embodiment, when a Chinese character appears in a non-initial position with such an alternate reading,
The Indirect Kanji (INDIECT KANJI) directive is used to identify the desired Kanji by referring to its alternate reading.
In order to reduce the size of the database, the referenced Kanji is not stored from the root (root) in relation to the alternative readings, but the normal readings (with dakuten or judgment dakuten) Associated. To identify the intended kanji n, the value stored in the second object-list-index field of the indirect kanji instruction is modified in the following way: N was associated with an alternative reading. Representing the number of kanji stored from the root, and letting X be stored in the intended kanji position if that kanji is stored from the root in association with normal reading (no dakuten or semi-dakuten) Represent by the corresponding second object-list-index value. Then, the second object-list (LIST) -index field of the "indirect kanji" command is set to the value (N + X). When processing an "Indirect Kanji" command, the system first searches the stored Kanji for alternate readings, and then stores only N (less than field value (N + X)) Kanji there. Determine that you have been. It is determined that the associated reading starts with a kana with a dakuten or a semi-dakuten, and a corresponding normal reading is generated, and the determined number of kanji N
Is subtracted from the field value (N + X), and the intended Chinese character is found under the determined normal reading at the determined index position X.

V. Use ambiguous keystrokes
Operation of the system to operate even Figure 28 shows a typical example of three operations of the system shown in Figure 1. These examples describe the operation of the system, and data key 21-3.
The nature of the feedback provided in the preferred embodiment, including the use of 0, select key 60, convert key 62, and diacritic key 68, is described. This example
FIG. 7 illustrates the text that would appear in text area 66 as a result of each keystroke, which text includes the special format of the object at insertion point 88 (dotted or solid underline). As shown in FIG. 1, each keystroke is identified by a number label on the key.

The example of FIG. 28 illustrates how the phrase "please" is entered in the first preferred embodiment of the system of FIG. Key 2
After each of the first three keystrokes for 1, 25, 22 the most frequently used readings are displayed, corresponding to pseudonyms of lengths 1, 2, 3 respectively. The fourth keystroke for the discriminative diacritic key 68 identifies the kana of the previous keystroke for the key 22 as a kana with a dakuten, and the displayed reading is the three most common kana readings. Then, the reading is changed to correspond to the key sequence 21, 25, 22 and a dakuten is added to the third position (eel). After the fifth keystroke for key 21, the most common reading is "Please", which corresponds to the first word of the preferred input phrase. Subsequent keystrokes to the conversion key 62 change the displayed text to the most common headword, which corresponds to the displayed reading, which in this case is also the first word of the desired input phrase. Corresponding to. The next keystroke is for the data key 23, which is the operation following the select key 60 or the convert key 62 (in this case the conversion key 62),
It starts the input of a new keystroke sequence to be distinguished from the previous sequence. Following this keystroke on the key 23, the next two keystrokes on the key 27 and the key 23 are operated again so that the most frequent reading is always displayed. In this case, the word is also displayed after those keystrokes that correspond to the desired word "do" in the input phrase. The last keystroke for the select key 60 is
Indicates that the keystroke sequence for the current word object is complete, so that the next keystroke for keys 21-30 will start a new input sequence.

Example 2 in FIG. 28 shows a display display when the phrase "Thank you" included in the database is being input. After the seventh keystroke (for key 22), the single object that matches the input key sequence in the database is the desired input phrase itself. Therefore, even if the order at that point does not correspond to a complete word or phrase, the most frequently matching stem (in this case "Thank you") is displayed. In addition, there is only one potentially matching object in the database, and Kana at the current position of this object contains a dakuten, so Di
Even if the acritic key 68 is not activated, the pseudonym is displayed with the dakuten. Therefore, in this case, the actuation of the Diacritic key 68 is optional, and
Indicates the case where the "" or "" is displayed without activating the Diacritic key 68. One stem is shown in the seventh and the stem is displayed in the seventh, even though the keystroke is the tenth in the sequence, until the input phrase is completed with eleven keystrokes.

Example 3 illustrates various functions associated with the select key 60 and the convert key 62 in the preferred embodiment. After the first two keystrokes for keys 22 and 25, the most frequently matching reading is determined as "this". The next keystroke for the select key 60 marks the end of the data key sequence for the current word object, and deflects the dotted underline to the solid underline. If you press the select key 60 twice,
Select the second most frequent reading, "Kuni". By the subsequent keystroke for the conversion key 62,
The headword most common to the selected and displayed reading "Kuni" is selected. Subsequent conversion key 6
The second keystroke for 2 cycles through the smallest common lemma that is a single Kanji character, the last lemma in the order indicating the reading selected in the Katakana narration. Subsequent keystrokes of the conversion key 62 will return to the first displayed hiragana, the first text interpretation in the order of the lemmas and the same hiragana reading. A keystroke for the additional conversion key 62 causes the cycle to be repeated, again indicating the most frequent Kanji interpretation. Following this, when the selection key 60 is pressed, the display of the currently selected reading "Kuni" is restored. When the selection key 60 is pressed twice, the reading mode is changed to the next (third) most frequent reading "Kane". The subsequent keystrokes for the conversion key 62 cycle through the first two (most common) lemmas associated with the reading, a single Chinese character.
Pressing and holding the last conversion key 62 cycles back through the entry word list and reselects the previously displayed kanji.

The Japanese text input system with the small keyboard described above reduces the size of the computer and other devices included in the system. By reducing the number of keys, the device can be configured so that the user can hold it with one hand and allow it to be operated with the other hand. The disclosed system allows accurate and fast text entry, which makes it useful for use in mobile phones, PDAs, interactive pagers, or other small electronic devices. The system can contribute to both efficiency and simplification when applied to a device with a touch screen or a device with a limited display screen area and a limited number of keys. The system of the present invention integrates the steps of generating an input in the form of a kana consisting of Japanese syllables and converting the input kana into the intended kanji or other text corresponding to the reading of the kana. Further, the system of the present invention provides a method of storing in a database the information needed to operate the system so that it is very compact and can be processed with a minimum processing capacity.

It should be noted that those skilled in the art can make some modifications to the design of the keyboard layout and the design of the basic database without changing the gist of the present invention.
In addition, within the scope of the appended claims, specific implementations as described herein are possible.

[0159]

The Japanese text input system using the small keyboard described above reduces the size of the computer and other devices included in the system. By reducing the number of keys, the device can be configured so that the user can hold it with one hand and allow it to be operated with the other hand. The disclosed system allows accurate and fast text entry, which makes it useful for use in mobile phones, PDAs, interactive pagers, or other small electronic devices. The system can contribute to both efficiency and simplification when applied to a device with a touch screen or a device with a limited display screen area and a limited number of keys. The system of the present invention integrates the steps of generating an input in the form of a kana consisting of Japanese syllables and converting the input kana into the intended kanji or other text corresponding to the reading of the kana. Further, the system of the present invention provides a method of storing in a database the information needed to operate the system so that it is very compact and can be processed with a minimum processing capacity.

[Brief description of drawings]

FIG. 1 is a schematic diagram of a mobile phone incorporating a system for disambiguating a miniaturized keyboard according to an embodiment of the present invention.

FIG. 2 is a schematic diagram of a cell phone keypad incorporating a miniaturized keyboard system with marginal or no display capability according to an embodiment of the present invention.

FIG. 3 is a mobile phone incorporating a keyboard system having a display capability of displaying on the display after key 2 as the first of the keystrokes in the pair of unambiguous two-input method according to the embodiment of the present invention. Schematic of the phone keypad.

FIG. 4 is a hardware block diagram of a miniaturized keyboard by disambiguating the system of FIG. 1 according to an embodiment of the present invention.

FIG. 5 is a schematic of a touch screen of a portable computer incorporating a miniaturized keyboard indicating that it is being displayed before the first keystroke of a pair of unambiguous two-stroke methods according to an embodiment of the present invention. Fig.

FIG. 6 shows a syllable “ka”, “ki”, “ku”, as the beginning of a pair of key inputs of the key operation according to the embodiment of the present invention.
FIG. 6 is a schematic diagram of the touch screen of FIG. 5 incorporating a miniaturized keyboard that is being displayed by key operations corresponding to “ke” and “ko”.

FIG. 7 is a diagram showing a waod-level flow for disambiguating software for a keyboard for disambiguating a miniaturized system for Japanese according to an embodiment of the present invention.

FIG. 8 is a diagram showing a word-level flow for disambiguating software for a keyboard for disambiguating a miniaturized system for Japanese according to an embodiment of the present invention.

FIG. 9 is a schematic diagram of a touch screen of a portable computer incorporating a miniaturized keyboard according to an embodiment of the present invention.

FIG. 10 is a schematic diagram of a touch screen of a portable computer incorporating a miniaturized keyboard having nine keys according to an embodiment of the present invention.

FIG. 11 is a diagram illustrating a comparison of a physical combination of a symbol to a key and a key having an example of a logical combination including additional highlighted changes of characters appearing on the physical key according to an embodiment of the present invention.

FIG. 12 is a diagram showing a table for associating logical symbols with key indexes according to an embodiment of the present invention.

FIG. 13 is a diagram showing preferable internal processing of data in a node of a tree of a vocabulary module according to the embodiment of the present invention.

FIG. 14 is a diagram showing a vocabulary configuration of a first method for generating a reading text object according to an embodiment of the present invention.

FIG. 15 is a diagram showing a structure relating to a vocabulary of a second instruction used to create text objects of four different types of headings for reading according to an embodiment of the present invention.

FIG. 16 is a diagram showing a vocabulary structure of a second instruction used to create a text object of two headwords out of four different types of reading in accordance with an embodiment of the present invention.

FIG. 17 is a diagram showing four embodiments of possible internal data items in the structure of the node according to the embodiment of the present invention.

FIG. 18 illustrates a preferred tree structure of uncompressed vocabulary module according to an embodiment of the present invention.

FIG. 19 is an object list according to an embodiment of the present invention.
FIG. 6 is a diagram showing (embodiment for intermediate storage of objects in the process of being extracted from a vocabulary module).

FIG. 20 illustrates a software process flow for retrieving a text object from a vocabulary module given a list of keystrokes according to an embodiment of the present invention.

FIG. 21 illustrates a software process flow for traversing the tree structure of a vocabulary module given a keystroke and changing the state of an object list according to an embodiment of the present invention.

FIG. 22 is a diagram representing the flow of a software process for expanding a compressed vocabulary module according to an embodiment of the present invention.

FIG. 23 is a diagram showing a flow of a software process for expanding a tree data structure of a vocabulary module according to the embodiment of the present invention.

FIG. 24 is a diagram representing a tree flow of vocabulary modules with the greatest redundancy in comparison with some nodes of the software process for installed nodes per second according to an embodiment of the present invention.

FIG. 25 illustrates a software process flow for calculating redundancy between two nodes of a tree in a vocabulary module according to an embodiment of the present invention.

FIG. 26 is a syllable “ka” according to the embodiment of the present invention;
FIG. 4 is a diagram representing a partial content flow of a database for a series of three consecutive keystrokes on a key, which are vaguely associated with “ki”, “ku”, “ke” and “ko”.

FIG. 27 is a syllable “ka” according to the embodiment of the present invention;
FIG. 4 is a diagram representing a partial content flow of a database for a series of three consecutive keystrokes on a key, which are vaguely associated with “ki”, “ku”, “ke” and “ko”.

FIG. 28 is an input following each key input on a series of keys during the input of text when displaying the content of the text of the system shown in FIG. 1 on display 66 according to an embodiment of the present invention. The figure showing the typical embodiment of the system control of operation.

FIG. 29 is a diagram showing a basic Japanese syllabary table according to the embodiment of the present invention.

FIG. 30 is used for phonetic distinction according to the embodiment of the present invention;
Diagram showing additional Japanese syllable tables.

FIG. 31 is a diagram showing a Japanese syllable table with palatalized vowels added thereto according to the embodiment of the present invention.

FIG. 32 is a view showing a classification table relating to Japanese syllabary tables according to the embodiment of the present invention.

FIG. 33 is a diagram showing a classification table relating to Japanese syllabary tables according to the embodiment of the present invention.

FIG. 34 is a diagram showing an alternate classification table for a Japanese syllabary table according to the embodiment of the present invention.

[Explanation of symbols]

21-30 ... key 52 ... Mobile phone 53 ... Display 54 ... Keyboard 60 ... Conversion key 62 ... Selection key 64 ... Clear key 66 ... Text area 67 ... Mode key 68 ... Distinct phonetic key 77 ... Selection list area 88 ... insertion point

─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Edward P. Frynchem, Washington, USA 98119, Seattle, W. Quinea Place 118 (72) Inventor Ethan Earl Bradford, USA 98103, Washington 98103, Seattle, N. Thirty Fifth Street 1412 (72) Inventor Daiju Matsuo, Washington, USA 98133, Seattle, Meridian Avenue N. No. 606, 10306 (56) Reference JP-A-5-298262 (JP, A) Kaihei 8-249102 (JP, A) JP 8-314920 (JP, A) JP 8-292944 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 3 / 02-3/023

Claims (48)

(57) [Claims] [Claim 1] ambiguous input Sea that has been input by the user
To eliminate the ambiguity of the cans, a disambiguation system for generating a character output Japanese, (a) a plurality of input portions, and each plurality of input portions is associated with a plurality of characters, each time a said user input device is selected the input unit is operated, is generated corresponding to the sequence of inputs input sequence is selected, the generated input sequence is a character multiple associated with each input A user input device , which, therefore, retains the ambiguity of the text interpretation ; and (b) includes data for composing multiple reading objects, each reading object containing an input sequence and a frequency of use. associated with each reading object identifies the sequence of kana, sequence of kana one or more text objects are output to the user Is intended to correspond to the door of the reading, the first sequencing of the pseudonym of the object phrase phrases object was completed, in the unfinished words or phrases
Stem object consisting scan, and consists object containing both of them word phrases and stem, all terms, phrases and stem objects are stored in a tree structure having a plurality of nodes in the memory, each node input sequence And a memory associated with one or more reading objects, and (c) a disk displaying system output to the user.
Play, and (d) one or two of the memories associated with each input sequence , connected to the user input device, memory and display.
From the above identified reading objects, at least one or more most frequently used candidate objects are identified , wherein the candidate objects have at least one or more word or phrase objects associated with the generated input sequence. If it is is that word or phrase objects, the candidate objects, the generated input sequence
If there is no word or phrase objects associated with the scan are stem objects, elements, at least one or more of the identified candidate object associated with prior Symbol each generated input sequence, the interpretation of the input sequence system and generating an output signal to be displayed on the display as text, comprises a processor. 2. Special categorical pronunciation including dakuten and semi-dakuten
One or more pseudonyms symbol is affixed The system of claim 1, wherein that those symbols are associated with the same input means as the pseudonym not attached. Text wherein the user input device has an additional input unit for special classification diacritical including voiced and semi-voiced sound mark is associated, comprising one or more pseudonym with such symbols The system of claim 2 , wherein an object is associated with an input sequence that includes one or more operations of the additional input. 4. Each reading object in the tree structure in the memory is associated with 0 or 1 or more entry word objects, each entry word object is a text interpretation of the associated reading object, and The system of claim 1 , wherein each entry word object comprises a character sequence consisting of any combination of Kanji, Hiragana, Katakana. 5. The system of claim 4, wherein the frequency of use associated with the reading object corresponds to the sum of frequencies of use of all character interpretations associated with the reading object. 6. One of the plurality of inputs is an unambiguous selection input , and the user selects the selection input to accept the highest frequency reading object as a character interpretation of the input sequence entered. The system of claim 1 , wherein the subsequent input selection is treated as the first input of the new input sequence . 7. The user selects the place of reading the object as the interpretation of the input sequence by additional selection of the selection input unit not the ambiguous, the曖not昧 selection input
Each selection of parts selects a reading object from one or more identified reading objects in memory associated with the generated input sequence , the alternative reading object having a reduced frequency of use, and the ambiguous Na
One or more system according to claim 6, wherein selecting one of the selection of a plurality of input associated with more 1 or more characters are processed by the first input of the new input sequence have selection input unit. 8. is associated with each or number of the plurality of inputs associated with a plurality of letters, numbers original composed of the numbers by numbers their respective generated input sequence associated with each input It has interpretation, wherein the numeric interpretation a曖昧性 no selection input unit additional system of claim 7, wherein included in the reading object which the user selects as the interpretation of the input sequence by the selection of. 9. Ru good to additional selected without selecting the input section of said曖昧性, the user selects as the interpretation of the input sequence
Subsequent to all of reading objects as possible, the numbers solution
9. The system of claim 8 , wherein the release is provided to the user. 10. (a) One of the plurality of input sections is an unambiguous selection input section, and the user selects this selection input section to obtain the best text interpretation of the input sequence input. can accept reading object with frequency of use, (b) by an additional selection of the selection input unit, the input Sea
As a text interpretation of the can, the user is able to select another reading object, each selection of said selection input being one or more specified in memory associated with the generated input sequence. One reading object is selected from the reading objects, and the other reading object is less frequently used, and (c) one of the plurality of input units is a conversion input unit without ambiguity, by selecting the parts, the user to select an entry word object with the highest frequency of use associated with reading object with the highest frequency of use as a text interpretation of the input sequences entered
Can, by additional selection of the conversion input unit (d), the user selects a different headword objects associated with reading object with the highest frequency of use as a text interpretation of the input sequence is <br/> input it can, each selection of the conversion input unit selects one entry word objects from the identified one or more entry word object in memory associated with the reading object with the highest frequency of use
The frequency of use of the another entry word object is low, and (e) by the additional selection of the selection input unit, the user can use another reading object as a text interpretation of the input sequence. after selecting, it is that the user is to select the entry word object with the highest frequency of use associated with the selected reading object as text interpretation of the input sequences entered by selection of the conversion input unit
Can, by an additional selection of (f) the selection input unit, the user after selecting a different reading object as text interpretation of <br/> input sequence, the user inputs the additional selection of the conversion input unit been said it is possible to select a different entry word objects associated with the selected reading object as text interpretation of the input sequence, wherein each selected transform input unit, the identification in the memory associated with the selected reading object which selects one entry word objects from one or more entry word objects
And the frequency of use of the another entry word object is low, and (g) after one or more selections in the selection input section, any one selection of a plurality of inputs associated with one or more characters. Is processed as a first input of the new input sequence , and (h) following the one or more selections of the conversion input, any one selection of a plurality of inputs associated with one or more characters is of the new input sequence . The system of claim 4, wherein the system is processed as a first input. The first kana syllable 11. Ru is output to the user regarding each input sequence ambiguity phrases specified by the first sub-sequence of one or more inputs,
Following one or more of the input sequence of the input associated with one or more characters, when the user selects the <br/> select input unambiguous, processor only the memory those reading object 1 One or confirmed from further reading object, system <br/> beam according to claim 7, wherein the reading object including the determined kana not the same ambiguous same Ru initial position near, it is characterized. 12. The first kana syllable output to the user, the indicated pairs of keystrokes, system of claim 11, wherein a that will be specified rather ambiguity <br/><br / > Mu. 13. The first kana syllable Rubeki is output to the user, having a one or more times associated syllable
By selecting the input that is specified unambiguously,
Here, the system of claim 11, wherein each syllable associated with each input, characterized in that the further related to a unique number of times the input is selected as a general syllable without the ambiguity. The first kana syllable is output to the user Ru for 14. Each input sequence is designated ambiguous phrases by the first results of the one or more input, user, an unambiguous one or more 1 associated with a letter
Or followed by more of the input sequence, came and was selected the "Select" input, the processor checks only those reading objects from one or more of the reading object of the memo <br/> in Li, this reading object is in the same initial position, the system of claim 10 further comprising the determined pseudonym same unambiguous, it is characterized. 15. The first kana syllable output to the user, key by the indicated pairs of strokes, system <br/> arm according to claim 14, wherein the specified unambiguously. 16. Rubeki first kana syllable is output to the user, having a one or more times associated syllable
By selecting the input that is specified unambiguously,
Here, the system of claim 14, wherein each syllable associated with each input, characterized in that the further related to a unique number of times the input is selected as a general syllable without the ambiguity. 17. In a tree structure of memory, each reading is associated with one or more entry words, each entry object is a verbatim interpretation associated with the reading object, and each entry object is , Kanji, and hiragana and katakana
A sequence of characters that includes various combinations of names <br/> and Nde including, by the processor for each reading object,
Containing only generated Katakana, - associated with the "katakana only" have seen <br/> out word object, - headword object "katakana only", where the additional selection of an unambiguous conversion input, claim 10, wherein the free Murrell that in the entry word object as the input sequence <br/> interpretation can be selected by the user
The system described . 18. The "katakana - Only" is provided subsequently to <br/> users in all headword object headword object called users more input additional selection for converting input the unambiguous 18. The selection as a sequence interpretation can be made.
The system described . 19. ambiguous input entered by the user Shi
To eliminate the ambiguity of the Sequence, a disambiguation system for generating a character output Japanese has a plurality of input portions (a), and the input unit is associated with multiple Romaji characters, input sequence, is generated in response to the selection sequence each time the user input device is selected the input unit is operated, it is intended to correspond to the already entered unit selected, the generated input sequence, characters associated with each input portion is to hold the text interpretation having but because ambiguity is more, seen including a user input device, the data for configuring (b) a plurality of reading objects, each reading object is associated with an input sequence and frequency of use, each reading object identifies the sequence of Romaji characters, sea of the Roman letter characters Nsu corresponds to kana having one or more readings of the text object is output to the user, the first sequence of kana of the object phrase phrase objects completed in unfinished words or phrases
Stem object consisting scan, and consists object containing both of them word phrases and stem, all terms, phrases and stem objects are stored in a tree structure having a plurality of nodes in the memory, each node input sequence And a memory associated with one or more reading objects, and (c) a disk displaying system output to the user.
Play, and (d) a processor connected to a user input device, a memory, and a display, the processor from one or more identified reading objects in the memory associated with each input sequence. , At least one or more most frequently used candidate objects are identified, the candidate objects being the input sequence in which at least one or more word or phrase objects are generated.
When associated with Nsu is the phrase or phrase objects, the candidate object, wherein the generated input sequence
If there is no word or phrase objects associated with the scan are stem object, and the processor, each generated input Sea
At least one or more of the identified candidate object associated with cans, generates an output signal to be displayed on the display as interpreting text of the input sequence, it features a system. 20. Each reading objects in the tree structure in memory is associated with 0 or 1 or more headword object, each entry word object here is a text interpretation of the associated reading object,
The system of claim 19 , wherein each headword object includes a sequence of characters that includes any combination of Kanji, Hiragana, Katakana. 21. (a) One of the plurality of input sections is an unambiguous selection input section, and the user can select the selection input section to obtain the best text interpretation of the input sequence input. can accept reading object with frequency of use, (b) by an additional selection of the selection input unit, the input Sea
As a text interpretation of the can, the user is able to select another reading object, each selection of the selection input being one of the one or more specified reading objects in memory associated with the generated input sequence. One reading object is selected, the other reading object is used less frequently, and (c) one of the plurality of input sections is an unambiguous conversion input section, and this conversion input section should be selected. Allows the user to select the most frequently used entry word object associated with the most frequently used reading object as a textual interpretation of the input sequence entered.
Can, by additional selection of the conversion input unit (d), the user selects a different headword objects associated with reading object with the highest frequency of use as a text interpretation of the input sequence is <br/> input it can, each selection of the conversion input unit selects one entry word objects from the identified one or more entry word object in memory associated with the reading object with the highest frequency of use
The frequency of use of the another entry word object is low, and (e) by the additional selection of the selection input unit, the user can use another reading object as a text interpretation of the input sequence. after selecting, it is that the user is to select the entry word object with the highest frequency of use associated with the selected reading object as text interpretation of the input sequences entered by selection of the conversion input unit
Can, by an additional selection of (f) the selection input unit, the user after selecting a different reading object as text interpretation of <br/> input sequence, the user inputs the additional selection of the conversion input unit been said it is possible to select a different entry word objects associated with the selected reading object as text interpretation of the input sequence, wherein each selected transform input unit, the identification in the memory associated with the selected reading object which selects one entry word objects from one or more entry word objects
And the other entry word object is less frequently used, and (g) one or more selections in the selection input section are followed by any one selection of a plurality of inputs associated with one or more characters. is treated as a first input the new input sequence, (h) a first of said converter input of one or more of any one of the selected new input sequence of the plurality of inputs associated with one or more characters Following selection 21. The system of claim 20, wherein the system is processed as an input of. 22. plurality of nodes are connected by a plurality of paths, the plurality of each path, and the parent node associated with the base input sequence, and input the base input sequence及<br/> beauty additional parent node 2. The system according to claim 1, wherein the system links a child node related to. 23. reading objects associated with the child node, the system of claim 22, wherein the is based on reading the object associated with the parent node corresponding child node is linked. 24. reading objects associated with the child node, in order to correct the reading object associated with the parent node the corresponding, characterized in that it is configured with the previously stored code in a memory Claim 23
System. 25. Ri by to correct the reading objects associated with the parent node, code that is used to form a reading objects associated with the child node, corresponding reading objects associated with the parent node and specifications about the numerical index, one of the characters associated with the additional input you are linking the parent node to the child node
The system of claim 24, wherein the containing and specifications about the numerical index against. 26. Ri by to correct the reading object associated with the parent node that is related to the child node
Code used to form the reading object, wherein, wherein the specification of whether the final code further including that of the sequence of code that generates an object that the code is associated with a child node
Item 25. The system according to Item 25 . 27. Additional numbers and identity of the inputs corresponding to the child nodes linked to a parent node is shown in more parent node in the field of reasonable key bits indicating the number and identity of said child nodes Characterized by
The system of claim 25 . 28. pointers to child nodes immediately after each set of many <br/> code from one or used to generate a reading object associated with a child node can <br/> continued , 1 for one or more code or
Many sets and subsequent pointer from it, in the same order as the valid key bits that indicate the number and identity of said child nodes, according to claim 27, wherein the sequentially arranged in the memory in the parent node system. 29. The sequence of code that creates a reading object associated with a child node is ordered in memory such that the reading object is created in a sequence that is sorted by the frequency of use of the object. 26. The system according to claim 25 . 30. The system of claim 25 , wherein the index of the character associated with each input means is sequentially assigned to the character in decreasing order of occurrence of the character in the reading object in memory. 31. Ri by to correct the reading object associated with the parent node that is related to the child node
The code used to form the reading object is related to the object formed in relation to the child node.
The system of claim 30, wherein further including that the specification of object types to be. 32. Object types that are identified, information about the language part of the constructed object including <br/> claim 31, wherein the system. 33. Object types that are identified, information about <br/> beauty suffix Oyo may refractive endings also attached to the structure object of including claim 31, wherein the system. 34. Object types that are identified, the code identifying the configured object-specific among the objects in memory including claim 31, wherein the system. 35. Object types that are identified, information about the frequency of use of constructed objects including請<br/> Motomeko 31 wherein system. 36. Object types that are identified, information about whether constructed object is a complete word including claim 31, wherein the system. Index of 37. characters associated with each input means corresponding to a character that is an index to form a reading object associated with a child node is applied
Systems in order reduction in connection Ku character occurrence frequency of the character immediately preceding the reading object associated with the parent node, according to claim 25, wherein the sequentially assigned to the character that. 38. two parent nodes of the tree structure redundant
Is long and exists in both of the redundant parent nodes.
All code associated with the input means are the same, Oyo the co <br/> over de is generated in the same sequence and the same numerical reading objects in deck scan (LOGICAL-SYMBOL-INDEX)
Identify and beauty same numerical character index (OBJECT-LIST-INDEX), further with about all input related to these, if the child nodes are also redundant in the same recursive sense, said redundant parent nodes one is removed from the tree structure in memory and the remaining redundant parent node is linked is Zoon by any code, and the child nodes that were present only in the removed redundant parent node Claim 25
The system described. 39. One or more codes associated with a given input means and present on both of said redundant parent nodes have different codes in the two redundant parent nodes.
39. The system of claim 38 , wherein the codes are defined to be the same when they occur in a sequence when they specify the same numeric reading object index and the same numeric character index. 40. One or more codes associated with a given input means and present on both of said redundant parent nodes have different codes in the two redundant parent nodes.
39. The system of claim 38 , wherein the codes are defined to be the same when they occur in a sequence when they specify the same numeric reading object index, the same numeric character index, and the same object type. By modifying the reading object 41. associated with the corresponding parent node and associated with a child node
One that will be used to construct the reading object that
Or more code comprises of <br/> object type specification that is associated with the configured reading objects associated with likewise its child nodes, two codes, they are the same numerical reading object index (logical- SYMBOL-INDEX) and the same numeric character index (OBJECT-LIST-INDEX) ,
It is defined as the same, where it is Zoon by any code present in the remaining redundant parent node linked to child nodes that were present only in the removed redundant parent node code is either system all specifications including claim 31, wherein the object type that has been identified in a redundant node. 42. Each reading object constructed at each node of a tree structure in memory is associated with a zero or entry word object, and each entry word object is a textual interpretation of the associated reading object. There, each entry word object, kanji, hiragana, according to claim 25, wherein being configured any sequence or <br/> these characters composed of a combination of single <br/> pseudonym system. 43. A child node headword object associated with the reading object in the claim the child node is based on one or more of the associated lemma object of the parent node corresponding a descendant 42
The system described. Headword objects associated with reading object 44. During the child node, the information corresponding to the previously stored child node in the memory in order to modify the one associated headword objects corresponding ancestor node 44. The system of claim 43 configured using a containing code. 45. Associated with one of the corresponding ancestor nodes
By modifying the headword object, the code used to construct the entry word object associated with the reading object in the child node must go back the tree to reach the corresponding ancestor node node Number specification, the specification of the numerical index of the entry word object associated with the reading object in the corresponding ancestor node in which the reading object in the child node was constructed, and should be attached to the entry word object identified in the ancestor node. Kanji or instructs the other characters, and specifications of numerical character codes constituting the headword objects associated with reading objects in a child node, the including claim 44, wherein the system. 46. Associated with one of the corresponding ancestor nodes
By modifying the headword object, the code used to construct the entry word object associated with the reading object in the child node must go back the tree to reach the corresponding ancestor node node and specifications of numbers, and specifications of numerical index entry word objects reading objects in the child node is associated with reading objects in ancestor nodes corresponding configured, ancestors corresponding to when configuring the reading object at a child node A sequence of one or more pseudonyms attached to the reading object in the node
Nsu also attached as hiragana with the identified entry word objects in ancestor nodes, and specifications indicating that constitutes the entry word object associated with the reading object in the child node, the including claim 44, wherein System. 47. Associated with one of the corresponding ancestor nodes
By modifying the headword object, the code used to construct the reading object associated with the child node, the code is the final sequence of code that generates <br/> object associated with a child node whether specification further including claims 44 system, wherein the code. 48. Associated with one of the corresponding ancestor nodes
By modifying the headword object, in the code used headword objects associated with reading objects in the child nodes to be configured by placing a kanji character, the specification of the Tagged Kanji characters, a ． A specification of the number of nodes that must traverse the tree to reach the corresponding ancestor node, b. Correspondence that the reading object in the child node is configured
The specification of the numerical index of the found word object associated with the reading object in the ancestor node to perform c. One or more sequences of kana given to reading objects in ancestor node corresponding to when configuring reading object in the child node is also attached as hiragana with the identified entry word objects in ancestor node, a child node a specification which indicates that constitutes the <br/> headword objects associated with reading objects in, can a be found in the tree starting from Le Tonodo, and the Chinese characters are related as headword object including specification of the route reading object to
And d. A specification of a numerical index of the entry word object associated with the root reading object, the specification corresponding to the Kanji character attached to construct the entry word object associated with the reading object in a child node; system of including claim 45.