Patent Publication Number: US-5842202-A

Title: Systems and methods for data quality management

Description:
STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH 
     This invention was made with government support under contract Number F30602-93-C-0160 awarded by the Air Force. The government has certain rights in the invention. 
    
    
     FIELD OF THE INVENTION 
     The invention relates to systems and methods for processing structured data sets, and more particularly, to systems and methods that determine a measure of the error that exists within the results that are returned by operations on structured data sets. 
     BACKGROUND OF THE INVENTION 
     Today, database systems take data and information and organize the data and information into logical groups and categories that present the data as a logically structured table of information. Query mechanisms allow a user to examine and analyze these tables and to extract information both implicitly and explicitly stored therein. One common example of a query mechanism is a search engine that employs the structured query language that allows a database user to develop complex logical processing operations that sort through and process the data within the structured data set and provide a search result that extracts information explicitly and implicitly held within the structured data set. 
     Although these query systems work well to manipulate logically the structured data set and thereby produce search results, the accuracy of these search results is often questionable. Inaccuracies in search results arise from data errors existing within the structured data sets. These errors come from a multitude of sources including aging of the database, transcription errors, as well as from inaccurate data values being collected as valid input to the structured data set. All these errors within the structured data set result in an unknown source of error that undermines the integrity of any query result generated from that structured data set. 
     Accordingly, it is an object of the invention to provide systems and methods for providing a measure of the error within query results generated from the processing of a structured data set. 
     It is a further object of the invention to provide systems and methods for testing the integrity of a structured data set and for enumerating how input errors affect output errors. 
     It is still a further object of the invention to provide database administrators with systems that allow for measuring the utility of a database of information and for performing sensitivity analysis to relate input errors to output errors when no measure of input error is available. 
     Other objects of the invention will, in part, be obvious, and, in part, be disclosed within the following description of the invention. 
     SUMMARY OF THE INVENTION 
     The invention provides systems and methods that model and measure the propagation of error in information systems. The system provides a means to measure the error in a database, and to model the propagation of that error through queries applied to that database. In particular, the invention provides data management systems that provide an error measure that represents the accuracy, or inaccuracy, of a query result achieved from processing a structured data set. 
     In one embodiment, the invention provides systems that have a model of the error which exists within a structured data set. The structured data set may be encoded as database tables, with the error model also encoded as a database table wherein each entry of the error model corresponds to respective entries within the structured data set. The error model can include three separate tables. A first table describes each inaccurate or missing attribute value within the structured data set. A second table describes incompleteness in the class represented by the structured data set, and a third table identifies each member of the structured data set that is misclassified within that structured data set. These three tables provide an integrated class level and attribute level model of the error that exists within each table of the structured data set. 
     The system includes an interface that couples to a query mechanism employed for processing the structured data set. The system monitors the query instructions being employed to process the structured data set. As each logical operation of the query instruction can cause a portion of the errors within the structured data set to propagate through to the query result, the interface includes a processor that generates for the logical operations of the query instructions, a second set of logical operations which process the error model and the structured data set to determine how errors within the structured data set will propagate through to the output of the database query. Thus the error measure on the query input is transformed to an error measure on the query output. Those errors which propagate through will be processed by the invention to create an error measure that is representative of the error in the query results. The terms error model and error measure will be used interchangeably. 
     More particularly, in one aspect the invention can be understood as a system for performing data processing on the structured data set, which includes a query mechanism for providing logical instructions for selectively processing the structured data set to generate a query result signal, a memory device that has storage for error model data which is representative of error that exists within the structured data set as query input, and a propagation monitor that detects and models the propagation of the error from the structured data set as query input into the query result signal and further for generating in response thereto an error measure signal which is representative of error in query result signal. 
     The propagation monitor can, in one embodiment, include a query interface that couples to the query mechanism for monitoring the logical instructions, and can further include a memory interface that couples to the memory device for accessing the error model data. In this embodiment the propagation monitor processes the input error model data as a function of the query instruction signals in order to generate the query result error measure signal. In one particular embodiment, the system includes an instruction parser which is responsive to the instruction signals for generating a set of query instructions for processing the error model data and the structured data set to generate the error measure signal. 
     The systems of the invention can include table generators that provide the error measure signal in a table format having storage for error tuples wherein each error tuple is representative of an error in an associated tuple or table of the query result. Commonly, structured data sets are organized with a classification and attribute level structure. Systems according to the invention for operating on structured data sets that include classification and attribute organization can further include a processor for generating the error measure as a set of tables that store classification level errors and attribute level errors of the query result signal. In these systems, the query mechanism is operating on a structured data set which allows organization into classes and attributes. Accordingly, the query results which are generated from processing such a structured set of data are typically also organized as a structured data set that includes class and attribute level organization. In one embodiment of the invention, the systems include an element for generating the error measure as a set of tables which have entries which correspond to the tables which form the query result signal, or which form a portion of the query result signals. In this way the errors information is also organized according to class and attribute level errors. 
     In one embodiment, the system can also include a component for modifying portions of the error data as a function of an interpretation map. 
     Systems according to the invention identify or employ a set of error states that define the universe of errors and error combinations which can occur within a structured data set. In one embodiment, systems according to the invention measure three error types to define the error that exists within a structured data set. The system employs this set of error types to define the error within the structured data set that is being processed, and within the structured data set that is generated as the query results. Systems according to the invention monitor the propagation of each of these errors. Accordingly, the systems can include an attribute monitor for detecting the propagation of an attribute inaccuracy, or propagation of a missing attribute, from the input dataset to the query result signal. Similarly, systems according to the invention can include a class mismember monitor for monitoring the propagation of a class mismember error from the input data set to the query result signal. Similarly, a system according to the invention can include a class incompleteness monitor that monitors the propagation of a class incompleteness error from the input data set to the query result signal. 
     In one embodiment, the invention includes a memory device that stores error model data representative of a probability distribution of error within the structured data set. Alternatively, or in combination therewith, the memory device can store error model data that is representative of possibility or interval data, in that it provides for the representation of a non-zero probability of error within the structured data set. 
     In these embodiments, the systems can include an iteration processor for iteratively processing the logical error model data as a function of the probability data to generate a plurality of error measure signals representative of a probability distribution of error within the query result signal. 
     In alternative embodiments, systems according to the invention can include functional processors for selecting, in response to the probability data, a closed form statistical function for processing the probability data. 
     Systems of the invention can further include a data characteristic processor for generating portions of the probability data as a function of a predetermined characteristic of an element of the structured data set. 
     In another aspect, the invention can be understood as methods for measuring error in a query result generated from a structured data set. These methods comprise the steps of providing an error model which is representative of error within the structured data set, identifying an instruction signal representative of an operation for processing the structured data set to generate the query result signal, and processing the structured data set and the error model as a function of the instruction signal to generate an error measure representative of error within the query result. 
     In this aspect, the step of providing an error model can include the steps of providing a reference data set, and comparing the reference data set with the structured data set to determine differences therebetween. The methods can also include the step of organizing the error model as a data table having class level and attribute level characteristics and having a plurality of error tuples each corresponding to a tuple or table within the structured data set or within the query result dataset. Accordingly, the invention can provide an error model that provides tuple level error measures, as well as column level, row level, and class level error measures. The data within the error model can be provided as deterministic, i.e. numerical error data, as well as probabilistic or possibilistic data. 
     In further embodiments, processes according to the invention can include the steps of identifying a portion of the data table as corresponding to a selected characteristic, e.g., those portions of the data that are associated with female alumni. In this embodiment, the system can provide conditional probability data for this identified portion, wherein certain probability data is known to be different for certain portions of the input data. 
     The invention will now be described with reference to certain illustrated embodiments, which are provided to illustrate and describe the invention set forth herein, and which are not to be understood as limiting the invention to the depicted embodiments. 
    
    
     BRIEF DESCRIPTION OF THE ILLUSTRATED EMBODIMENTS 
     FIG. 1 illustrates one embodiment of a system according to the invention for providing a measure of error within the result of a data set query; 
     FIG. 2 illustrates one structured data set for processing by the system depicted in FIG. 1; 
     FIG. 3 illustrates a description of errors within the structured data set depicted in FIG. 2; 
     FIG. 4 illustrates the error conceptualization leading to the formulation depicted in FIG. 3; 
     FIG. 5 illustrates in functional block diagram form an embodiment of the invention for processing probabilistic error models; 
     FIG. 6 illustrates a further alternative embodiment of the invention; and 
     FIG. 7 is a diagrammatic view of the relationship between data, true value for data, and error. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     FIG. 1 illustrates one embodiment of a system according to the invention for providing a deterministic measure of error within the query results generated by processing of a structured data set. FIG. 1 illustrates a system 10 that includes a data processor 12, a query mechanism 14, a query result table 16, a database memory device 18, and an error measurement system 20 that includes an error propagation monitor 22, a memory device 24 for storing error model data, and a set of error measure tables 28a-28c. 
     The illustrated embodiment of FIG. 1 is a database system that employs a query mechanism 14, such as the software query language mechanism (SQL), to perform logical operations on the structured data set stored within the database memory device 18. This example of employing the error measurement system 20 according to the invention for measuring the error that can occur within query results generated by processing a database 18 is provided for illustrative purposes, and the invention itself is not to be limited to such database systems, but for employment as an error measurement system for any system suitable for processing a structured data set. 
     As figuratively illustrated in FIG. 1, the depicted error measurement system 20 is a device that sits on top of and is separate from the database system that is providing the query results. To this end, the error measurement system 20 interfaces at two points with the database system, at a first point to interface to the query mechanism, and at a second point to interface with the database memory device 18 that stores the structured data set. Accordingly, the error measurement system 20 depicted in FIG. 1 has the advantage of being employable with a conventional database query system and avoids modifications to the database or the data in database memory device 18. 
     In FIG. 1, the database query system to which the error measurement system 20 interfaces is depicted by the elements 12, 14, 16, and 18. To that end, the data processor 12 depicted in FIG. 1 can be a conventional data processing system suitable for operating a query mechanism, such as the query mechanism 14. The query mechanism 14 can be any query mechanism suitable for performing logical operations on the structured data set stored in the memory device 18. 
     For example, the query mechanism 14 can be a software database query mechanism, such as an SQL compliant database processor and search engine, such as the Oracle SQL query system. The query mechanism generates, typically in response to user inputs, a set of logical operations that process the structured dataset. The logical operations can be sorting operations, counting, joining or any other such operation. The output of the processing operation is the query result. Typically, it is this query result that the database user takes as the answer to the query entered into the system and employed by the query mechanism 14 to generate the set of logical operations. The illustrated database memory 18 that stores the database information as a structured data set can be any memory device including a hard-disk, tapedrive, or remote database, suitable for storing computer readable information in a format that facilitates processing by the query mechanism 14. The query result and its appended error measure can serve again as input to the database query mechanism and the error propagation monitor. 
     FIG. 2 illustrates an example of a structured data set that can be stored within the memory device 18 for processing by the query mechanism 14. This example refers to the hypothetical alumni(ae) or a university. The structured data set 30 illustrated in FIG. 2 is comprised of six separate records, each being one tuple of the structured data set 30. The structured data set 30 depicted in FIG. 2 is an organized aggregation of different data types, including text and numerical data. The text and numerical data is organized into the six records depicted. Each tuple of the depicted structured data set 30 has seven fields, including a record number field, an alumni name field, a home state field, a degree field, a major field, a year of graduation field, and a five-year donation field. The structured data set 30, and the data and logical organization of that table, represent the total information known to a database administrator or database user, regarding the actual real-world state of the alumni objects. Accordingly, any error in this world representation can affect the accuracy of query results generated from processing the structured data set 30. 
     Data error is defined relative to the true state of the world. A logical error measure is defined on a structured data set as a difference between the true data and the structured data, as depicted in FIG. 7, where the World (W) denotes data that correctly represents the true world state. Data (D) is an approximation of that true world. Error (E) documents the difference or discrepancies between D and W. The difference operator Θ maps from &lt;D, W&gt; to E. The correction operator ⊕ maps from &lt;D, E&gt; to W. 
     To measure error within the structured data set 30, systems according to the invention define statements that recite the errors that can occur within the database data. For example, the system can organize error into three categories, that as a set are understood to provide a complete representation of error within a structured data set. One such error definition is depicted in FIG. 4. The depicted error definition integrates class and attribute statement level errors. This error definition provides a more precise, general, and quantitative formulation of error than frequently used error related terminology including accuracy, completeness, integrity, and consistency, which are often vague and poorly defined. 
     The integrated definition which includes class statement and attribute statement error measures allows error to apply differently to a data set than to a data value, and allows systems according to the invention to operationalize error differently to categorical and numerical data. As the term class is used herein, it will be understood to encompass a category in which a particular object either is or is not a member. An object is a thing or concept that may be denoted by an identifier, for example, a text string, or a number. An object can be either classified, e.g. wealthy, or big number, or can be assigned an attribute value such as a specific number, or text string. The same symbol may be an attribute in one table and an object in another, while referring to the same concept. Attribute and class concepts are convertible during query processing. 
     Accordingly, attribute level errors referred to as inaccuracies within the structured data set 30 can, as a result of the query operation, result in classification level errors within query results. Systems according to the invention track the propagation of error from the input table, structured data set 30, to the query results, even if a conversion of error type occurs within the error propagation path. 
     As further depicted in FIG. 4, attribute statement level errors are understood as inaccuracies within the recorded data wherein the attribute value is wrong relative to the denoted object, either because it is incorrect or missing. Class statement level errors include incompleteness errors and misclassification errors. An incompleteness error occurs when a member of a class which should properly be recorded within that class, fails to be accurately recorded as a member of the class. Misclassification occurs when a defined class incorrectly records an object as a member of that class, when the actual characteristics of the real-world object fail to qualify the object for membership in the defined class. 
     With reference again to FIG. 2, examples of errors within the structured data set 30 can be described. The table depicted in FIG. 2 lists active alumni of a college who have made large donations and live in the United States. FIG. 3 depicts the errors believed to exist in the table of FIG. 2. Firstly, record 2 contains an inaccurate attribute value. In particular, Lisa Jordan&#39;s donation amount is actually $400,000.00. Included in this category is the null attribute value (record numbers 1 and 3): these are values which exist but are unknown to the database. For example, the true value for Mae-Ray&#39;s year of graduation is 1991. The true value for Tom Jones&#39; major is CS. 
     Class incompleteness occurs within the structured data set 30 as exemplified by the tuple for the alumnus John Junto as incomplete, i.e. missing (perhaps the corrupt record number 6 was to correspond to the Junto data). He is an actual alumnus who satisfies the class definition, but is not listed. This is an error within the input structured data set. 
     Class mismembership is exemplified in record numbers 4 and 6. For example, John Wales is a mismember--he is no longer active. Record number 6 is a mismember, as it represents a spurious object--null or corrupt keys are modeled as mismembers. 
     In one embodiment, systems according to the invention can create the error model stored in memory device 24 by generating three tables, that describe the errors of the structured data set 30 depicted in FIG. 2. These tables are depicted in FIG. 3 as tables 32, 34, and 36. Table 32 denoted r em  models the alumni mismembers errors that occur within the structured data set 30. Table 34 denoted r ea  models the alumni inaccuracies that occur within the structured data set 30. Table 36 denotes r ei  models the alumni incompletion errors within the structured data set 30. These three tables together, termed an error triple, can be understood to provide a complete representation of the errors within one table of the structured data set 30, wherein this error triple is understood to define the structured data set 30&#39;s failure to record the accurate state of the major U.S. active alumni. Accordingly, the error triple is data that models the differences in the data recorded within the structured data set 30 and the actual data which represents the real-world state of major U.S. active alumni. 
     The above description illustrates one system according to the invention for providing an error measure on the input data on which a query will operate. Systems according to the invention include an error propagation processor that employ this error measure on the input data, data set 30, to determine an error measure 28 for a query result 16, wherein the errors in the query result 16 arise from the propagation of the input errors from the input data 30 to the query result 16. 
     To that end, as depicted in FIG. 1, systems according to the invention include an error propagation monitor 22. The error propagation monitor can be a software module that has an interface to the query mechanism 14 to monitor the query instructions entered by a database user for processing the structured data set stored within the database memory 14 or on a remote server. 
     The interface can be a software interface that acts as a background process running on the data processing system that supports the query mechanism 14 or on a remote server. The software interface can generate a file of the instructions and pass the file to the error propagation processor 22. Alternatively, the interface can be a hardware interface, such as a data cable, that directs queries to both the database memory 18 and the error propagation processor 22. It will be apparent that any interface suitable for monitoring the instructions can be practiced with the invention. The instructions can be a set of logical operands, such as AND, OR, NOT EQUALS, GREATER THAN, LESS THAN, or other such logical operations, or additionally, a set of more abstract instructions, such as SELECT, JOIN, OR PROJECT which incorporate within this more abstract instruction a set of primitive logical operations such as those enumerated above. The instructions can also include operations such as COUNT and SUM, that direct the query mechanism 14 to aggregate data, either to provide the aggregated data as output to the user, or to create new intermediate data for further processing by the instruction signals. 
     In one embodiment, the error propagation processor includes a parser and a compiler that parses out the instruction signals generated by the query mechanism 14 to generate a set of error propagation instructions that can process the structured data sets of the error model 24 and the data set stored in database memory 18. The error propagation instructions query these structured data sets to analyze the propagation of error from the input data to the output data and to generate an error measure representative of error within the query results provided by query mechanism 14. Accordingly, the parser can generate from the query operations a set of error propagation operations that process the error model 24 and the structured data set of database memory 18 to develop an error measure 28a, 28b, 28c that again can be represented as an error triple that identifies error in the query result as three tables that measure inaccuracy, class incompleteness and class mismembership within the query results. 
     The following example describes a system for processing a database using an SQL compliant query mechanism. The parser/compiler of the error propagation processor can be written in LEX/YACC, and operates as a software module running on a conventional data processor, such as the data processor 12 depicted in FIG. 1. The error propagation processor can be a layer of software that sits above the query mechanism 14 to monitor the query mechanism and to generate a set of error propagation query instructions. In one embodiment of the invention, the query mechanism 14 and the error propagation processor 22 operate in parallel, with the query mechanism 14 operating on the database 18 in one step to determine the query results, and with the error propagation processor 22 operating in a second independent step to determine an error measure for that query result. This allows the system 20 to employ the architecture of the query system, including the interface with memory 18 and the data processor 12. 
     The error propagation processor 22 depicted in FIG. 1 determines the form and parameters of the query generated by query mechanism 14 and compiles the appropriate error propagation calculus sub-expressions as a set of SQL expressions that can query the error model data in memory 24 and the structured data sets stored in memory device 18. After submitting this SQL query against the error model data 24 and the structured data set stored in memory device 18, an output error triple, such as that shown in FIG.3 is produced. These can represent the computed corrections to the query result tables 16 generated by query mechanism 14 that will correct the errors in query result table 16. 
     In one practice, a database user operates the data processor 12 by manipulating an interface that is written in HTML/PERL using a CGI script. The database user types a valid SQL query into the text area on a web browser screen. Hitting a send button on that screen invokes the error propagation processor 22 which operates separate from, and induced by, the query mechanism processing 14 to provide a nonintrusive system for measuring error. Accordingly, the underlying database system does not have to change to accommodate the system 20 depicted in FIG. 1. 
     In this example, a database of structured commercial financial data shown in Table 1, was intentionally corrupted with known errors to facilitate the provision of an error model 24 and a database of flawed information. The errors introduced into the financial database are illustrated in Tables 2, 3, and 4. Table 2 shows a table of inaccuracies within that input database, Table 3 shows the table of incomplete classes and Table 4 shows the mismembers existing within the input database. 
     This provides actual error data, in that the errors are known and the error corrections necessary can be stated deterministically. Accordingly, the logical error model can be built as an error triple that definitely states the error within a table of the structured data set. In practice such as an error model can be created by comparing data in one database against a reference database of the same information. The reference database can be a more expensive database or a collection of data that has been more carefully gathered and updated. 
     
                                           TABLE 1                                 
__________________________________________________________________________
Sample data from the California Data Co. table                            
Connected to:                                                             
ORACLE7 Server Release 7.0.15.4.0-Production                              
With the procedural and distributed options                               
PL/SQL Release 2.0.17.1.0-Production                                      
SQL&gt; select * from disc where comp.sub.-- name like `A%`;                 
COMP.sub.-- NAME NUM.sub.-- EMPLOYEES                                     
                           TOTAL.sub.-- ASSETS                            
                                    NET.sub.-- SALES                      
__________________________________________________________________________
A O SMITH CORP   10800      823099  1193870                               
A SCHULMAN INC   1582       407865   685112                               
ABBOTT LABORATORIES                                                       
                 49659     7688569  8407843                               
ACX TECHNOLOGIES INC                                                      
                 4200       653999   641852                               
ADOLPH COORS CO  6200      1350944  1946592                               
ADVANCED MICRO DEVICES INC                                                
                 12060     1929231  1648280                               
AG PROCESSING INC                                                         
                 2128       465796  1218614                               
AGWAY INC        7900      1204764  1710577                               
AIR PRODUCTS &amp; CHEMICALS INC                                              
                 14075     4761500  3327700                               
ALBERTO CULVER CO.                                                        
                 8600       593046  1147990                               
. . .                                                                     
__________________________________________________________________________
 
    
     
                                           TABLE 2                                 
__________________________________________________________________________
Inaccuracies in input relation                                            
SQL&gt; select * from disc.sub.-- ea;                                        
COMP.sub.-- NAME       NUM.sub.-- EMPLOYEES                               
                                 TOTAL.sub.-- ASSETS                      
                                          NET.sub.-- SALES                
__________________________________________________________________________
INTERNATIONAL BUSINESS MACHINES CORP                                      
                       302196     81113000                                
                                          62716000                        
                                 101000000                                
FORD MOTOR CO          322213    198938000                                
                                          108521000                       
                                  98938000                                
GENERAL ELECTRIC CO    222000    251506000                                
                                           59827000                       
                                 251506731                                
GENERAL MOTORS CORP    710800    188200900                                
                                          133621900                       
                        71100                                             
__________________________________________________________________________
 
    
     
                                           TABLE 3                                 
__________________________________________________________________________
Incompletes from input relation                                           
SQL&gt; select * from disc.sub.-- ei;                                        
COMP.sub.-- NAME                                                          
              NUM.sub.-- EMPLOYEES                                        
                        TOTAL.sub.-- ASSETS                               
                                 NET.sub.-- SALES                         
__________________________________________________________________________
NORTHERN TELECOM LTD                                                      
              60293      9485000  8148000                                 
AMERICAN EXPRESS CO                                                       
              64493     101132000                                         
                                 14173000                                 
__________________________________________________________________________
 
    
     
                                           TABLE 4                                 
__________________________________________________________________________
Mismembers in input relation                                              
SQL&gt; select * from disc.sub.-- em;                                        
COMP.sub.-- NAME                                                          
             NUM.sub.-- EMPLOYEES                                         
                       TOTAL.sub.-- ASSETS                                
                                NET.sub.-- SALES                          
__________________________________________________________________________
DAIMLER BENZ CORP      9.0926E + 10                                       
                                9.7737E + 10                              
SEARS ROEBUCK and CO                                                      
             359000     90807800                                          
                                50837500                                  
CITICORP      81500    216574000                                          
                                32196000                                  
__________________________________________________________________________
 
    
     Table 5 shows the output from an SQL Plus program (of the type sold by the Oracle Company, Redwood Shores, Calif.) as it operates on the financial database. The parser compiler of the error propagation processor 22 creates an associated script resulting in an SQL Plus script, whose execution is shown as the SQL Plus program of Table 5. 
     
                       TABLE 5                                                     
______________________________________                                    
Sample of SQL compiler execution-the logical calculus implementation      
1.   Connected to:                                                        
2.   ORACLE7 Server Release 7.0.15.4.0-Production                         
3.   SQL&gt;&gt;                                                                
4.   SQL&gt; EPC-processing standard select-from-where query:                
5.   SQL&gt;&gt;                                                                
6.   SQL&gt; dropping 3 output error tables: inacc, incompl, mismem . . .    
7.   Table dropped.                                                       
8.   Table dropped.                                                       
9.   Table dropped.                                                       
10.  SQL&gt; The user query was:                                             
11.  select  total.sub.-- assets, comp.sub.-- name from disc where        
     total.sub.-- assets &gt; 100,000,000;                                   
12.  SQL&gt; table =  disc!                                                  
13.  SQL&gt; key.sub.-- attr =  comp.sub.-- name!                            
14.  SQL&gt; attr.sub.-- list =  total.sub.-- assets, comp.sub.-- name!      
15.  SQL&gt; where.sub.-- clause =   total.sub.-- assets &gt; `100000000`!      
16.  SQL&gt; INACCURACY                                                      
17.  SQL&gt; compiling inaccuracy EPC.                                       
18.  SQL&gt; result:                                                         
19.  SQL&gt;&gt; CREATE table error.sub.-- table.sub.-- inacc as                
20.  SQL&gt;&gt; SELECT total.sub.-- assets, comp.sub.-- name                   
21.  SQL&gt;&gt; FROM disc.sub.-- ea                                            
22.  SQL&gt;&gt; WHERE                                                          
23.  SQL&gt;&gt; (total.sub.-- assets &gt; `100000000`)                            
24.  SQL&gt;&gt; AND                                                            
25.  SQL&gt;&gt; (comp.sub.-- name IN                                           
26.  SQL&gt;&gt; ( SELECT comp.sub.-- name                                      
27.  SQL&gt;&gt; FROM disc                                                      
28.  SQL&gt;&gt; WHERE ( total.sub.-- assets &gt; `100000000`)                     
29.  SQL&gt;&gt;  )                                                             
30.  SQL&gt;&gt; )                                                              
31.  SQL&gt;&gt; AND                                                            
32.  SQL&gt;&gt; (total.sub.-- assets, comp.sub.-- name) NOT IN                 
33.  SQL&gt;&gt; ( SELECT total.sub.-- assets, comp.sub.-- name                 
34.  SQL&gt;&gt; FROM disc)                                                     
35.  SQL&gt;&gt;                                                                
36.  SQL&gt;&gt; executing EPC to compute output inaccuracy                     
37.  Table created.                                                       
38.  SQL&gt; INCOMPLETENESS                                                  
39.  SQL&gt; compiling incompleteness EPC                                    
40.  SQL&gt; result:                                                         
41.  SQL&gt;&gt; CREATE table error.sub.-- table.sub.-- incomp as               
42.  SQL&gt;&gt; SELECT total.sub.-- assets comp.sub.-- name                    
43.  SQL&gt;&gt; FROM disc.sub.-- ei                                            
44.  SQL&gt;&gt; WHERE ( total.sub.-- assets &gt;`100000000&#34; )                     
45.  SQL&gt;&gt; UNION                                                          
46.  SQL&gt;&gt; SELECT total.sub.-- assets, comp.sub.-- name                   
47.  SQL&gt;&gt; FROM disc.sub.-- ea                                            
48.  SQL&gt;&gt; WHERE                                                          
49.  SQL&gt;&gt; ( total.sub.-- assets &gt; `100000000` )                          
50.  SQL&gt;&gt; AND                                                            
51.  SQL&gt;&gt; comp.sub.-- name NOT IN                                        
52.  SQL&gt;&gt; (SELECT comp.sub.-- name                                       
53.  SQL&gt;&gt; FROM disc                                                      
54.  SQL&gt;&gt; WHERE ( total.sub.-- assets &gt;`100000000` )                     
55.  SQL&gt;&gt; )                                                              
56.  SQL&gt;&gt;                                                                
57.  SQL&gt; executing EPC to compute output incompleteness                  
58.  Table created.                                                       
59.  SQL&gt; MISMEMBERSHIP                                                   
60.  SQL&gt; compiling mismembership EPC                                     
61.  SQL&gt; result:                                                         
62.  SQL&gt;&gt; CREATE table error.sub.-- table.sub.-- mismem as               
63.  SQL&gt;&gt; SELECT total.sub.-- assets, comp.sub.-- name                   
64.  SQL&gt;&gt; FROM disc.sub.-- em                                            
65.  SQL&gt;&gt; WHERE ( total.sub.-- assets &gt; `100000000&#34; )                    
66.  SQL&gt;&gt; UNION                                                          
67.  SQL&gt;&gt; SELECT total.sub.-- assets comp.sub.-- name                    
68.  SQL&gt;&gt; FROM disc                                                      
69.  SQL&gt;&gt; WHERE                                                          
70.  SQL&gt;&gt; ( total.sub.-- assets &gt; `100000000` )                          
71.  SQL&gt;&gt; AND                                                            
72.  SQL&gt;&gt; comp.sub.-- name IN                                            
73.  SQL&gt;&gt; (SELECT comp.sub.-- name                                       
74.  SQL&gt;&gt; FROM disc.sub.-- ea                                            
75.  SQL&gt;&gt; WHERENOT ( total.sub.-- assets &gt; `100000000` )                 
76.  SQL&gt;&gt; )                                                              
77.  SQL&gt;&gt;                                                                
78.  SQL&gt; END OF EPC OUTPUT                                               
79.  SQL&gt; executing EPC to compute output mismembers                      
80.  Table created.                                                       
______________________________________                                    
 
    
     In this example, the user query is: 
     select total --  assets comp --  name, from disc where total --  assets&gt;&#34;100000000&#34;. 
     By this query, the database user wishes to see which companies have greater than one hundred billion dollars and what is their asset amount. The listing of Table 5 shows the output of the script as executed in the SQL Plus environment. The user query is shown on line 11. The LEX and YACC parse and transform input queries into error propagation expressions in lines 16, 38, and 58 of the listing of Table 5 respectively. The compiler generates a separate SQL expression set for inaccuracy, incompleteness, and mismembership errors. 
     Lines 19-35 provide an example of the error propagation instructions generated by the error propagation processor 22. The parser generates from the SQL command select, a subset of instructions that identifies the set of tuples that are inaccurate within the query results generated by the query mechanism 14. The selection operation is a logical formula on the data of database memory 18 that will select from that data a subset of the data which meets the criterion of the selection operation. Inaccuracies result in the selection operation due to the existence of an inaccurate tuple in the input data structure that will be selected during the SQL selection operation entered by the user. This relationship can be represented by the following formula: 
     
         S.sub.ea ={r.sub.2 |∃r.sub.1 εr, ∃r.sub.2 εr.sub.ea, r.sub.1.R.sub.k =r.sub.2.R.sub.k, f(r.sub.1)f(⊕r.sub.1)} 
    
     Wherein the expression ∃r 1  εr means there exists a tuple in r 1  in R. &#34;r 1 .R k  =r 2 .R k  &#34; matches r 1  in R with a tuple r 2  in R ea  on the key columns R k . So, r 1  is inaccurate and r 2  contains attribute value corrections to r 1 . &#34;f(r 1 )&#34; indicates that r 1  was selected by f. &#34;f(r 1 )&#34;indicates that r 1  should have been selected, i.e. if the attribute values in the input data r 1  had been corrected before applying f, the tuple would still have been selected. This is understood to ensure that the inaccuracy in r 1  did not result in an S mismember due to false selection of r 1 . This formula is represented by the SQL query instructions set forth in lines 19-35 of Table 5. 
     Selection incompleteness errors arise from two conditions. An incomplete from the input data would have been selected had the tuple been present, and inaccuracy in the input data caused the select condition to fail where it would have succeeded otherwise. These criteria are set forth by the expressions 3a and 3b below. 
     Selection mismemberships in the query results can arise from two causes; a mismember of the input data is selected by a selection operation so that the mismember remains, and where an inaccurate tuple is selected by the selection operation only due to its inaccuracy and should not have been selected. This logical formula is set forth in expressions 2a and 2b. Other query operations are described besides SELECT in Appendix A attached hereto, and still others will be apparent to those of ordinary skill in the art. Accordingly, it will be understood the invention set forth herein which measures error propagation is not to be limited to any particular set of operations, nor to any particular set of error definitions. 
     The parser of the error propagation of monitor 22 generates, as set forth in lines 41 through 56, a set of query instructions for processing the error model 24 and the data sets stored in database memory 18 to generate an error measure of the incompleteness within the query results. Similarly, the parser at lines 62 through 78 of Table 5 generate a set of query instructions for determining mismemberships within the query results. These three derived SQL queries relate to the error propagation formalisms set forth in formulas 1 through 3. When executed against the error model 24 and the data in database 18, the error propagation processor 22 generates an error measure represented in FIG. 1 as three output tables 28a, 28b, and 28c. Each of these tables corresponds to one portion of an error triple, i.e. inaccuracy, mismembership, or incompleteness. The contents of these three tables are set forth in Table 6 below. A short review of Table 6 indicates that the error measurement system 20 according to the invention has identified those errors that exist within the query result 16 depicted in FIG. 1. The system is mathematically closed in that the output of one error propagation calculus expression can serve as input to another. 
     
                       TABLE 6                                                     
______________________________________                                    
Output error triple: &lt;output.sub.-- ea, output.sub.-- ei, output.sub.--   
em&gt;                                                                       
81. SQL&gt; ************** OUTPUT INACCURACIES ******                        
82. SQL&gt; select * from output.sub.-- ea;                                  
83. TOTAL.sub.-- ASSETS COMP.sub.-- NAME                                  
84. --                                                                    
85. 251506000 GENERAL ELECTRIC CO                                         
86. SQL&gt; ***************** OUTPUT INCOMPLETES ******                      
87. SQL&gt; select * from output.sub.-- ei;                                  
88. TOTAL.sub.-- ASSETS COMP.sub.-- NAME                                  
89. --                                                                    
90. 101132000 AMERICAN EXPRESS CO                                         
91. 198938000 FORD MOTOR CO                                               
92. SQL&gt; ************* OUTPUT MISMEMBERS ******                           
93. SQL&gt; select * from output.sub.-- em;                                  
94. TOTAL.sub.-- ASSETS COMP.sub.-- NAME                                  
95. --                                                                    
96. 101000000 INTERNATIONAL BUSINESS MACHINES CORP                        
97. 216574000 CITICORP                                                    
98. 9.0926E + 10 DAIMLER BENZ CORP                                        
99. SQL&gt; Disconnected from ORACLE7 Server Release 7.0.15.4.0-Production   
______________________________________                                    
 
    
     The above description describes a method for measuring error within query results and provides a deterministic evaluation of the error within those query results. To this end, the system depicted in FIG. 1 employs an error model 24 that contains, as described in the above example, values which indicate the actual errors existing in the input data stored in the database memory 18. Accordingly, this logical error model represents error as deterministic corrections to individual facts. Such a deterministic error model 24 allows a database administrator to document or verify the integrity and value of the structured data set stored within the database memory 18. For example, the database administrator can generate a deterministic error model 24 by selecting a portion of the data stored within the database memory 18 and manually researching the data therein to identify any inaccuracies, incompleteness, or mismemberships. 
     For example, a database administrator can be in charge of a database that stores records on 35,000 alumni. The database administrator can select a representative 500 records from that database. The database administrator can review and analyze these records to create an error model 24 that is representative of a portion of the data records stored in the database memory 18. The database administrator can then conduct query searches of those 500 records to get error measures that indicate the accuracy of the query result being generated from the database. The error measures generated by the error measurement system of the invention provides the database administrator with the integrity of the search results being produced on searches of the full database. If error measurements indicate that the search results are of little value, the database administrator can draw the inference that the database needs to be overhauled. 
     Alternatively, if the error measures indicated that query results being produced from the database 18 are generally accurate, the database administrator can choose to avoid the expensive process of updating the database. Similarly, a database administrator that is choosing between a number of available databases that contain similar information can select the highest quality database, perhaps the most expensive, and determine differences between that high quality database and other less expensive ones. These differences can be employed to generate a deterministic error model 24. If error measures produced upon processing less expensive databases indicates an acceptable level of error within the query results, then the database administrator can select to purchase the less expensive database. Alternatively, if the error measure results indicate that the less expensive database produces query results highly inaccurate and of little value, the database administrator can justify the expense of purchasing the more expensive database. 
     It is understood, that the system allows a database administrator to get a measure of how error in an input database propagates to query results. The propagation of error is not necessarily intuitive. Accordingly, an error model that indicates a high level of inaccuracy in a certain attribute may nonetheless fail to translate into any type of significant error for the queries generally performed by the database administrator. Consequently, the invention provides database administrators with systems and method for comparing, maintaining, and selecting databases. 
     In an alternative embodiment of the invention, the system employs an error model 24 that represents error within the structured data set by probabilistic data. In a probabilistic sense, knowing error fully implies having a probability distribution on the error sample space so that each error state can be individually quantified for likelihood. A probabilistic error representation consisting of expressions such as those described below in Table 7, can be one way of defining these probability distributions. FIG. 5 depicts one embodiment of the invention for use with probabilistic error models. This error and error propagation model define a simulation mechanism for iterating over the logical error states. 
     FIG. 5 depicts the induced probabilistic error measurement system 40 that includes a logical error propagation monitor 42, an induced probabilistic error model 44, a discrete logical error model memory 46, a discrete logical error measure memory 48 having storage for error measure triples 48a, 48b, and 48c, an aggregation controller 50, and an induced probabilistic output error measure memory 52. 
     In the system 40 depicted in FIG. 5, the probabilistic error data stored in the probabilistic error model 44 is employed to generate an error measure that defines error within query results as a probability distribution. In this embodiment, the system 40 generates probabilistic error measures by iteratively testing each possible error state of the database memory 18 to generate a plurality of error measures, each being representative of one possible output error state for the query results. Thus the system 40 can also be termed the induced probability error measurement and propagation system, as this model results from probabilistic iterations over the logical model. 
     As further depicted in FIG. 5, the system 40 includes an aggregation controller 50 that aggregates the probabilities of the individual logical output error measurements to generate an output error measure that represents the probability distribution of error within the query result separately for each type of error and for various subsets of the query result. To this end, the error propagation monitor 42 contains an iteration processor that employs the probabilistic data stored in the probabilistic error model 44 to generate randomly one discrete logical error measure which is stored in error model memory 46. This discrete logical error measure represents one possible logical error model for the data of database memory 18. The system 40 processes this single discrete logical error measure as described above with reference to the system 20 of FIG. 1, to generate an error measure representative of an output error that would occur for this one discrete logical error measure stored in error model memory 46. This output measure is then stored within the error measure memory 48. The iteration processor of error propagation monitor 42 then randomly generates, using the probability error model 44, another discrete logical error measure which can be stored in error model memory 46. Again, the error propagation monitor 42 generates an output error measure signal for this possible error measure and stores the output measure within the error measure memory 48. This iterative process continues until sufficient iterations have been performed to generate a sufficient number of logical output error measures to define the probability distribution of the error within the query result signal. 
     In particular, as further illustrated in FIG. 5, each iteration of the logical model produces an error triple that can be stored within the error measure memory 48. Each error measure stored within error measure memory 48 represents one point of the error space of the logical measure of error for the query results signal 16. In the depicted embodiment, the error measure memory 48 couples to the aggregation controller 50. The aggregation controller 50 can, optionally, sum together the multiple logical executions provided by the iterative processor of the propagation monitor 42. In particular, the aggregation controller generates an aggregate statistic over the multiple logical executions performed by the error propagation monitor 42. For example, the iterative processor can perform one hundred iterations of the simulation. Random logical error measures are generated according to probabilistic error statements such as those in Table 7 and in formulas 1, 2, and 3 below. The output of each iteration is a logical output error measure. This output error measure is a probability density function of its outputs over one hundred iterations and constitutes the induced model&#39;s output distribution for each of the error types. This output distribution can be graphically plotted to depict the probability distribution of the error within the query result signal 16. The probabilistic output error measure memory 52 can store the aggregated output error data for subsequentive use by the database administrator. 
     It will be apparent that other query operations and error propagation calculus expressions can be employed with the invention without departing from the scope thereof. 
     In a further alternative embodiment of the invention, the systems can employ error model data that is represented as probabilistic expressions. For example a statistical methodology can determine that an error term on income for Alumni is some (discretized) normal distribution (call it P (income-error)). These probabilistic error statements can be processed by statistical operations to directly determine the error probability distribution of the query result signal 16. Continuing with the example, if a selection predicate asks for the number of individuals with income greater than some amount, this input normal distribution of error become a distribution on inaccuracy, incompleteness, and mismembership by operation of a functional processor that employs a sum of binomial random variables to model the number of incompletes and mismembers in the output. Such a functional view of error representation and propagation directly determines the probabilistic output error without requiring the iterative processes previously described with reference to FIG. 5. The statistical processing operations employed by the functional processor for combining probability statements of error are well known in the art of probability and statistics. 
     One such system is the functional probabilistic error measurement system 60 depicted in FIG. 6. The depicted system 60 includes a functional error propagation monitor 62, a functional probabilistic error model memory 64 having probability data stored therein, a statistical function library 68, and functional probabilistic error measure memory devices 70a, 70b, and 70c. 
     Accordingly, in this embodiment, the error model data stored in memory device 64 can be stated as closed form statements of probability distributions. For example, an error statement that alumni under-report or over-report their income as a function of region (Europe, Texas, etc.) and employment category (CEO, manager, etc.), can take the form: 
     
         P(Income-error=x|Region=y Employment-category=z)  (Statement 1) 
    
     Further, mismembers may be represented as: (1) &#34;the probability that a randomly chosen tuple in the table is a mismember is 0.1&#34;, and (2) &#34;the distribution of values in a tuple given it is a mismember is P x  (x)&#34; where xεX is a tuple variable on the table&#39;s scheme. These can be stated in the form: P (mismember) and P(X=x|mismember). Other probabilistic statements of error will be apparent to those of ordinary skill in the art, and the use thereof does not depart from the scope of the invention. 
     Table 7 illustrates probability statements in an error model data set. In Table 7, t is a random tuple in a relation r, ⊕t is the correction to t necessary to correct any error therein, o is a random object in the world which is in fact in r&#39;s class, x and y are tuple variables on r&#39;s scheme. Then the following statements describe alternative ways of structuring knowledge about data error for each error type. Member (t) is the event that the tuple t is in fact a member of the table&#39;s class. Mismember (t) is the event that the tuple t is in fact not a member of the table&#39;s class. Incomplete (o) is the event that the object o is in fact a member of the table&#39;s class, but is not listed in the table. 
     
         ______________________________________                                    
error type                                                                
         item       functional representation expression                  
______________________________________                                    
inaccuracy                                                                
         1          P (⊕t = y | member(t)    t = x)          
          1&#39;        P (member(t)  t = x)                                  
         or                                                               
         2          P (t = y | member(t)  ⊕t = x)            
          2&#39;        P (member(t)   ⊕t = x)                            
incompleteness                                                            
         3          P (incomplete(o)|o = x)                      
          3&#39;        P (o = x)                                             
         or                                                               
         4          P (o = x | incomplete(o))                    
          4&#39;        P(incomplete(o))                                      
mismembership                                                             
         5          P (mismember(t) | t = x)                     
          5&#39;        P (t = x)                                             
         or                                                               
         6          P (t = x | mismember(t))                     
          6&#39;        P (mismember(t))                                      
______________________________________                                    
 
    
     For encoding knowledge about the error type inaccuracy, an error data model can structure the information based on either of the two expressions of item 1 and 1&#39; or on 2 and 2&#39; above as these are alternative statements. This can be similarly done for incompleteness and mismembership. Accordingly, memory 64 can store an error triple data model having three tables of errors each providing tuple level representation of error recited as statements of probability. This system 60 can also be termed the functional probabilistic error measurement and propagation system. This is because it operates directly on probability functions. 
     The functional probability representation can also provide error models that include conditional descriptions of error. To this end, the probability statement of error expressed for a tuple in the error model can provide a first statement of error probability that applies under a first condition, and a second statement of probability of error that applies under a second condition. For example, the probability statement of error for the accuracy of an address field in the input data set may be conditional upon the age of the associated alumni member, given that younger people have a tendency to move more frequently that older people. Accordingly, the parameters of a probability statement, e.g., the mean of a binomial distribution, may be different conditioned upon the age of the alumni. Error can may also be conditioned upon evidence of other error contained in the table. The evidence of error can be any information which leads to a belief that error may exist in a particular subset of the data which is different than the error that exists for the other portions of the data. One such form of evidence includes a recording of the processing history of data, including its source, age, and collection method. 
     As with the embodiments described above, the error propagation monitor 62 determines errors in the input data set that will propagate through to the query results 70 given the input errors and the operations employed in the query. 
     For example, mismembers can propagate for a select operation. For example, variable r represents a table that is input to a database query, and variable s represents a table that is output from that query. The scheme of both is R, with r e  and s e  are the respective error triples. s e  can be computed by the calculus. Let K.OR right.R be the key of R. As an example of the probabilistic events, let s 1  be a random tuple drawn from the output table s. Let s 1 .Kεs em .K be the event that s 1 .K is a mismember of s. Then P(s 1 .K.di-elect cons.s em .K) is the probability of this event. As discussed above, a conditional distribution such as P (s 1 .K εs em .K |s 1  =x) allows assignment of a higher likelihood or degree of error to some subsets of the data(world) than to others (where x is a tuple variable on R). 
     mismembership in the select result ##EQU1## Expressions 2a and 2b above state that two exclusive events among input tuples can result in an s mismember. 2a covers the event that s 1 .K was a mismember in r, in which case (by definition of a selection) it is also a mismember in s. 2b describes the other way a tuple may be a mismember in s--when an inaccuracy in r causes a tuple to be wrongly selected into s. 
     The probability of an output mismembership is a function of the probabilities of the these two types of input error events. The probability that a random output tuple s 1  εs is a mismember (given s 1  =x) is the probability that, for the tuple s 1  εr, and given ƒ(s 1 ), then what is the conditional probability--in r--that s 1  is either a mismember of r or s 1  is inaccurate resulting in false selection by ƒ. And, because of the conditionals, a probabilistic &#34;filtering&#34; of error occurs. The selectivity of ƒ over conditioning variables may lead to different proportions of tuples in each error category. 
     Inaccuracy error concerns an attribute value vis-a-vis an object. As in mismembership, a conditional interpretation of inaccuracy can be adopted. y below is another tuple variable on R. 
     inaccuracy in the select result ##EQU2## This equation describes the single event in the input event space that results in an inaccuracy in the output. This is the case where an inaccurate tuple s 1  of r satisfies ƒ, and the satisfaction is not spurious, i.e., it would have occurred even if the inaccuracy were corrected. 
     For incompleteness, let o be a random tuple missing from ⊕s where ⊕s represents the true output. Let t be the corresponding inaccurate tuple in r such that t.K=o.K. Two conditions can cause incompleteness: an incomplete from r would have been selected had the tuple been present and an inaccuracy in r causes the select condition to fail where it would have succeeded otherwise. P s  and P r  represent probabilities on s and r respectively. 
     incompleteness in the select result ##EQU3## 
     An error calculus can be provided to detect errors that arise from attribute level errors crossing over into class-level errors. For example, Major was an attribute column in context of Alumni, but will generate an object in the Major table due to a projection operation. A propagation calculus can account for such semantic transformations and convert across error measures from one interpretation of data to another. Let r and s be input and output respectively for a projection: s=Π s  (r). Probabilistic project propagation depends on the relationship between the projection list S and the key K of the input scheme R. If S includes the entire key of R, then the key of S and R are the same, and the incompleteness and mismembership of s and r are the same. If the key is removed, then a new key arises (as in Major above) and error is to be computed accordingly. 
     Another factor in the projection can be the relationship between S and the set of columns that are conditioning in the error representation. If conditioning columns are removed, then a new marginal distribution of error is to be computed for the remaining columns in order to maintain (the now reduced) error information. For example, the formula below describes the calculus for projection incompleteness when the conditioning columns are kept and the key is removed. 
     Let R k  be the key of R. Because S is disjoint from R k , there is a key change so that S k  =S. Define o as in 3a-c above. The functional processor can compute incompleteness as: ##EQU4## This error propagation calculus expression indicates that object o.S k  will be incomplete from s if either incompleteness or inaccuracy in r masked the fact that a member of r in fact had S value o.S k . 
     A probabilistic aggragation calculus can also be determined. A count operation reflects how many tuples are in a given table. In the above described error model, the true count can be derived random variable. Let x be the number of tuples actually present in a table. Let y be the number of incomplete objects, and let z be the number of mismember tuples. Then by simple observation the true count is equal to 
     
         x+y-z. 
    
     The data defines x. So as long as the probabilistic error term gives a distribution on the number of incompletes (y) and mismembers (z), then the true count is fully (i.e., probabilistically) defined. For example, if the alumni DBA states: 
     300 people are incorrectly listed as deceased 
     then the query select name from alumni where Deceased=`no` would result in a table of exactly 300 missing. The DBA might have stated instead: the likelihood of any individual reporting him or herself as dead is 1 in 1,000 Then, given 70,000 alive and 30,000 dead tuples, a simple binomial model of lying about death can determine the distribution of numbers of incompletes in the result. 
     A probabilistic calculus for a sum operation can also be determined. Let T be a table having a numeric attribute column a 1 , and having n tuples. Let the aggregation be over α 1 . Let 
     
         Σα.sub.1 
    
     
         i=1, . . . , n 
    
     be the sum over α 1 , counting blanks as zeros. First make adjustment to S.α 1  to address the incompletes. Let P y  (y) be the probability that the number of incomplete objects is y. Then, to adjust S.α 1  for incompleteness in T, the functional processor can add z, where z is the random sum of a random variable. The random sum is over the random number (|T ei  |) of incomplete objects. The random variable is the value t 1 . a 1  for a missing tuple t 1 . A similar operation corrects for mismembers, but the random sum of random variables is subtracted. Let m be that mismember adjustment, 
     Then the true sum random variable can be expressed as: 
     
         Σα.sub.1 +z-m. 
    
     Thus, the probability distribution for the statistic &#34;total-income of Boston area alumni&#34; can be computed, from which various derivative metrics can be computed, such as confidence intervals on this statistic. 
     The count and sum calculi described above for the functional processor, compute the same output distributions as the embodiment depicted in FIG. 5. The semantics are a clearer from this discussion, however, because they acknowledge the conditional structure of error and the formulation of error as random sums of random variables, allowing for (increasingly) closed-form solutions. Propagating such sums functionally (e.g., without the simulations of the induced model of FIG. 5) will depend on the particular underlying distributions involved. Accordingly, the functional model manipulates conditional probability distributions explicitly and leads, where possible, to increasingly closed form analytic formulas for probability distribution propagation. Many uncertainty models embody assumptions about the &#34;shape&#34; of uncertainty (e.g., uniformity, independence, and normality). These may or may not be valid in a given setting. The current model makes no assumptions about distributions, but specifies what probabilities are relevant. 
     It will be apparent that other aggregate query expressions, such as average, and union, can be employed with the invention without departing from the scope thereof. 
     In operation the propagation monitor 62 monitors the instructions generated by query mechanism 14 and parsers the queries, as described above, to generate a set of propagation queries to determine how errors from the probabilistic error model 64 propagate to the output error measure in memory device 70. As described above, the operations of the logical instructions for processing the database 18 determine how error propagates to the query results. For example, for a select operation, errors that exist within the structured data set generally, if selected, propagate right through to the output error measure stored in 70. However, when the query requests data to be aggregated, either for counting, summing, or averaging, the propagation monitor 62 determines the type of probability statement, e.g., normal distribution, associated with the appropriate attributes in the error model 64 and accesses the statistical function library 68 to select a statistical function, i.e. a binomial sum of normal random variables, for generating the probability statements to achieve the proper probability statement for the error measure. In this way, the propagation monitor 62 acts as a functional processor for directly determining probability statements of error within the error measure signal stored in the memory devices 70a, 70b, and 70c. 
     In the alternative embodiment depicted in FIG. 6, the error model can also store possibility data. Possibility data is understood to be probabilistic data which is less certain than probability data, in that it merely indicates that error can exist within the data measurement. However, possibility data typically provides no measure as to the likelihood of that error. However, in some embodiments, it is useful for database administrator to determine whether or not the possibility of error propagates through into his query results. 
     The above description illustrates the systems and methods according to the invention that are suitable for determining an error measure signal representative of the error that occurs within a query result generated from processing a structured data set. The error models shown herein can be provided to the systems of the invention or can be generated for use with such systems. As described above, the error models can be generated by comparing a reference data set to an existing data set to determine an error measure, which in one embodiment can be represented as the corrections which are necessary to make to the structured data set to bring the structured data set into correspondence with the reference data set. 
     Additionally, the error models can include probability data which can be gathered either through known statistical processes for measuring error within a set of data, or by less deterministic, and empirical methods, wherein a database administrator who has substantial knowledge of what the accuracy of data within the database is interviewed to determine rough estimates or subjective statement about error within the data. Other techniques, including database integrity constraints, can be employed by the invention for measuring the error within database and for generating the error models suitable for use with the invention described herein. 
     The systems and methods of the invention can be employed for determining or stimulating the integrity of an existing database as well as for allowing a database administrator to compare multiple databases for purposes of selecting between the multiple databases. Additionally, systems of the invention can be employed for determining measures of error produced by application of an interpretation map to the query results of a database system. In this application, an interpretation map can be applied to the query results provided by a database system for purposes of translating the query results received from a first context to a second context. For example, an interpretation map can be provided to translate query results achieved from processing a database having pre-tax financial information into query results represented in post-tax dollars. As the interpretation from pre-tax to post-tax dollars can be inexact, and create errors within the query results, systems of the invention can be employed for modeling the generated error and for determining the error that gets propagated through to the post-tax query results. Other applications that employ these systems and methods of the invention described herein will be apparent to those of ordinary skill in the art of database systems and statistical analyses. 
     It will thus be seen that the invention provides systems and methods for measuring error within a structured data set and for measuring and modeling the propagation of that error through the structured data set to a query result. ##SPC1##