Abstract:
A homograph filter and method which increase the probability that homographs are pronounced correctly in a speech synthesis system utilizes a filter engine operating in conjunction with a set of rules. The filter engine parses a textual sentence to extract any present homographs and applies a correct set of rules to the homograph, based on an optimal search algorithm. The engine then carries out any appropriate substitution of phonetic data. Rules are primarily based on syntactic analisis, based on a priori knowledge of how each homograph is used. The rule set is classified into different categories in order to optimize the search algorithm and to allow the rules to be modified and updated incrementally without effecting the engine construction and/or performance. The search algorithm utilizes syntactic analysis to achieve optimum results. If syntactic analysis does not yield a satisfactory result, semantic analysis could also be utilized to determine the usage of the homograph based on the contents of the items which surround the homograph. The rule set contains a set of grammatical rules to perform syntactic analysis. If syntactic or semantic analysis does not yield a result, the result will be based on the statistical usage of the given homograph.

Description:
FIELD OF THE INVENTION 
     The present invention relates, in general, to data processing systems, and more specifically, to a speech synthesis system capable of correctly pronouncing homographs. 
     BACKGROUND OF THE INVENTION 
     A homograph, as defined by Webster&#39;s Ninth New College Dictionary, is one of two or more words spelled alike but different in meaning or derivation and, sometimes having different pronunciation. For example, the word &#34;bow&#34; functions as a noun, meaning the front part of a ship, or, a decorative knot. The word &#34;bow&#34; also functions as a verb, meaning to bend. The noun and verb versions of the word &#34;bow&#34; have different pronunciations. Other examples of homographs which can function as either nouns or verbs with different pronunciations include words such as wind, defect, conduct, rebel, record, subject, etc. Generally, when reading text, the context of the text provides the reader with a basis for choosing the correct pronunciation of the homograph, however such a task is more difficult for speech synthesis systems. 
     Numerous advances have been achieved recently in speech synthesis technology, i.e., hardware and/or software capable of recreating the format and other vocal patterns required for intelligible human natural language. In particular, because of the large amount of memory required to store digitized speech, many computer based systems use text-to-speech conversion protocols. In these systems, the data to be synthesized is stored in binary form as text and, when necessary, converted to speech for presentation to listeners. Such systems reduce significantly the memory and overhead requirements in synthesizing speech. U.S. Pat. No. 3,704,345, Coker et al., discloses an early text-to-speech system. U.S. Pat. No. 5,157,759, Bachenko discloses a written language parser for a text-to-speech system used to provide properly placed pauses and emphasis in the synthesized words. In many synthesized speech systems homographs are generally ignored, with one pronunciation generated for all instances of a word regardless of the context. Some systems have attempted to alleviate the complexities created by homographs by using a full natural language parser. Unfortunately, the complexity of such a parser is not practical due to the memory and processing overhead required to execute the parser in conjunction with speech generation. Accordingly, a need exists for a method of increasing the probability the homographs are pronounced correctly within a speech synthesis system which may be implemented with as little programming code as possible. Further, a need exists for a means for increasing the probability that such homographs are pronounced correctly which does not significantly reduce the response time of the speech synthesis system. An additional need exists for a way to increase the probability the homographs are pronounced correctly in a speech synthesis environment which does not require significant amounts of system memory. 
     It is therefore an object of the present invention to provide a homograph filter which increases the probability of correctly pronouncing homographs in a speech synthesis environment which has both a fast response time and requires less code overhead and system memory. 
     SUMMARY OF INVENTION 
     The above and other objects are achieved with a homograph filter which increases the probability the homographs are pronounced correctly in a speech synthesis system. The homograph filter comprises a filter engine operating in conjunction with a set of rules. The filter engine parses a textual sentence to extract any present homographs and applies a correct set of rules to the homograph, based on an optimal search algorithm. The engine then carries out any appropriate substitution of phonetic data. The rule set is classified into different categories in order to optimize the search algorithm and to allow the rules to be modified and updated incrementally without effecting the engine construction and/or performance. The search algorithm utilizes syntactic analysis to achieve optimum results. If syntactic analysis does not yield a satisfactory result, then semantic analysis can be applied to analyze the contents of the items surrounding the homograph to determine its usage. The rule set comprises a set of grammatical rules to perform syntactic analysis. If syntactic or semantic analysis does not yield a result, the result will be based on the statistical usage of the homograph. 
     More specifically, the homograph filter retrieves a text sentence from the text database and copies it into a buffer. The sentence is parsed by the filter engine. In the illustrative embodiment, parsing is done by dividing the text into text segments delineated by punctuation characters. However, other parsing schemes may also be implemented. The filter engine examines each word in the text segment against the homograph list in the phonetic table and determines whether a homograph exists within that parsed segment of text. Ultimately, each word of the parsed sentence is compared with words in the homograph table. If a homograph exists, the engine also retrieves the words surrounding the homograph and applies rules to determine how the homograph is being used, i.e. as a past participle, adjective, noun, or verb. The rules are applied in accordance with the attributes associated with the homograph under test, found in the attribute table. Once the filter engine has determined the word usage for the homograph, the filter engine uses the attribute table entries to determine which phonetic code is appropriate for that usage of the given homograph. The phonetic code associated with that homograph is pulled from the phonetic table and inserted into the originally parsed text. The homograph filter passes the text string to the text-to-speech synthesis system. If a homograph is not found, the homograph filter copies the original word back into the text segment. 
     In accordance with one embodiment, the present invention discloses a computer program product for use with a computer system capable of converting text data into synthesized speech. The computer program product includes a computer useable medium having program code embodied in the medium for determining the correct pronunciation of homographs within the text data. The program code parses the text data into phrases and identifies any homographs within the phrases. Program code is further included for determining which homograph pronunciation is preferred, given the context of the homograph within the phrase, in accordance with a predetermined rule set. Program code is further included for substituting the homograph with phonetic data for the preferred pronunciation of the homograph. 
     In another embodiment of the invention, a method for increasing the probability that a homograph is pronounced correctly in a computer system capable of converting text data into synthesized speech includes the steps of parsing the text data into phrases, identifying homographs within the phrases, determining the preferred pronunciation of the homograph within the phrase in accordance with the predetermined rule, and substituting the homograph within the text data with data representing the preferred pronunciation of the homograph. 
     In yet another embodiment, the invention discloses a homograph filter apparatus for use with a computer system capable of converting text data into synthesized speech, the homograph filter containing apparatus for parsing the text data into phrases and identifying homographs within the phrases. Apparatus is further included for determining, in accordance with a predetermined rule set, which homograph pronunciation is preferred given the context of the homograph within the phrase, as well as apparatus for substituting the homograph in the text data with data indicating the preferred phonetic pronunciation. 
     In a further embodiment, the invention discloses a speech synthesis system having a processor, a memory for storing text data, a speech synthesizer coupled to an audio transducer for generating synthetic speech, and program code for converting the text data to phonetic data used by the speech synthesizer. The computer system further incudes a homograph filter operatively coupled between the program code means for converting the speech synthesizer for determining the preferred pronunciation of a homograph within the text data. The homograph filter comprising apparatus for parsing the text data into phrases and for identifying homographs within the phrases. The homograph filter further contains apparatus for determining which pronunciation of a homograph is more preferred in accordance with a predetermined rule set and, apparatus for substituting the homograph within the text data with phonetic data identifying the preferred pronunciation of the homograph. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The above and other features, objects and advantages of the invention will be better understood by referring to the following detailed description in conjunction with the accompanying figures in which: 
     FIG. 1 is a block diagram of a computer system suitable for use with the present invention; 
     FIG. 2A is a conceptual block diagram of a text-to-speech system utilizing the homograph filter of the present invention; 
     FIG. 2B is a conceptual block diagram of the homograph filter of the present invention; 
     FIG. 3 illustrates a representative phonetic table in accordance with the invention; 
     FIG. 4A illustrates parts of speech for a representative list of homographs in accordance with the present invention; 
     FIG. 4B illustrates a homograph proposition pair table in accordance with the present invention; 
     FIG. 5A illustrates the rules, depicted as software functions, in accordance with the present invention; 
     FIG. 5B illustrates a mapping of homograph rules to generic rules in accordance with the illustrative embodiment of the present invention; 
     FIGS. 6A-B illustrate the format of the 32-bit attribute word and a representative attribute table, in accordance with the present invention; 
     FIG. 7 illustrates a functional decomposition of the filter engine, in accordance with the present invention; 
     FIG. 8A is a flowchart illustrating the process steps performed by the filter engine in accordance with the method aspect of the present invention; and 
     FIG. 8B is a flowchart illustrating the process steps performed by the homograph filter in accordance with the method aspect of the present invention. 
    
    
     DETAILED DESCRIPTION 
     FIG. 1 illustrates the system architecture for a computer system 100 such as an IBM PS/2®, on which the invention may be implemented. The exemplary computer system of FIG. 1 is for descriptive purposes only. Although the description may refer to terms commonly used in describing particular computer systems, such as in IBM PS/2 computer, the description and concepts equally apply to other systems, including systems having architectures dissimilar to FIG. 1. 
     Computer system 100 includes a central processing unit (CPU) 105, which may be implemented with a conventional microprocessor, a random access memory (RAM) 110 for temporary storage of information, and a read only memory (ROM) 115 for permanent storage of information. A memory controller 120 is provided for controlling RAM 110. 
     A bus 130 interconnects the components of computer system 100. A bus controller 125 is provided for controlling bus 130. An interrupt controller 135 is used for receiving and processing various interrupt signals from the system components. 
     Mass storage may be provided by diskette 142, CD ROM 147, or hard drive 152. Data and software may be exchanged with computer system 100 via removable media such as diskette 142 and CD ROM 147. Diskette 142 is insertable into diskette drive 141 which is, in turn, connected to bus 30 by a controller 140. Similarly, CD ROM 147 is insertable into CD ROM drive 146 which is, in turn, connected to bus 130 by controller 145. Hard disk 152 is part of a fixed disk drive 151 which is connected to bus 130 by controller 150. 
     User input to computer system 100 may be provided by a number of devices. For example, a keyboard 156 and mouse 157 are connected to bus 130 by controller 155. An audio transducer 196, which may act as both a microphone and a speaker, is connected to bus 130 by audio controller 197, as illustrated. It will be obvious to those reasonably skilled in the art that other input devices, such as a pen and/or tabloid may be connected to bus 130 and an appropriate controller and software, as required. DMA controller 160 is provided for performing direct memory access to RAM 110. A visual display is generated by video controller 165 which controls video display 170. Computer system 100 also includes a communications adaptor 190 which allows the system to be interconnected to a local area network (LAN) or a wide area network (WAN), schematically illustrated by bus 191 and network 195. 
     Operation of computer system 100 is generally controlled and coordinated by operating system software, such as the OS/2® operating system, available from International Business Machines Corporation, Boca Raton, Fla. The operating system controls allocation of system resources and performs tasks such as processing scheduling, memory management, networking, and I/O services, among other things. 
     FIG. 2A is a conceptual block diagram of a text-to-speech system 200 implementing a homographic filter in accordance with the present invention. System 200 comprises a text database 204, a text-to-speech application 202, a speech synthesis system 206, and a transducer, such as a speaker, 208. Homograph filter 210 is illustrated conceptually as part of text-to-speech application 202 but may function completely separate, in conjunction with a text-to-speech application. The structure and function of database 204, speech synthesis system 206 and speaker 208 are known within the relevant art and will not be described herein. In addition, text-to-speech applications are currently commercially available, such as those previously described. 
     Homograph filter 210 is illustrated conceptually in greater detail in FIG. 2B. Specifically, filter 210 comprises a filter engine 212, a buffer 214, a rule set 215, an attribute table 216 and a phonetic table 218, which includes a homograph list 220. In addition, text database 204 and speech synthesis system 206 are illustrated to show their relationship to homograph filter 210. In the illustrative embodiment, the homograph filter 210 is implemented in the C programming language. However, implementation of the instant invention could be accomplished using other software and hardware implementations. For example, an object oriented design language, such as C++ or Java, could also be used for the software implementaiton of the instant invention. 
     Referring FIG. 2B, the homograph filter 210 retrieves a text sentence from the text database 204 and copies it into a buffer 214. The sentence is parsed by the filter engine 212. In the illustrative embodiment, parsing is done by dividing the text into text segments delineated by punctuation characters. However, other parsing schemes may also be implemented. The filter engine 212 examines each word in the text segment against the homograph list 220 in the phonetic table 218 and determines whether a homograph exists within that parsed segment of text. Ultimately, each word of the parsed sentence is compared with words in the homograph table 220. If a homograph exists, the engine 212 also retrieves the words surrounding the homograph and applies rules to determine how the homograph is being used, i.e. as a past participle, adjective, noun, or verb. The rules are applied in accordance with the attributes associated with the homograph under test, found in the attribute table 216. Once the filter engine 212 has determined the word usage for the homograph, the filter engine 212 uses the attribute table 216 entries to determine which phonetic code is appropriate for that usage of the given homograph. The phonetic code associated with that homograph is pulled from the phonetic table 218 and inserted into the originally parsed text. The homograph filter 210 passes the text string to the text-to-speech synthesis system 206. If a homograph is not found, the homograph filter 210 copies the original word back into the text segment. The phonetic table 218, rules DB 215, attribute table 216, and filter engine 212 are discussed in more detail below. 
     FIG. 3 shows a phonetic table 218 in accordance with the illustrative embodiment. The phonetic table 218 is comprised of a homograph list 220 and two phonetic codes associated with each homograph. The homograph list 220 in the phonetic table 218 is used by the filter engine 212 to determine whether or not a parsed word is a homograph. Depending on the determination of the filter engine 212 regarding the usage of the homograph, based on application of the rules, one of the two phonetic representations will be inserted into the originally parsed text string in place of the original homograph. For example, for the homograph &#34;wind&#34;, there are two phonetic representations shown in the phonetic table 218. The first representation or &#34;phonetic #1&#34;, is for the noun form of the homograph &#34;wind&#34;. The second phonetic representation is for the verb form of the word &#34;wind&#34;. If, through application of the rules, its determined that &#34;wind&#34; is used as a noun, the filter engine 212 will substitute phonetic code #1 for the actual &#34;wind&#34; text in the original text string. In the illustrative embodiment, the phonetic codes have the form and content such that they can be recognized and used by the text-to-speech synthesis system 206 in combination with the homograph filter 210. 
     FIG. 4A is a representative list of the homographs and the associated parts of speech for which each homograph may be used. The filter engine 212 exploits the limitations on word usage for each homograph to reduce the number of rules to be applied to each homograph. For example, FIG. 4A shows that &#34;address&#34; can only be a noun or verb, &#34;close&#34; can only be a verb or adjective, and so on. The filter engine 212 will not apply a rule relating to adjectives or past participles when trying to determine the proper usage for the homograph &#34;address&#34;, which can only be a verb or noun. The filter engine 212 employs the concept of &#34;proposition pairs&#34; to limit the application of homograph rules to a relevant rules subset and ultimately to determine the part of speech for which a homograph is being used. 
     FIG. 4B illustrates possible proposition pairs according to the illustrative embodiment. The phrase &#34;proposition pair&#34; refers to a grouping of two, or a pair of, possible parts of speech for a given homograph. For example, a proposition pair for &#34;address&#34; is noun-verb (NV) and another is verb-noun (VN). This concept of proposition pairs is embedded inherently in the rules to optimize searching. In fact, each homograph rule sets out the test to be applied to a given proposition pair. An attribute code, discussed below, is associated with each homograph, which informs the filter engine 212 as to which subset of rules to apply, given the possible proposition pairs for each homograph. Therefore, only rules applicable to a certain homograph are applied, thus minimizing the search time and processing. 
     In the illustrative embodiment, there are four different sets of homograph rules: noun, verb, adjective, and past participle. Each homograph rule in the set of rules relates to a proposition pair. For example, referring to FIG. 4B, there is a noun-verb (NV) rule within the noun set of homograph rules, as well as a noun-adjective (NA) rule and noun-preposition (NP) rule. Furthermore, there may be multiple homograph rules for a given proposition pair, such as NV, which relate to the likelihood a given homograph is used as a certain type of word or is used within a known combination of words. Consequently, each homograph rule within each set of homograph rules is further distinguished as being &#34;special&#34;, &#34;certainty&#34;, or &#34;probable&#34; rules. So, it&#39;s possible to have a special NV rule, a certainty NV rule, and a probable NV rule. These possibilities hold true for each rule set: noun, verb, adjective, and past participle. A &#34;special&#34; rule relates to a unique combination of a homograph and adjacent word, with a variety of tenses of the adjacent word possible. Satisfaction of a special rule yields an accurate determination of how a particular homograph is being used, e.g. &#34;address&#34; is used as a noun. A &#34;certainty&#34; rule has a more general application than a special rule, but when a homograph of a given speech type is paired with another type of word, application of the rule accurately identifies whether the homograph is a noun, verb, adjective, or past participle. A &#34;probable&#34; rule is similar to a certainty rule, but does not yield a definite result. 
     FIG. 5A shows all of the rules of the illustrative embodiment depicted as C language software functions. These rule functions are stored in the rules DB 215 and called and run by the filter engine 212. The top-level &#34;Apply Ruleso&#34; function 400 of the filter engine 212 calls the appropriate subset of homograph rules 420 for a homograph under test. As mentioned earlier, each homograph rule 420, is based on a proposition pair and is distinguished as being a special, certainty, or probable rule. Furthermore, in some instances special test &#34;cases&#34; comprise part of a homograph rule. For example, the ApplySpecialAdjV() function or rule includes a special test case to determine whether the preposition &#34;from&#34; follows the homograph &#34;live&#34;. If so, &#34;live&#34; is being used as an adjective. 
     Beyond the homograph rules 420, there are generic rules 440 associated with the words surrounding the homograph. The filter engine 212 runs the generic rule functions 440 to determine the word type of each of as many as two words preceding and following the homograph. In some cases, the engine 212 will search less than two words around the homograph, by design, and will not necessarily search words preceding and following the homograph. This tailoring is built into each rule based on a priori knowledge of how each homograph is used with other words. This scheme could easily be extended to analyze more than two words preceding and following the homograph under test for, perhaps, higher accuracy of the system. The filter engine 212 will not search beyond a punctuation mark for the surrounding words. For example, the filter engine 212 might try to determine whether the homograph is preceded by a personal pronoun or perhaps a form of the verb &#34;to be&#34;, e.g. &#34;am&#34;, &#34;are&#34;, &#34;is&#34;, &#34;was&#34;, or &#34;were&#34;. Analysis of the surrounding words helps determine the usage of the homograph. In the illustrative embodiment, the homograph rules 420 have embedded within them function calls to the relevant generic rules 440. For example, the &#34;ApplySpecialAdjVo()&#34;, i.e. special adjective-verb, rule calls the &#34;IsDefArticle()&#34;, i.e. is it a definite article, rule. A mapping of the generic rules 440 to those homograph rules 420 which call them is provided in FIG. 5B. Generic rules 440 can be called by multiple homograph rules or functions. For example, IsDefArticle() is also called by ApplySpecialNounV(), ApplyCertNounV(), ApplyCertVerbN(), and ApplyProbAdjN(). The application of generic rules 440 is not coded into the homograph attribute codes, unlike the application of the homograph rules 420 which is coded into the attribute codes. 
     It is significant that homograph rules are applied to a homograph under test in a deliberate manner to implement an optimal search based on a priori knowledge of the limited parts of speech that the homograph under test may assume. Accordingly, generic rules are also called by homograph rules in a deliberate manner to ensure that only relevant rules are used with a homograph under test. While FIG. 5B shows a mapping between homograph rules and generic rules for the illustrative embodiment, the rules could be modified or applied in a variety of ways to achieve substantially the same result as the instant invention. 
     An example of a homograph rule of the illustrative embodiment coded in the C programming language is as follows: 
     
         ______________________________________/******************************************************//* FUNCTION:BOOL ApplyCertPastV (LPWCP IpWCB, LPRCB IpRCP,WORD RuleNumber, LPINT IpMask)PURPOSE:Apply either a specific or all certainty pastp-verb rules to a word.*******************************************************/BOOL ApplyCertPastV (LPWCP IpWCB, LPRCB IpRCP, WORD RuleNumber, LPINT IpMask)BOOL TestAll,Result,GroupResult;//initif (RuleNumber==0)            //test all rules{    TestAll = 1;RuleNumber = 1; //start from lowest rule number}elseTestAll = 0;    //test this specific rule onlyGroupResult = 0;                //RuleNumber = parameter passed//apply ruleswhile((RuleNumber&lt;=IpRCB-&gt;VMaxCertPastVRule) &amp;&amp;GroupResult!=-1){                //more rules to test, no certainty yetResult = 0;      //default valueswitch (RuleNumber){case 1://W{pastp,verb} &amp; [to have conjugate, W]=&gt;W{pastp}if(IsToHave (IpWCB-&gt;OnePre)   || IsToHaveNot(IpWCB-&gt;TwoPre, IpWCB-&gt;OnePre)   || IsToHaveNotCtract (IpWCB-&gt;OnePre))   Result = -1;            //rule assertedbreak;           //end case 1case 2://W{pastp,verb} &amp; [{he,she,it}W]&amp; W{singular}=&gt;W{pastp}if(!*IpWCB-&gt;sEnding &amp;&amp;  (!strcmp (&#34;he&#34;, IpWCB-&gt;OnePre)  || !strcmp (&#34;she&#34;,IpWCB-&gt;OnePre)))Result = -1      //rule assertedbreak;           //end case 2}                //end switchGroupResult = GroupResult + Result;if(TestAll)      //test the next rule if test all trueRuleNumber++;}                // end whilereturn (GroupResult);}                // end function______________________________________ 
    
     This example illustrates the homograph rule 420 &#34;ApplyCertPastV()&#34;, with calls to the generic rules 440 &#34;IsToHave()&#34;, &#34;IsToHaveNot()&#34;, and &#34;IsToHaveNotCtract()&#34; and two special test cases. The C language coding for the generic rule &#34;IsToHave()&#34; follows, for illustrative purposes. 
     
         ______________________________________/***********************************************************//* FUNCTION:BOOL IsToHave (LPSTR String)PURPOSE: Assert whether word is a conjugated form of the verb to have(i.e. have, has, had). Return true if so.************************************************************/BOOL IsToHave (LPSTR String)if(! strcmp (String, &#34;have&#34;)|| !strcmp (String, &#34;has&#34;) ||!strcmp(String, &#34;had&#34;))return (1);        //match foundelsereturn (0)}                  //end function______________________________________ 
    
     The homograph rules 420 and generic rules 440 are stored in the rule DB 215 and accessed by the filter engine 212 according to the coding of the attribute code for a homograph under test. 
     A summary of each homograph and generic rule is provided near the close of the this section. In light of the functional descriptions of the rules illustrated in FIG. 5A, the Rule Summaries, and the code examples contained herein, the actual coding of each rule module to perform the specified functions associated therewith is within the scope of those skilled in the programming arts. 
     The structure of the 32-bit attribute code assigned to each homograph is shown in FIG. 6A. The attribute code denotes the part of speech, i.e. verb, noun, adjective or past participle, a given homograph can assume and the applicable rules, i.e. special, certainty, or probable, to be applied to a particular homograph under test. The attribute also incorporates a phonetic index associated with the pronunciation of the homograph. As discussed earlier, the phonetic index relates to the possible pronunciations of the homograph, depending on the rule determined usage of the homograph. Finally, the attribute code includes a statistics bit. If through application of the rules, the filter engine 212 is not able to determine the certain or probable pronunciation of the homograph, the filter engine 212 relies on the statistics bit to determine the statistically probable pronunciation of the homograph. 
     FIG. 6B shows an attribute table 216 in accordance with the illustrative embodiment for a representative sample of homographs. The 32-bit attribute code is represented in an 8-bit hexadecimal attribute code, with the right most bit being the least significant bit. The least significant bit, i.e. &#34;statistics bit&#34;, in the right hand Phonetic Usage Based On Statistics Bit column, corresponds to the pronunciation of the homograph based on statistical usage. If the statistics bit is &#34;0&#34;, the engine 212 will use the &#34;Phonetic #1&#34; representation for the homograph, as shown in FIG. 3. If the statistics bit is &#34;1&#34;, the engine 212 will use the &#34;Phonetic #2&#34; representation. 
     Again referring to FIG. 6B, the second bit of the 8-bit hexadecimal attribute code corresponds to a 4-bit binary word representing &#34;Phonetic Usage Based On Rules&#34;, i.e. &#34;phonetic usage word&#34;. If the 4-bit binary phonetic usage word is &#34;0001&#34;, as with &#34;address&#34;, a &#34;1&#34; appears as the second bit of the 8-bit hexadecimal attribute code. The phonetic usage word is also directly related to the &#34;Applicable Parts of Speech&#34; 4-bit binary code. That is, if a homograph rule is satisfied, the 4-bit binary phonetic usage word indicates which phonetic code from the phonetic table, FIG. 3, will be used for a homograph given the determined word usage for the homograph. But, possible word usages are limited, as indicated by entries in the Applicable Parts of Speech column. For example, the word &#34;address&#34; can take on the applicable parts of speech of a noun (N), or verb (V), but not an adjective (A) or past participle (P), as indicated by the &#34;1&#34; under each &#34;N&#34; and &#34;V&#34; heading and a &#34;0&#34; under the &#34;P&#34; and &#34;A&#34; headings. This yields a 4-bit binary word of &#34;0011&#34; in the Applicable Parts of Speech column. The 4-bit binary word for phonetic usage also indicates a bit associated with P, A, N and V, which is &#34;0001&#34; for &#34;address&#34;, although the bits associated with the &#34;P&#34; and &#34;A&#34; are meaningless for &#34;address&#34;. Therefore, if &#34;address&#34; is used as a verb the &#34;1&#34; under V in the Phonetic Usage Based on Rules column indicates that the Phonetic #2 code from the phonetic table of FIG. 3 will be used. A &#34;0&#34; under the N indicates that the Phonetic #1 code will be used if &#34;address&#34; is determined to be used as a noun. 
     Referring to the &#34;Applicable Rules&#34; column of FIG. 6B, &#34;SCP&#34; refers to the first, second, and third bit of a 4-bit binary word, with the fourth, most significant bit, of the 4-bit word unused. The Applicable Rules column 4-bit binary word represents whether the special, certainty, or probable homograph rules must be applied by the filter engine 212 for the given homograph. Again, for the homograph &#34;address&#34;, &#34;CP&#34; equates to &#34;0011&#34; which equals 3. Referring to the 8-bit hexadecimal attribute code, accordingly bits 4 and 6 are shown to be &#34;3&#34;. Had there been an S in the applicable rules column for &#34;address&#34; also, there would have been a &#34;3&#34; in the 8th bit of the hexadecimal representation of the attribute code. This is shown in the representation of the word &#34;close&#34;, where a &#34;5&#34; appears as the 4th, 6th and 8th bits. In this way, the applicable homograph rules are encoded into the attribute code for each homograph. Bits 3, 5, and 7 of the 8-bit hexadecimal attribute code remain &#34;0&#34; and are unused. 
     As shown in FIG. 7, filter engine 212 can be decomposed into the following functions: text string retrieve and copy 250, text string parse 252, word retrieve, copy, and prepare 254, homograph test 256, attribute retrieval 260, rules application 262, and phonetic substitution 264. This is a notional functional composition used to represent the basic functional elements of the filter engine, but the actual software coding of the functions need not be segmented into these specific functional modules. In the text string retrieve and copy function 250, the filter engine 212 goes into a text database 204 or &#34;clipboard&#34; maintained by the computer&#39;s 100 operating system and copies a text segment into a homograph filter buffer 214. In the text string parse function 252, the filter engine 212 operates on the text string stored in the buffer 214 by parsing it into text segments, delineated at punctuation marks. Once parsing has been completed, the word retrieval, copy, and prepare function 254 operates by using a &#34;NextWord()&#34; function to copy in the first, and subsequently the next, word in the segment to be tested into a variable, called &#34;word&#34; in the illustrative embodiment. This function also strips any plurality or past tense from the word to be tested. The filter engine 212 then conducts a homograph test 256, by comparing the variable &#34;word&#34; against each homograph 220 listed in the phonetic table 218 using a function called &#34;MatchWord()&#34;. If there is a match, the word under test is a homograph, the word retrieval, copy, and prepare function 254 proceeds to copy the two words preceding and following the homograph using its &#34;GetOnePre()&#34;, &#34;GetTwoPre()&#34;, &#34;GetOnePost()&#34;, and &#34;GetTwoPost()&#34; functions. While the illustrative embodiment analyzes, at most, the two words preceding and following the homograph, more words could also be analyzed if desired. If any of these functions reach a punctuation mark the function stops, since the filter engine 212 assumes that the relationship between a word separated from the homograph by punctuation is not necessarily useful in determining the usage of the homograph. The preceding and following two words are stripped of plurality and past tense, if any, to prepare them for use with the rules. Next, the attribute retrieval function 260 obtains the attribute code for the given homograph from the attribute table 6B. The filter engine 212 uses the rules application function 262 to apply all relevant rules 420, 440 associated with the homograph under test, which is referred to as syntactic analysis. If application of the rules yields satisfaction of a special, certainty, or probable rule, the filter engine 212 uses the phonetic usage portion of the attribute code to retrieve the appropriate phonetic code from the phonetic table 218. This functionality is coded in a separate routine called &#34;GetPhonelndex()&#34;. If none of the syntactic-based rules are satisfied, then syntactic analysis has failed. Consequently, the filter engine 212 could then apply semantic analysis, which is another rule based analysis which focues on the contents, e.g. punctuation, numbers, and words, surrounding the homograph to determine how a given homograph is being used. Ultimately, if the application of rule based analysis has not yielded a satisfactory result, a result will be arrived at based on statistical probability by retrieving the statistical usage bit from the attribute code and retrieving the related phonetic code from the phonetic table 218. In either case, once the phonetic code is obtained, the filter engine 212, in the phonetic substitution function 264, replaces the original text with the phonetic code. If a homograph was never found the filter engine 212 copies the original text back into the text segment. 
     FIG. 8A shows the inventive method steps for determining the proper pronunciation of a homograph and converting the text homograph into synthesized speech. In the preferred embodiment, the homograph filter 210 is used in conjunction with a text database 204 and a speech synthesis system 206 to convert text into audio. In the first step 500, the process is started by having the computer running and text available in the text database. In the second step 510, a text string is received by the homograph filter 210 from the text database 204. In step 520, this string is stored in a buffer by the homograph filter for use by the filter engine 212. The homograph filter, in step 530, passes the string to the filter engine 212. In step 540, the filter engine 212 determines the certain, or at least most probable, phonetic representation of the text. This determination is made by the filter engine 212 through the application of a prioritized set of rules associated with each homograph, as is discussed more fully below and illustrated in FIG. 5B. Once the filter engine 212 has determined the proper phonetic representation of the homograph, the homograph filter 210, in step 550, inserts the phonetic code into the original text string where the homograph was originally located. The homograph filter 210 then passes the text string to the speech synthesis system 206. This completes the method of the preferred embodiment as shown in step 560. 
     FIG. 8B illustrates the method employed by the filter engine 212 to accomplish the method shown in step 540 of FIG. 5A. In step 605, the filter engine 212 parses the received text string into segments. In the illustrative embodiment, the parsing into phrases is done using punctuation characters as delineaters, as described previously. In step 610, the filter engine 212 compares words in the text string against a predefined homograph table. If the filter engine 212 determines in step 615 that a homograph exists in the parsed text string, the filter engine 212 proceeds to determine the correct or at least most probable phonetic representation of the homograph. According to step 615, if a homograph does not exist in the text string, the parsed text string is returned to the homograph filter 210 in step 680. At this point the operation of filter engine 212 would be complete, as shown in step 690. If there is a homograph in the text string, the engine 212 determines, based on an attribute code, the applicable rules for that homograph. Rules will be pulled from the rules database according to the following priority: special rules, certainty rules, and probable rules. As discussed earlier, the rules relate to all possible proposition pairs for each homograph. Coding of the 32-bit attribute word inherently identifies which rules the filter engine 212 will apply and the possible phonetic codes associated with the given homograph. To optimize the search, a priori knowledge of the limited possible usages for each homograph is reflected in the attribute code via the limitation on proposition pairs associated with each homograph. In applying a rule, the filter engine 212 looks at the possible usage of the homograph, e.g. noun, and the words adjacent to the homograph. Application of rules is tailored, by the coding of the attribute code, for each homograph to ensure an optimal search, with no wasted processing by the computer 100 from applying, for example, a verb rule to a homograph that can never be used as a verb. Application of the special, certainty, and probable rules is the syntactic analysis referred to earlier. Because there are fewer special rules than any other type, satisfaction of a special rule will result in the least amount of processing time. Therefore, the filter engine 212 will apply special rules in step 622, if any, first. In step 625 the filter engine 212 determines if the first applicable special rule is satisfied. If so, the filter engine 212 proceeds to step 660, where the appropriate phonetic representation is retrieved from the phonetic table of FIG. 4E. If the analysis in step 625 showed that the applicable special rule was not satisfied, the filter engine 212 determines whether there are remaining applicable special rules, in step 630. If there is another applicable special rule, the filter engine 212 proceeds back to step 622 and applies the next special rule, as discussed above. If no special rule has been satisfied and all special rules are exhausted, the filter engine 212 proceeds from step 630 to step 632, where the filter engine 212 applies the first applicable certainty rule, according to the coding of that homograph&#39;s 32-bit attribute word. As with the special rules, the filter engine 212 determines whether the certainty rule is satisfied in step 635. If so, the filter engine 212 proceeds to step 660. If not, the filter engine 212 proceeds to step 640 and determines whether there are any remaining certainty rules to apply. If there are remaining certainty rules, the filter engine 212 proceeds back to step 632 and determines whether the next certainty rule is satisfied, as before. If no certainty rule has been satisfied and all certainty rules are exhausted, the filter engine 212 proceeds to apply the first applicable probable rule in step 642. Regardless of whether the applied probable rule was satisfied, the filter engine 212 determines in step 645 whether all probable rules have been exhausted. The filter engine 212 will apply all applicable probable rules, regardless of how many are satisfied. In step 650 the filter engine 212 will determine whether at least one probable rule was satisfied. In the illustrative embodiment, if no probable rules were satisfied, the filter engine 212 will use the statistical rule in step 655, based on the statistics bit in the 32-bit attribute word, and choose the most likely usage, e.g. noun, of the homograph given the words adjacent to it in the parsed text. The filter engine 212 will proceed from step 655 to step 660 and insert the appropriate phonetic code for the homograph, e.g. &#34;noun&#34; phonetic code for the homograph. If, in step 650, the filter engine 212 determined that more than one probable rule was satisfied, the engine 212 will proceed to step 652 and determine, based on weighting of the probable rules, which rule was best satisfied and, therefore, which satisfied rule will most likely yield the proper usage of the homograph. The filter engine 212 will then proceed from step 652 to step 660 and retrieve the phonetic code to be substituted from the phonetic table and insert the phonetic code into the originally parsed text in place of the homograph. The filter engine process is then complete, as shown in step 690. The homograph filter 210 then begins processing again at step 550 of FIG. 8A. 
     Summary of Rules 
     As discussed earlier, there are two types of rules which are coded, in the illustrative embodiment, as C functions. They are generic rules 440 and homograph rules 420. These functions, implementing rules, are summarized below. The generic rule functions are discussed first and then the homograph rule functions, which call the generic rule functions, are discussed. FIG. 5B shows the mapping of generic rules to homograph rules in the illustrative embodiment, but the rules could be modified and, possibly applied in different ways, to achieve substantially the same result as disclosed herein. 
     Generic Rules 
     The naming conventions for each generic rule function is comprised of two parts. First, the word &#34;Is&#34; is used to indicate that the function implements a true or false type of test. Next, appended to &#34;Is&#34;, is a text segment identifying the part of speech for which the function tests. Other naming conventions may also be used. If the test implemented by the function is satisfied, the function returns a &#34;1&#34; indicating &#34;true&#34;, else the function returns a &#34;0&#34; indicating &#34;false&#34;. 
     IsDefArticle() is called to determine whether the word passed to it is a definite article. That is, is the word passed &#34;a&#34;, &#34;an&#34;, or &#34;the&#34;? 
     IsIndefArticle() is called to determine whether the word to it is an indefinite article. That is, is the word passed &#34;certain&#34;, &#34;few&#34;, &#34;many&#34;, &#34;more&#34;, &#34;several&#34;, or &#34;some&#34;? 
     IsDemonstrative() is called to determine whether the word passed to it is a demonstrative. That is, is the word passed &#34;this&#34;, &#34;that&#34;, &#34;these&#34;, or &#34;those&#34;? 
     IsToBe() is called to determine whether the word passed to it is a form of the verb &#34;to be&#34;. That is, is the word passed &#34;am&#34;, &#34;are&#34;, &#34;is&#34;, &#34;was&#34;, or &#34;were&#34;? 
     IsToBeNot() is called to determine whether two adjacent words passed to it are a negated conjugated form of the verb &#34;to be&#34;. That is, are the words &#34;am not&#34;, &#34;are not&#34;, &#34;is not&#34;, &#34;was not&#34;, or &#34;were not&#34;? 
     IsToBeNotCtract() is called to determine whether the word passed to it is a negated form of the verb &#34;to be&#34; contracted. That is, is the word &#34;ain&#39;t&#34;, &#34;aren&#39;t&#34;, &#34;isn&#39;t&#34;, &#34;wasn&#39;t&#34;, or &#34;weren&#39;t&#34;? 
     IsToBeEquiv() is called to determine whether the word passed to it is an equivalent form of the verb &#34;to be&#34;. That is, is the word &#34;appear&#34;, &#34;become&#34;, &#34;feel&#34;, &#34;look&#34;, &#34;seem&#34;, &#34;smell&#34;, &#34;sound&#34;, or &#34;taste&#34;, or a form thereof, e.g. &#34;appears&#34; or &#34;felt&#34;? 
     IsToHave() is called to determine whether the word passed to it is a conjugated form of the verb &#34;to have&#34;. That is, is the word &#34;have&#34;, &#34;has&#34;, or &#34;had&#34;? 
     IsToHaveNot() is called to determine whether the words passed to it are a negated conjugated form of the verb &#34;to have&#34;. That is, are the words &#34;have not&#34;, &#34;has not&#34;, or &#34;had not&#34;? 
     IsToHaveNotCtract() is called to determine whether the word passed to it is a negated contracted form of the verb &#34;to have&#34;. That is, is the word &#34;haven&#39;t&#34;, &#34;hasn&#39;t&#34;, or &#34;hadn&#39;t&#34;? 
     IsToDo() is called to determine whether the word passed to it is a conjugated form of the verb &#34;to do&#34;. That is, is the word &#34;do&#34;, &#34;does&#34;, or &#34;did&#34;? 
     IsToDoNot() is called to determine whether the two adjacent words passed to it are a negated conjugated form of the verb &#34;to do&#34;. That is, are the words passed to it &#34;do not&#34;, &#34;does not&#34;, or &#34;did not&#34;? 
     IsToDoNotCtract() is called to determine whether the word passed to it is a negated contracted form of the verb &#34;to do&#34;. That is, is the word &#34;don&#39;t&#34;, &#34;doesn&#39;t&#34;, or &#34;didn&#39;t&#34;? 
     IsPrepG1() is called to determine whether the word passed to it is a preposition from Group 1. That is, is the word &#34;for&#34;, &#34;from&#34;, &#34;in&#34;, &#34;of&#34;, &#34;off&#34;, &#34;on&#34;, &#34;over&#34;, &#34;with&#34;, or &#34;without&#34;? 
     IsPrepG2() is called to determine whether the word passed to it is a preposition from Group 2. That is, is the word &#34;around&#34;, &#34;away&#34;, &#34;by&#34;, &#34;close&#34;, &#34;far&#34;, &#34;in&#34;, &#34;near&#34;, &#34;next&#34;, &#34;for&#34;, &#34;off&#34;, &#34;with&#34;, or &#34;within&#34;? 
     IsPersPronoun() is called to determine whether the word passed to it is a personal pronoun. That is, is the word &#34;I&#34;, &#34;you&#34;, &#34;he&#34;, &#34;she&#34;, &#34;it&#34;, &#34;we&#34;, or &#34;they&#34;? 
     Is PossessiveP() is called to determine whether the word passed to it is a possessive pronoun. That is, is the word &#34;my&#34;, &#34;your&#34;, &#34;his&#34;, &#34;her&#34;, &#34;its&#34;, &#34;our&#34;, or &#34;their&#34;? 
     IsIndefPronounG1() is called to determine whether the word passed to it is an indefinite pronoun from Group 1. That is, is the word &#34;all&#34;, &#34;both&#34;, &#34;certain&#34;, &#34;few&#34;, &#34;many&#34;, &#34;several&#34;, or &#34;some&#34;? 
     IsIndefPronounG2() is called to determine whether the word passed to it is an indefinite pronoun from Group 2. That is, is the word &#34;little&#34;, &#34;more&#34;, &#34;or &#34;much&#34;? 
     IsImpIndObj() is called to determine whether the word passed to it is an impersonal indirect object. That is, is the word &#34;me&#34;, &#34;you&#34;, &#34;him&#34;, &#34;her&#34;, &#34;it&#34;, &#34;us&#34;, or &#34;them&#34;? 
     IsAux() is called to determine whether a word is an auxiliary. That is, is the word &#34;can&#34;, &#34;could&#34;, &#34;might&#34;, &#34;must&#34;, &#34;shall&#34;, &#34;should&#34;, &#34;will&#34;, or &#34;would&#34;. 
     IsAuxNot() is called to determine whether the words passed to it are a negative auxiliary combination. That is, are the words &#34;could not&#34;, &#34;might not&#34;, &#34;shall not&#34;, &#34;should not&#34;, &#34;will not&#34;, or &#34;would not&#34;? 
     IsAuxNotCtract() is called to determine whether the word passed to it is a negated auxiliary contracted. That is, is the word &#34;cannot&#34;, &#34;can&#39;t&#34;, &#34;couldn&#39;t&#34;, &#34;mustn&#39;t&#34;, &#34;shan&#39;t&#34;, &#34;shouldn&#39;t&#34;, &#34;won&#39;t&#34;, or &#34;wouldn&#39;t&#34;? 
     IsModifierG1() is called to determine whether the word passed to it is a modifier from Group 1. That is, is the word &#34;so&#34;, &#34;too&#34;, &#34;or &#34;very&#34;? 
     IsModifierG2() is called to determine whether the word passed to it is a modifier from Group 2. That is, is the word passed to it &#34;few&#34;, &#34;little&#34;, &#34;many&#34;, or &#34;much&#34;? 
     IsModiferG3() is called to determine whether the word is a modifier from Group 3. That is, is the word &#34;never&#34; or &#34;quite&#34;? 
     IsAdverb() is called to determine whether the word passed to it is an adverb. 
     Homograph Rules 
     The naming convention for each homograph rule function is comprised of four pieces of text information. First, the word &#34;Apply&#34; is used to indicate that when the function is called, a rule is being applied. Second, an indication is given as to what type of rule the function represents: special, certainty, or probable. Third, identification of the part of speech for the first word of the proposition pair under test is given, i.e. &#34;Verb&#34;, &#34;Noun&#34;, &#34;Adj&#34;, or &#34;Past&#34;. Finally, the fourth textual part of the function name is a single letter indicating the part of speech for the second word of the proposition pair, i.e. &#34;V&#34;, &#34;N&#34;, &#34;A&#34;, or &#34;P&#34;. Other naming conventions may also be used. Once a called rule function has completed its execution, the function returns a value to the routine from which it was called which indicates whether or not the rule was satisfied. The returned value is central to the filter engine&#39;s determination of whether or not to apply additional rules. 
     ApplySpecialAdjN() is called to determine whether the homograph is being used in its adjective or noun form in accordance with a special case coded into the function. For example, if the homograph &#34;minute&#34; is followed by &#34;amount&#34;, then &#34;minute&#34; is being used as an adjective. 
     ApplySpecialAdjV() is called to determine whether the homograph is being used in its adjective or verb form in accordance with special cases coded into the function. For example, if the homograph &#34;live&#34; is followed by &#34;from&#34; or &#34;via&#34;, then &#34;live&#34; is being used as an adjective. If the homograph &#34;close&#34; is followed by &#34;to&#34;, &#34;close&#34; is being used as an adjective. If the any of the homographs &#34;close&#34;, &#34;live&#34; or &#34;perfect&#34; are preceded by a definite article, the homograph is being used as an adjective. 
     ApplySpecialNounV() is called to determine whether the homograph is being used in its noun or verb form in accordance with special cases coded into the function. For example, if the homograph &#34;tear&#34; is followed by &#34;gas&#34;, then utear&#34; is being used as part of the noun &#34;tear gas&#34;, and is pronounced like &#34;teer&#34;. If &#34;tear&#34; is preceded by &#34;wear and&#34;, then &#34;tear&#34; is being used as part of the common noun phrase &#34;wear and tear&#34;, and is pronounced like &#34;tare&#34;. If the homograph &#34;lead&#34; is followed by &#34;foot&#34;, &#34;pencil&#34;, or &#34;out&#34;, then &#34;lead&#34; is pronounced like &#34;led&#34;. 
     ApplySpecialVerbA() is called to determine whether the homograph is being used in its verb or adjective form in accordance with special cases coded into the function. For example, if the homograph &#34;live&#34; is followed by a preposition, then &#34;live&#34; is being used as a verb. 
     ApplySpecialVerbN() is called to determine whether the homograph is being used in its verb or noun form in accordance with special cases coded into the function. For example, if the homograph &#34;wind&#34; is followed by &#34;up&#34; or &#34;down&#34;, then &#34;wind&#34; is being used as a verb. 
     ApplyCertPastV() is called to determine whether the homograph is being used in its past participle or verb form in accordance with certain cases coded into the function and application of the general rules. For example, if the homograph is preceded by a version of the verb &#34;to have&#34;, or by &#34;he&#34;, &#34;she&#34;, or &#34;it&#34;, then the homograph is being used as a past participle. 
     ApplyCertAdjN() is called to determine whether the homograph is being used in its adjective or noun form in accordance with certain cases coded into the function and application of the general rules. For example, if the homograph is preceded by a version of the verb &#34;to be&#34;, or its equivalent, and it does not end in &#34;s&#34;, then the homograph is being used as an adjective. If the homograph is preceded by a personal pronoun and the personal pronoun is preceded by a version of the verb &#34;to be&#34; and does not end in &#34;s&#34;, then the homograph is being used as an adjective. If the homograph is preceded by the word &#34;so&#34; or &#34;too&#34;, then the homograph is being used as an adjective. If the homograph is preceded by the word &#34;never&#34; or &#34;quite&#34;, then the homograph is being used as an adjective. 
     ApplyCertAdjV() is called to determine whether the homograph is being used in its adjective or verb form in accordance with certain cases coded into the function and application of the general rules. For example, if the homograph is preceded by a version of the verb &#34;to be&#34; and does not end in &#34;s&#34;, the homograph is being used as an adjective. If the homograph is preceded by &#34;so&#34;, &#34;too&#34; or &#34;very&#34;, then the homograph is being used as an adjective. If the homograph is preceded by a Group 2 Modifier and the Group 2 Modifier is preceded by a Group 1 Modifier, then the homograph is being used as an adjective. 
     ApplyCertNounA() is called to determine whether the homograph is being used in its noun or adjective form in accordance with certain cases coded into the function and application of the general rules. For example, if the word ends in &#34;s&#34;, then the word is a noun. 
     ApplyCertNounV() is called to determine whether the homograph is being used in its noun or verb form in accordance with certain cases coded into the function and application of the general rules. For example, if the homograph is preceded by a definite article, then the homograph is being used as a noun. If the homograph is followed by a version of the verb &#34;to be&#34; or &#34;to have&#34;, then the homograph is being used an a noun. If the homograph is followed by an auxiliary word, then the homograph is being used a noun. If the homograph is preceded by a Group 1 Preposition, then the homograph is being used as a noun. If the homograph is preceded by a possessive pronoun, then the homograph is being used as a noun. If the homograph is preceded by the word &#34;whose&#34;, then the homograph is being used as a noun. If the homograph is followed by a version of the verb &#34;to do&#34;, then the homograph is being as a noun. Finally, if the homograph is preceded by a Group 1 Indefinite pronoun, then the homograph is being as a noun. 
     ApplyCertVerbA() is called to determine whether the homograph is being used in its verb or adjective form in accordance with certain cases coded into the function and application of the general rules. For example, if the homograph is preceded by a form of an auxiliary word, then the homograph is being used as a verb. If the homograph has a &#34;s&#34; ending, then the homograph is being used as a verb. 
     ApplyCertVerbN() is called to determine whether the homograph is being used in its verb or noun form in accordance with certain cases coded into the function and application of the general rules. For example, if the homograph is preceded by a personal pronoun, then the homograph is being as a verb. If the homograph is preceded by some form of an auxiliary word, then the homograph is being used as a verb. If the homograph is followed by an impersonal indirect object, then the homograph is being used as a verb. If the homograph is followed by a definite or indefinite article, then the homograph is being used as a verb. If the homograph is followed by a possessive pronoun, then the homograph is being used as a verb. If the homograph is preceded by the word &#34;who&#34; or &#34;lets&#34;, then the homograph is being used as a verb. Finally, if the homograph is preceded by a version of the verb &#34;to do&#34;, then the homograph is being used as a verb. 
     ApplyProbAdjN() is called to determine whether the homograph is probably being used in its adjective or noun form in accordance with probable cases coded into the function and application of the general rules. For example, if the homograph is followed by a word which is not an adverb or a personal pronoun and that word is followed by some form of the verb &#34;to be&#34; or &#34;to have&#34; or &#34;to do&#34; or a form an auxiliary word, then the homograph is probably being used as an adjective. If the homograph is preceded by the word &#34;very&#34; and &#34;very&#34; is preceded by either a definite article or demonstrative, then the homograph is probably being used as an adjective. 
     ApplyProbAdjV() is called to determine whether the homograph is probably being used in its adjective or verb form in accordance with probable cases coded into the function and application of the general rules. For example, if the homograph is followed by a word which is not an adverb and that word is followed by a verb, then the homograph is probably being used as an adjective. ApplyProbNounVO is called to determine whether the homograph is probably being used in its noun or verb form in accordance with probable cases coded into the function and application of the general rules. For example, if the homograph is preceded by a demonstrative or an indefinite pronoun from Group 1 or Group 2 then the homograph is probably being used as a noun. 
     ApplyProbVerbA() is called to determine whether the homograph is probably being used in its adjective or noun form in accordance with probable cases coded into the function and application of the general rules. This function passes a series of parameters to the ApplyProbVerbN() function to aid in determining whether the homograph is probably being used as a verb or an adjective. 
     ApplyProbVerbN() is called to determine whether the homograph is probably being used in its verb or noun form in accordance with probable cases coded into the function and application of the general rules. For example, if the homograph is preceded by the word &#34;to&#34;, then the homograph is probably being used as a verb. If the homograph is followed the word &#34;this&#34; or &#34;that&#34; then the homograph is probably being used as a verb. If the homograph is at the start of a sentence or followed by a carriage return or followed by a new line and is not followed by punctuation and does not end in &#34;s&#34;, then the homograph is probably being used as a verb. If the homograph is preceded by the word &#34;which&#34;, where &#34;which&#34; is the first preceding word or second preceding word, then the homograph is probably being used as a verb. 
     A software implementation of the above described embodiments may comprise a series of computer instructions either fixed on a tangible medium, such as a computer readable media, e.g. diskette 142, CD-ROM 147, ROM 115, or fixed disk 152 of FIG. 1, or transmittable to a computer system, via a modem or other interface device, such as communications adapter 190 connected to the network 195 over a medium 191. Medium 191 can be either a tangible medium, including but not limited to optical or analog communications lines, or may be implemented with wireless techniques, including but not limited to microwave, infrared or other transmission techniques. The series of computer instructions embodies all or part of the functionality previously described herein with respect to the invention. Those skilled in the art will appreciate that such computer instructions can be written in any of a number of programming languages for use with many computer architectures or operating systems. Further, such instructions may be stored using any memory technology, present or future, including, but not limited to, semiconductor, magnetic, optical or other memory devices, or transmitted using any communications technology, present or future, including but not limited to optical, infrared, microwave, or other transmission technologies. It is contemplated that such a computer program product may be distributed as a removable media with accompanying printed or electronic documentation, e.g., shrink wrapped software, preloaded with a computer system, e.g., on system ROM or fixed disk, or distributed from a server or electronic bulletin board over a network, e.g., the Internet or World Wide Web. 
     Although various exemplary embodiments of the invention have been disclosed, it will be apparent to those skilled in the art that various changes and modifications can be made which will achieve some of the advantages of the invention without departing from the spirit and scope of the invention. It will be obvious to those reasonably skilled in the art that other components performing the same functions may be suitably substituted. Further, the methods of the invention may be achieved by using other software implementations, using the appropriate processor instructions, or in hybrid implementations which utilize a combination of hardware logic and software logic to achieve the same results. Such modifications to the inventive concept are intended to be covered by the appended claims.