Patent Publication Number: US-8112802-B2

Title: Verification of outsourced data streams

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention is directed to query verification of untrusted servers, and more specifically to a query verifier that uses a synopsis to verify query results. 
     2. Brief Discussion of Related Art 
     Due to the overwhelming flow of information in many data stream applications, data outsourcing is a natural and effective paradigm for individual businesses to address the issue of scale. In conventional data outsourcing models, the data owner outsources streaming data to one or more third-party servers, which answer queries posed by a potentially large number of clients on the data owner&#39;s behalf. Data outsourcing intrinsically raises issues of trust. Conventional approaches to query verification build upon cryptographic primitives, such as signatures and collision-resistant hash functions, which typically only work for certain types of queries, such as simple selection/aggregation queries. 
     Conventional industrial and academic Data Stream Management Systems (DSMS) have been developed in recent years. The need for such DSMSs is mainly driven by the continuous nature of the data being generated by a variety of real-world applications, such as telephony and networking. Providing fast and reliable querying services on the streaming data to clients is central to many businesses. However, due to the overwhelming data flow observed in most data streams, companies typically do not possess the necessary resources for deploying a DSMS. In these cases, outsourcing the data stream and the desired computations to a third-party server can be the only alternative. Outsourcing also solves the issue of scale. That is, as the number of clients increases, the number of mirroring servers employed by the data owner can be increased. In addition, this can often lead to faster query responses, since these servers can be closer to the clients than a single centralized server. However, because data outsourcing and remote computations raise issues of trust, outsourced query verification on data streams is a problem with important practical implications. 
     For example, a data owner with limited resources, such as memory and bandwidth, may outsource its data stream to one or more remote, untrusted servers that can be compromised, malicious, running faulty software, etc. A client registers a continuous query on the DSMS of the server and receives results upon request. Assuming that the server charges the data owner according to the computation resources consumed and the volume of traffic processed for answering the queries, the server then has an incentive to deceive the owner and the client for increased profit. Furthermore, the server might have a competing interest to provide fraudulent answers to a particular client. Hence, a passive malicious server could drop query results or provide random answers in order to reduce the computation resources required for answering queries, while a compromised or active malicious server might be willing to spend additional computational resources to provide fraudulent results (by altering, dropping, or introducing spurious answers). In other cases, incorrect answers might simply be a result of faulty software, or due to load shedding strategies, which are essential tools for dealing with bursty streaming data. 
     Ideally, the data owner and the client should be able to verify the integrity of the computation performed by the server using significantly fewer resources than having the query answered directly, i.e., where the data owner evaluates the query locally and then transmits the entire query result to the client. If a client wants to verify the query results with absolute confidence, the only solution is for the data owner to evaluate the query exactly and transmit the entire result to the client, which obviates the need of outsourcing. 
     Further, the client should have the capability to tolerate errors caused by load shedding algorithms or other non-malicious operations, while at the same time being able to identify mal-intended attacks which have a significant impact on the result. 
     SUMMARY OF THE INVENTION 
     Embodiments of the present invention are directed to a method, medium, a computing system for verifying a query result of an untrusted server. A data stream is outsourced to the untrusted server, which is configured to respond to a query with the query result. A verification synopsis is generated using at least a portion of the query result and a seed, which in some embodiments can uses at most 3 words of memory. The verification synopsis includes a polynomial, where coefficients of the polynomial are determined based on the seed. The verification synopsis and the seed are output to a client for verification of the query result. Verification of the query result can be performed in a single pass of the query result. A result synopsis can be computed using the query result and the result synopsis is compared with the verification synopsis to verify the query result. 
     In some embodiments, the seed can be required by the client to use the verification synopsis and can have a value that is undisclosed by the data owner until the seed is output to the client. An alarm can be raised when the verification synopsis and the query results do not match and/or the number of errors between the verification synopsis and the query results exceeds a threshold. In some embodiments, errors in the query result can be located and corrected using the verification synopsis and/or the number of errors in the query result can be estimated using the verification synopsis. 
     In some embodiments, a vector can be maintained corresponding to the query result and the verification synopsis can be computed using the vector when a request for verification is received. 
     In some embodiments, layers can be generated, where each layer includes buckets. One of the buckets can be represented by the verification synopsis and elements of the vector are assigned to one bucket per layer. 
     Other objects and features of the present invention will become apparent from the following detailed description considered in conjunction with the accompanying drawings. It is to be understood, however, that the drawings are designed as an illustration only and not as a definition of the limits of the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  shows an exemplary data outsourcing architecture  100 . 
         FIG. 2  is an exemplary illustration of a synopsis that includes layers and buckets. 
         FIG. 3  is an exemplary computing device for implementing embodiments of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     Exemplary embodiments of the present invention are illustrated using “GROUP BY, COUNT” and “GROUP BY, SUM” queries known to those skilled in the art, although it will be recognized that other queries can be used. In network monitoring applications, a computation of the total number of packets originated and destined to certain IP addresses is often desired. The “GROUP BY, COUNT” query is substantially equivalent to computing the frequencies (e.g., occurrences) of tuples in a stream. Most streaming algorithms deal with either the frequencies directly or their relatives, such as frequency moments, heavy hitters, quantiles, and inverse frequencies, which focus on computing the answers to these queries, but not their verification. 
     Embodiments of the present invention include a query verifier that uses algebraic and probabilistic techniques to compute a small synopsis on the true query result, which can be communicated to the client for verification of whether the query result returned by the server are correct. A synopsis is a small summary based on a query result that is maintained and updated by the data owner and includes a polynomial with coefficients that are based on query results and a random seed. As used herein, a “verification synopsis refers to a synopsis generated by the data owner using a vector based on query results and a “result synopsis” refers to a synopsis generated by a client using query results. A polynomial is a mathematical expression having constants and variables forming terms, each term consisting of a constant multiplier and one or more terms raised to a power, where the terms are separated by mathematical operations. A seed is a random number defined by the data owner that is required to perform the verification of query results using the synopsis. Embodiments of the present invention advantageously provide high-confidence probabilistic solutions with arbitrarily minuscule probability of error, and develop verification algorithms that incur minimal resources, in terms of both the memory consumption of the data owner and the data owner-client network bandwidth. 
       FIG. 1  is an exemplary data outsourcing architecture  100 , in which an untrusted server  110  maintains and makes available, to at least one client  120 , outsourced data steams  102  associated with a data owner  130 . Outsourcing refers to sending information to an independent third party such that the third party performs the operations typically performed by the data owner. The untrusted server, client, and data owner can be computing devices, the implementation of which is known to those skilled in the art. The untrusted server  110  is a server that operates independent of the data owner  130  as a third party to provide clients  120  of the data owner  130  with query results. A query result is a response from the untrusted server to a query that includes information requested by a client. As a result neither the client  120  nor the data owner  130  can be certain that the query results are valid. The untrusted server  110  can implement a Data Stream Management System (DSMS)  112 , which stores and manages data stream information provided by a data owner and retrieves the information in response to queries. A data stream is continuous flow of discrete pieces of information from one computing device to another computing device. The data stream can have a beginning and an end, where all information sent between the beginning and the end are considered to be part of the data stream. The client  120  can register a query  114  with the untrusted server  110  and can receive query results  116  when requested. The data owner generally does not have control of the query results provided by the untrusted server  110 . In some embodiments, the data owner can also act as the client. In these embodiments, the data owner typically does not have enough processing power and resources to run a DSMS itself, but has enough resources to compute the verification synopses instead. 
     To ensure that the untrusted server  110  is providing valid results, the data owner  130  includes a query verifier  132 , which generates and maintains a randomized synopsis  134  of the query results. The query verifier  132  generates the randomized synopsis  134 , which is referred to herein as a “polynomial identity random synopsis” (PIRS), to raise an alarm with very high confidence if errors in the query results  116  exist. Specifically, the data owner  130  preferably maintains the synopsis  134  at a constant size of three machine words (e.g., 3 bytes), and transmits the synopsis  134  to the client  120  preferably via a secure channel upon a verification request  122 . The query result  116  can be verified using this small synopsis  134 . The synopsis  134  can be maintained using constant space and low processing cost per tuple in the stream (O(1) for count queries and O(log n) or O(log μ) for sum queries, where n is the number of possible groups and μ is the update amount per tuple, and O denotes an asymptotic upper bound. In some embodiments, the synopsis  134  can be used for verifying multiple simultaneous queries with the same aggregate attribute but different group-by partitioning, where the size of the synopsis  134  is the same as that for verifying a single query. 
     In some embodiments, the query verifier  132  can implement a buffer  136  for data streams that exhibit a large degree of locality. The buffer  136  can be used to store exact aggregate results for a small number of groups. With data locality, a large portion of updates hit the buffer  136 . Whenever the buffer  136  is full and a new group needs to be inserted, a victim is evicted from the buffer using a simple least recently used (LRU) policy. Only then does the evicted group update PIRS, using the overall aggregate value computed within the buffer  136 . The buffer  136  is emptied to update PIRS whenever verification is required. 
     Embodiments of the query verifier  132  can use generalizations of the synopsis  134 , using the basic PIRS as a building block to create different verification schemes. In some embodiments, a generalization of PIRS is generated for raising alarms when a number of errors exceed a predefined threshold γ. This synopsis, referred to herein as PIRS γ , allows the server  110  to return query results having a predefined margin of error, which can result from, for example, using semantic load shedding. When the number of errors is less than the predefined threshold γ, the server is still considered to be trustworthy. 
     In some embodiments, a weaker version of PIRS γ , referred to herein as PIRS ±γ , can be generated for allowing the server  110  to return query results having an approximate predefined margin of error, where if the errors are fewer than γ −  the answer is considered valid, while if the errors are more than γ +  the answer is considered invalid. 
     In some embodiments, a strengthened version of PIRS γ , referred to herein as PIRS γ *, can be generated so that when the number of errors is tolerable, the errors can be located and even corrected. When PIRS γ * is implemented, it can also act as an error-correcting code, which can guarantee that the complete and correct query results can be delivered to the client  120  when the number of errors is less than the predefined threshold γ. 
     In some embodiments, an embodiment of the synopsis  134 , referred to herein as FM-PIRS, can be used to estimate the actual number of errors accurately. FM-PIRS is a parameter-free version of PIRS ±γ  in the sense that it does not depend on the predefined threshold γ. In particular, when the number of errors exceeds the predefined threshold γ, PIRS ±γ  raises an alarm, while FM-PIRS also reports an estimate of the actual number of errors. FM-PIRS has a smaller size than PIRS ±γ  for large enough threshold γ. 
     Exemplary queries used to illustrate the query verifier  132  can have the following structure:
         SELECT AGG(A — 1), . . . , AGG(A_N) FROM T   WHERE . . . GROUP BY G — 1, . . . , G_M       

     GROUP BY aggregate queries can have wide applications in monitoring and statistical analysis of data streams (e.g., in networking and telephony applications). An example of such a query that appears frequently in network monitoring applications is the following:
         SELECT SUM(packet_size) FROM IP_Trace   GROUP BY source_ip, destination_ip (*)       

     The above query (*) is used for illustrating exemplary embodiments, where sum and count are used, and is referred to herein as the “illustrative query”. Other aggregates that can be converted to sum and count, such as average, standard deviation, and the like, can be supported, by verifying each component separately (i.e., verifying the sum and the count in the case of average). 
     The “GROUP BY” predicate partitions streaming tuples into a set of n groups, computing one sum per group. The data stream can be viewed as a sequence of additions (or subtractions) over a set of items in [n]={1, . . . , n}). This data stream S and its τ-th tuple is denoted herein as s τ =(i, u τ ), an update of amount u τ  to the ith group. The query answer can be expressed as a dynamic vector of non-negative integers v τ =|ν 1   τ , . . . , ν n   τ |∈  containing one component per group aggregate. Initially, v 0  is the zero vector. A new tuple s τ =(i, u τ ) updates the corresponding group i in v τ  as ν i   τ =ν i   τ−1 +u τ . The amount u τ  can either be positive or negative, but require ν i   τ ≧0 for all τ and i. When count queries are concerned, u τ  is substantially equal to 1 for all τ. An assumption can be made that the L 1  norm of v τ  is always bounded by some large m, i.e., at any 
     
       
         
           
             
               
                 
                   τ 
                   i 
                 
                 ⁢ 
                 
                    
                   
                     v 
                     τ 
                   
                    
                 
                 ⁢ 
                 
                   1 
                   1 
                 
               
               = 
               
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     n 
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     υ 
                     i 
                     τ 
                   
                 
                 ≤ 
                 m 
               
             
             , 
           
         
       
     
     The following definition captures the semantics of Continuous Query Verification (CQV): 
     Formal Definition 1. Given a data stream S, a continuous query Q and a user defined parameter 
               δ   ∈     (     0   ,     1   2       )       ,         
a synopsis X of vector v is designed such that for any τ, given any w τ  and using X(v τ ), an alarm is raised with probability at least 1−δ if w τ ≠v τ  and an alarm is not raised if w τ =v τ .
 
     In some embodiments w τ  can be, for example, an answer provided by the server  110 , while X(v τ ) can be the synopsis  134  communicated to the client  120  from the data owner  130  for verifying vector v τ . 
     Using the above definition, an alarm can be raised with high probability if any component (or group answer) ν i   τ  is inconsistent. As an example, consider a server that is using semantic load shedding, i.e., dropping tuples from certain groups, on bursty stream updates. In this example, the aggregate of a certain, small number of components will be inconsistent without malicious intent. In some embodiments, a certain degree of tolerance in the number of erroneous answers contained in the query results is allowed, rather than raising alarms indistinctly. The following definition captures the semantics of  Continuous Query Verification with Tolerance for a Limited Number of Errors  ( CQV   γ ): 
     Formal Definition 2. For any w, v∈  let E(w, v)={i|w i ≠ν i }. Then define w≠ γ v if and only if |E(w, v)|≧γ and w=γ v if and only if |E(w, v)|&lt;γ. Given a data stream S, a continuous query Q, and user defined parameters 
               γ   ∈       {     1   ,   …   ⁢           ,   n     }     ⁢             ⁢             ⁢   and   ⁢             ⁢             ⁢   δ     ∈     (     0   ,     1   2       )       ,         
a synopsis X of vector v is designed such that, for any τ, given any w τ  and using X(v τ ), an alarm is raised with probability at least 1−δ, if w τ ≠ γ v τ ; and an alarm is not raised if w τ = γ v τ .
 
     Formal definition 1 is a special case of formal definition 2, where the threshold γ=1. 
     Some embodiments can support random load shedding (i.e., can tolerate small absolute or relative errors on any component irrespective of the total number of inconsistent components. The following definition captures the semantics of Continuous Query Verification with Tolerance for Small Errors (CQV η ). 
     Formal Definition 3. For any w, v∈  let w≈ η v if and only if there is some i such that |w i −v i |&gt;η, and w≈ηv if |w i −v i |≦η for all i⊖[n]. Given a data stream S, a continuous query Q, and user defined parameters η and 
               δ   ∈     (     0   ,     1   2       )       ,         
a synopsis Z of vector v can be designed such that, for any τ, given any w τ  and using X(v τ ), an alarm is raised with probability at least 1−δ, if w τ ≈ η v τ ; and an alarm is not raised if w τ ≈ η v τ .
 
     The formal definition 3 requires the absolute errors for each ν i   τ  to be no larger than η. It is also possible to use relative errors (i.e., raise an alarm if and only if there is some i such that |w i   τ −ν i   τ |/|ν i   τ |&gt;η). Thus, formal definition 1 is also a special case of formal definition 3 with η=0. 
     Those skilled in the art will recognize that further variations and cases can also be defined. For example, one may wish to bound the sum of the absolute errors, or bound both the number and the size of the errors. Under a standard RAM model, used for illustrative purposes, it is assumed that addition, subtraction, multiplication, division, or modular arithmetic operations involving two words take one unit of time. It is also assumed that n/δ and m/δ fit in a word. 
     Embodiments of the Polynomial Identity Random-Synopsis (PIRS) can be denoted by X(v). The synopsis  134  is based on testing the identity of polynomials by evaluating the polynomials at a randomly chosen point. The technique of verifying polynomial identities is well-known to those skilled in the art. PIRS can have two variants, named PIRS-1 and PIRS-2, respectively. 
     For PIRS-1, let p be some prime such that max{m/δ, n}&lt;p. For the space analysis, let p≦2 max{m/δ, n}. For PIRS-1, the field   is used, where additions, subtractions, and multiplications are done modulo p. For the first PIRS, denoted PIRS-1, a seed α is chosen from   uniformly at random and X(v) is computed incrementally from X(v τ−1 ) and s τ =(i, u τ ) as:
 
 X ( v   τ )= X ( v   τ−1 )(α− i ) u     τ     X (0)= X ( v   0 )=1  (1)
 
 X ( v )=(α−1) ν     1   ·(α−2) ν     2    . . . (α− n ) ν     n   .  (2)
 
     The values of n, m, δ, p are known to the data owner  130  and the clients  120 . The data owner  130  secretly picks a seed α and maintains X(v). Upon a verification request  122 , the data owner  130  returns the synopsis  134  (e.g., PIRS) to the client  120 , which can include only two words: seed α and X(v). Given any answer w (i.e., query results  116 ) returned by the server  110 , the client  120  can use PIRS to check if w=v with high probability, by computing
 
 X ( w )=(α−1) w     1   ·(α−2) w     2   · . . . (α− n ) w     n   .  (3)
 
     If 
                   ∑     i   =   1     n     ⁢           ⁢     w   i       &gt;   m     ,         
the answer w is rejected immediately as being erroneous. If X(w)=X(v), then it is declared that w=v. Otherwise, an alarm is raised. Using this approach, a false alarm is never raised, and it can be shown a true alarm will be missed with a probability at most δ. Given any w≠v, PIRS raises an alarm with probability at least 1−δ. To illustrate this, consider polynomials ƒ v (x)=(x−1) ν     1   (x−2) ν     2    . . . (x−n) ν     n    and ƒ w (x)=(x−1) w     1   (x−2) w     2    . . . (x−n) w     n   . Since a polynomial with 1 as its leading coefficient (i.e., the coefficient of the term with the largest degree) is completely determined by its zeroes (with multiplicities), ƒ v (x)≡ƒ w (x) if and only if v=w. Since both ƒ v (x) and ƒ w (x) have degree at most m, ƒ v (x)=ƒ w (x) happens at no more than m values of x if v≠w, due to the fundamental theorem of algebra. Since we have p≧m/δ choices for seed α, the probability that X(v)=X(w) happens is at most δ over the random choice of seed α.
 
     The update time to maintain X(v) as new updates are observed can be determined as follows. For count queries, each tuple increments one of the v i &#39;s by one, so the update cost is constant (one subtraction and one multiplication). For sum queries, a tuple s=(i, u) increases v i  by u, so (α−i) u  is computed, which can be done in O(log u) (exponentiation by repeated squaring) time. To perform a verification with the answer w, (x−i) wi  is computed for each nonzero entry w i  of the answer w, which takes O(log w i ) time, so the time needed for a verification is 
               O   ⁡     (     ∑           ⁢     log   ⁢           ⁢     w   i         )       =       O   ⁡     (          w        ⁢   log   ⁢     m        w            )       .           
Since both X(v) and seed α are smaller than p, the space complexity of the synopsis is
 
             O   ⁡     (       log   ⁢     m   δ       +     log   ⁢           ⁢   n       )           
bits.
 
     PIRS-1 occupies 
             O   ⁡     (       log   ⁢     m   δ       +     log   ⁢           ⁢   n       )           
bits of space, spends O(1) (resp. O(log u)) time to process a tuple for count queries, and
 
             O   ⁡     (          w        ⁢   log   ⁢     m        w            )           
time to perform a verification.
 
     When u is negative (or when handling deletions for count queries), the field   may not be equipped with division. In this case, (α−i)   is computed, which is the multiplicative inverse of (α−i) in  , in O(log p) time, and then compute (α−i) −1·|u| . 
     For PIRS-2, space usage can be improved using PIRS-2 when n&lt;&lt;m, in which the prime p is chosen between max {m, n/δ} and 2 max {m, n/δ}. For a seed α chosen uniformly at random from  , the following can be computed.
 
 X ( v )=ν 1 α+ν 2 α 2 + . . . +ν n α n .
 
     By adding on ua i  in response to update s=(i, u), the above synopsis is straightforward to maintain over a stream of updates. PIRS-2 has an O(log n) update cost for both count and sum queries, since ua i  is computed for a tuple (i, u) in the stream. PIRS-2 occupies 
             O   ⁡     (       log   ⁢           ⁢   m     +     log   ⁢     n   δ         )           
bits of space, spends O(log n) time to process a tuple, and O(|w|log n) time to perform a verification.
 
     One property of either variant of PIRS (e.g., PIRS-1 or PIRS-2) is that the verification can be performed in one pass of the answer w using a constant number of words of memory. This is advantageous when |w| is large. The client  120  can receive the answer w in a streaming fashion, verify it online, and either forward it to a dedicated server  140  ( FIG. 1 ) for further processing, or a network storage device  150  ( FIG. 1 ) for offline use. 
     Embodiments of the synopses solving the CQV problem with error probability of at most δ keep 
             Ω   ⁢           ⁢     (     log   ⁢       min   ⁢     {     m   ,   n     }       δ       )           
bits. To illustrate this, assume that the vector v and the answer w are both taken from a universe U, and let M be the set of all possible memory states the synopsis can have. Any synopsis X can be seen as a function ƒ:U→M; and if X is randomized, it can be seen as a function randomly chosen from a family of such functions F={ƒ 1 , ƒ 2 , . . . , ƒ l }, where ƒ i  is chosen with probability p(ƒ i ). Without loss of generality, assume that p(ƒ 1 )≧p(ƒ 2 )≧ . . . ≧p(ƒ l ). The synopsis X needs at least log |M| bits to record the output of the function and log |F| bits to describe the function chosen randomly from F.
 
     For any w≠v∈u, let F w,v ={ƒ∈F|ƒ(w)=·ƒ(v)}. For a randomized synopsis X to solve CQV with error probability at most δ, the following must hold for all w≠v∈u: 
     
       
         
           
             
               
                 
                   
                     
                       ∑ 
                       
                         f 
                         ⁢ 
                         
                             
                         
                         ∈ 
                         
                             
                         
                         ⁢ 
                         
                           
                             ℱ 
                             ⁢ 
                             
                                 
                             
                           
                           
                             w 
                             , 
                             v 
                           
                         
                       
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       p 
                       ⁡ 
                       
                         ( 
                         f 
                         ) 
                       
                     
                   
                   ≤ 
                   
                     δ 
                     . 
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
     Focusing on the first k=┌δ|F|┐+1 functions ƒ 1 , . . . , ƒ k , it can be seen that 
                 ∑     i   =   1     k     ⁢     p   ⁡     (     f   i     )         &gt;     δ   .           
Since there are a total of |M| k  possible combinations for the outputs of these k functions
 
| u|≦|M|   k   (6)
 
so that no two w≠v∈u have ƒ i (w)=ƒ i (v) for all i=1, . . . , k; otherwise an answer w and a vector v can be found that violate equation (5). Taking the log of both sides of equation (6), the following results
 
log| u |≦(┌δ·| F|┐+ 1)log| M|.   (7)
 
     Since vector v has n entries whose sum is at most m, by simple combinatorics, 
                    ??        ≥     (           m   +   n             n         )       ,         
or log|u|≧min {m, n}. The following tradeoff can therefore be obtained.
 
| F |·log| M |=Ω(min{ m,n }/δ).  (8)
 
     If log·|F|≦(1−ε)log(min{m, n}/δ) (i.e., |F|≦(min{m, n}/δ) 1-ε ) for any constant ε∈(0, 1), then X uses super-polylogarithmic space log |M|=Ω((min{m, n}/δ) ε ); else X keeps log|F|≧log(min{m, n})δ) random bits. Therefore, when m≦n, PIRS-1 is optimal as long as 
                 log   ⁢           ⁢   n     =     O   ⁡     (     log   ⁢           ⁢     m   δ       )         ;         
and when m&gt;n, PIRS-2 is optimal as long as
 
               log   ⁢           ⁢   m     =       O   ⁡     (     log   ⁢     n   δ       )       .           
The bounds are not tight when
 
               log   ⁢           ⁢     m   δ       =     o   ⁡     (     log   ⁢           ⁢   n     )             
or
 
     
       
         
           
             
               log 
               ⁢ 
               
                 n 
                 δ 
               
             
             = 
             
               
                 o 
                 ⁡ 
                 
                   ( 
                   
                     log 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     m 
                   
                   ) 
                 
               
               . 
             
           
         
       
     
     The analysis above focuses on bit-level space complexity. The value of p is chosen to be the maximum prime that fits in a word, so as to minimize δ, where δ=m/p for PIRS-1 and δ=n/p for PIRS-2. For example, if 64-bit words are used and m&lt;2 32 , then δ is at most 2 −32  for PIRS-1, which makes any error highly unlikely (e.g., 1 in four billion). For speed consideration, careful choice of p can allow faster implementation. For example, choosing p to be a Mersenne prime (e.g., p is of the form p=2 l −1 for some l) allows the modulo arithmetic to be performed using simple addition and subtraction operations. 
     Since the group id i is extracted from each incoming tuple directly, without the use of a dictionary (which would increase the memory cost), the size of the group space, n, needs to be large for certain queries. For example, the exemplary query discussed above has a group space of n=2 64  (the combination of two IP addresses), although the actual number of nonzero entries |v| may be much less than n. In this case, since m is typically much smaller, PIRS-1 is the better choice in this example. 
     Embodiments of the present invention can be used for handling multiple queries simultaneously. For example, consider a number of aggregate queries on a single attribute (e.g., packet size), but with different partitioning on the input tuples (e.g., source/destination IP and source/destination port). Let Q 1 , . . . , Q k  be k such queries, and let the i-th query partition the incoming tuples into n i  groups for a total of 
               ∑     i   =   1     k     ⁢     n   i           
groups. In some embodiments, PIRS can be applied once per query, using space linear in k. In other embodiments, the queries can be treated as one unified query of n groups so that one PIRS is used to verify the combined vector v. The time cost for processing one update increases linearly in k, since each incoming tuple is updating k components of vector v at once (one group for every query in the worst case):
 
     Using PIRS-1 for k queries can occupy 
             O   ⁡     (       log   ⁢           ⁢     m   δ       +     log   ⁢           ⁢   n       )           
bits of space, spend O(k) (resp. O(k log u)) time to process a tuple for count (sum) queries, and
 
             O   ⁡     (          w        ⁢   log   ⁢           ⁢     m        w            )           
time to perform a verification. As a result, multiple queries can be effectively verified with a few words of memory and communication.
 
     After an error has been detected, the client  120  can choose to disclose this information to the server  110 . If the error is not reported, then the probability of detecting an error remains 1−δ. However, errors can occur due to faulty software or bad communication links, and may not be intentional. In this case, it can be beneficial to give a warning to the server  110 . Since an adversary can extract knowledge from this warning (e.g., it knows at least that the same response on the same data will always fail), the guarantee of detecting an error with the probability of 1−δ does not strictly hold. In order to restore the 1−δ success rate after a reported attack, the synopsis  134  has to be recomputed from scratch, which is not typically possible in a streaming setting. Hence, it can be important to rigorously quantify the loss of guarantee after a series of warnings have been sent out without resetting the synopsis. 
     To achieve this let e k =1 if the k-th attack goes undetected and e k =0 otherwise. Let p k  be the probability that the server succeeds in its k-th attack after k−1 failed attempts, (i.e., p k =Pr[e k =1|e 1 =0, . . . , e k−1 =0]). Therefore, it can be determined that p 1 ≦δ. To demonstrate the strength of one embodiment of the present invention, p k  is bounded by an upper limit with respect to the most powerful server A. It can be assumed that the server A knows how PIRS works except its random seed, α; maximally explores the knowledge that could be gained from one failed attack; and possesses unbounded computational power. 
     The best server A could do to improve p k  over multiple attacks is quantified. The space of seeds used by PIRS is denoted R. For any answer w and vector v, the set of witnesses is denoted as W(w, v)={r∈ |PIRS raises an alarm on r} and the set of non-witnesses is denoted as W(w, v)=R−W(w, v). Note that |  W (w, v)|≦δ|  if w≠v, and  W (w, v)=  if w=v. Suppose the seed PIRS uses is r. Server A returns a correct answer w=v, server A cannot infer anything about r. If server A returns some w≠v and gets a warning, it is possible that server A can determine r∉  W (w, v). However, even if it is assumed that server A has enough computational power to compute both the sets of witnesses and non-witnesses, it can be impossible for server A to infer which witness PIRS is using as r. After k−1 failed attacks using w 1 , . . . , w k− , the set of seeds that server A has ruled out is ∪ i=1   k−1   W (w i , v i ), whose cardinality is at most (k−1)δ|R|. Thus, 
                 p   k     ≤     δ     1   -       (     k   -   1     )     ⁢   δ           ,         
where
 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           p 
                           k 
                         
                         = 
                         
                           
                              
                             
                               set 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               of 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               non 
                               ⁢ 
                               
                                 - 
                               
                               ⁢ 
                               witnesses 
                             
                              
                           
                           
                              
                             
                               set 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               of 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               remaining 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               seeds 
                             
                              
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             
                                
                               
                                 
                                   ?? 
                                   _ 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     
                                       w 
                                       k 
                                     
                                     , 
                                     
                                       v 
                                       k 
                                     
                                   
                                   ) 
                                 
                               
                                
                             
                             
                                
                               
                                 ℛ 
                                 - 
                                 
                                   
                                     ⋃ 
                                     
                                       i 
                                       = 
                                       1 
                                     
                                     
                                       k 
                                       - 
                                       1 
                                     
                                   
                                   ⁢ 
                                   
                                     
                                       ?? 
                                       _ 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           w 
                                           i 
                                         
                                         , 
                                         
                                           v 
                                           i 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                               
                                
                             
                           
                           ≤ 
                           
                             
                               δ 
                               
                                 1 
                                 - 
                                 
                                   
                                     ( 
                                     
                                       k 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                   ⁢ 
                                   δ 
                                 
                               
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
     Assuming that server A has made a total of k attacks to PIRS for any k, the probability that none of them succeeds is at least 1−kδ. 
     This probability is 
     
       
         
           
             
               
                 
                   
                     
                       
                         
                           Pr 
                           ⁡ 
                           
                             [ 
                             
                               
                                 e 
                                 1 
                               
                               = 
                               
                                 
                                   0 
                                   ⩓ 
                                   
                                       
                                   
                                   ⁢ 
                                   … 
                                   ⁢ 
                                   
                                       
                                   
                                   ⩓ 
                                   
                                     e 
                                     k 
                                   
                                 
                                 = 
                                 0 
                               
                             
                             ] 
                           
                         
                         = 
                           
                         ⁢ 
                         
                           
                             ∏ 
                             
                               i 
                               = 
                               1 
                             
                             k 
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             ( 
                             
                               1 
                               - 
                               
                                 Pr 
                                 ⁡ 
                                 
                                   [ 
                                   
                                     
                                       
                                         e 
                                         i 
                                       
                                       = 
                                       
                                         
                                           1 
                                           | 
                                           
                                             e 
                                             1 
                                           
                                         
                                         = 
                                         0 
                                       
                                     
                                     , 
                                     … 
                                     ⁢ 
                                     
                                         
                                     
                                     , 
                                     
                                       
                                         e 
                                         
                                           i 
                                           - 
                                           1 
                                         
                                       
                                       = 
                                       0 
                                     
                                   
                                   ] 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         ≥ 
                           
                         ⁢ 
                         
                           
                             ∏ 
                             
                               i 
                               = 
                               1 
                             
                             k 
                           
                           ⁢ 
                           
                             ( 
                             
                               1 
                               - 
                               
                                 δ 
                                 
                                   1 
                                   - 
                                   
                                     
                                       ( 
                                       
                                         i 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                     ⁢ 
                                     δ 
                                   
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           
                             ∏ 
                             
                               i 
                               = 
                               1 
                             
                             k 
                           
                           ⁢ 
                           
                             
                               1 
                               - 
                               
                                 i 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 δ 
                               
                             
                             
                               1 
                               - 
                               
                                 
                                   ( 
                                   
                                     i 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⁢ 
                                 δ 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           
                             
                               
                                 1 
                                 - 
                                 δ 
                               
                               1 
                             
                             · 
                             
                               
                                 1 
                                 - 
                                 
                                   2 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   δ 
                                 
                               
                               
                                 1 
                                 - 
                                 δ 
                               
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           … 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               1 
                               - 
                               
                                 k 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 δ 
                               
                             
                             
                               1 
                               - 
                               
                                 
                                   ( 
                                   
                                     k 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                                 ⁢ 
                                 δ 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                         ⁢ 
                         
                           1 
                           - 
                           
                             k 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               δ 
                               . 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
     The above shows that PIRS is very resistant towards coordinated multiple attacks, even against an adversary with unlimited computational power. For a typical value of δ=2 −32 , PIRS could tolerate millions of attacks before the probability of success becomes noticeably less than 1. The drop in the detection rate to 1−kδ occurs only if the client chooses to disclose the attacks to the server. Such disclosure is not required in many applications. 
     The PIRS can be extended to support sliding windows. PIRS-1 for count queries is used as an illustrative example. Those skilled in the art will recognize that the extension for sliding windows to sum queries, as well as to PIRS-2, PIRS γ , and PIRS ±γ  can also be similarly implemented. 
     One property of PIRS-1 is that it is decomposable (i.e., for any v 1 , v 2 , X(v 1 +v 2 )=X(v 1 ) X(v 2 ) and for PIRS-2, X(v 1 +v 2 )=X(v 1 )+X(v 2 )). This property allows PIRS to be extended for periodically sliding windows using standard techniques. One example of a sliding window query might be the following.
         SELECT SUM(packet size) FROM IP_Trace   GROUP BY source_ip, destination_ip   WITHIN LAST 1 hour SLIDE EVERY 5 minutes       

     In this example, PIRS-1 can be built for every 5-minute period, and can be kept in memory until it expires from the sliding window. Assume that there are k such periods in the window, and let X(v 1 ), . . . , X(v k ) be the PIRS for these periods. In addition, the data owner maintains the overall 
               PIRS   ⁢           ⁢     X   ⁡     (   v   )         =       ∏     i   =   1     k     ⁢           ⁢       χ   ⁡     (     v   i     )       .             
When a new PIRS X(v k+1 ) completes, X(v) is updated as X(v):=X(v) X(v k+1 ) (X(v 1 )) −1 . For a periodically sliding window query with k periods, the synopsis uses
 
             O   ⁡     (     k   ⁡     (       log   ⁢     m   δ       +     log   ⁢           ⁢   n       )       )           
bits of space, spends O(1) time to process an update, and
 
             O   ⁡     (          w        ⁢   log   ⁢     m        w            )           
time to perform a verification.
 
     For various window sizes consisting of between 1 to k periods the k periods can be decomposed into a number of dyadic intervals. For simplicity assume that k is a power of 2. These intervals can be organized into l=log k levels. On level 0, there are k intervals each consisting of one period; on level i, 1≦i≦l−1, there are k/2 i  intervals, each spanning 2 i  periods. There are a total of 2 k −1 such dyadic intervals for this example. One PIRS is built for each interval, so the total size of the entire synopsis is still 
               O   ⁡     (     k   ⁡     (       log   ⁢     m   δ       +     log   ⁢           ⁢   n       )       )       .         
Since a PIRS at level i+1 can be computed in constant time from two PIRS&#39;s at level i, the amortized update cost remains O(1). Upon a verification request with a window size of q periods, the window can be decomposed into at most O(log k) dyadic intervals, and those corresponding PIRS&#39;s can be combined together to form the correct synopsis for the query window. To support sliding window queries with various window sizes of up to k periods, the synopsis uses
 
             O   ⁡     (     k   ⁡     (       log   ⁢     m   δ       +     log   ⁢           ⁢   n       )       )           
bits of space, spends O(1) time to process an update, and O(log k) time to assemble the required synopsis upon a verification request. The client spends
 
             O   ⁡     (          w        ⁢   log   ⁢     m        w            )           
time to perform a verification.
 
     In some embodiments, a synopsis that is tolerant for a few errors, solving the CQV γ  problem can be implemented. To achieve this, let the threshold γ be the number of components in vector v that are allowed to be inconsistent. In some embodiments, a construction is presented that gives an exact solution that satisfies the requirements of CQV γ , and requires 
             O   ⁡     (       γ   2     ⁢   log   ⁢     1   δ     ⁢   log   ⁢           ⁢   n     )           
bits of space. This synopsis can be strengthened so that errors can be located and even corrected. This exact solution uses space quadratic in γ. In other embodiments, an approximate solution which uses only
 
               O   ⁡     (     γ   ⁢           ⁢   log   ⁢     1   δ     ⁢     (       log   ⁢           ⁢   m     +     log   ⁢           ⁢   n       )       )       ⁢                 
bits can be implemented. In other embodiments, a synopsis that can estimate the number of errors can be implemented that uses polylogarithmic space and does not depend on the threshold γ.
 
     Using PIRS as a building block, the synopsis  134  can be constructed that satisfies the requirements of CQV γ . Referring to  FIG. 2 , this embodiment of the synopsis  134 , referred to herein as “PIRS γ ”, consists of multiple layers  200 , where each layer  200  contains k=c 1 γ 2  buckets  210  (c 1 ≧1 is a constant to be determined shortly). Each component of vector v is assigned to one bucket  210  per layer  200 , and each bucket  210  is represented using only its PIRS synopsis. PIRS γ  raises an alarm if at least γ buckets in any layer raise an alarm. If there are fewer than γ errors, no layer will raise an alarm, and if there are more than γ errors, at least one of the layers raises an alarm with high probability (when the γ inconsistent components do not collide on any bucket for this layer). By choosing the probability of failure of the individual PIRS synopsis carefully, it can guarantee that PIRS γ  achieves the requirements of formal definition 2. 
     Examining one layer of PIRS γ , let b be a pairwise independent hash function which maps the range {1, . . . , n} uniformly onto {1, . . . , k}. PIRS γ  assigns v i  to the b(i)-th bucket, and for each bucket computes the PIRS synopsis of the assigned subset of v i &#39;s with probability of failure δ′=1/(c 2 γ) where c 2 ≧1 is a constant. Using PIRS-1 as an example, each of these k synopses occupies 
               O   ⁡     (       log   ⁢     m     δ   ′         +     log   ⁢           ⁢   n       )       =     O   ⁡     (       log   ⁢           ⁢   m     +     log   ⁢           ⁢   n       )             
bits. Given some w= γ v, since there are fewer than γ errors, no alarm is raised. Constants c 1  and c 2  can be chosen such that if w≠ γ v, then an alarm is raised with probability at least ½ for this layer. In this case there are two cases when the query verifier fails to raise an alarm. First where there are fewer than γ buckets that contain erroneous components of w. Second where there are at least γ buckets containing erroneous components but at least one of them fails due to the failure probability of PIRS. Setting constants c 1 , c 2 =4.819, either of the above cases occurs with probability at most ¼. In the first case, the v i &#39;s are assigned to the buckets in a pairwise independent fashion, and it can be guaranteed that the mapping of the γ erroneous components onto the k buckets is injective with probability
 
                           1   -       (     1   -     1   k       )         γ   ⁡     (     γ   -   1     )       2         ≤       ⁢     1   -       (     1   -     1       c   1     ⁢     γ   2           )       γ     2   /   2                       ≤       ⁢     1   -     2       -   1     /     c   1                         ≤       ⁢     1   4       ,                 (   11   )               
where the last inequality holds by the choice of c 1 . In the second case the probability that some of the γ buckets that are supposed to raise an alarm fail is:
 
                       1   -       (     1   -     δ   ′       )     γ       =       1   -       (     1   -     1       c   2     ⁢   γ         )         c   2     ⁢     γ   /     c   2             ⁢     
     ⁢           ≤     1   -     2     -     2     c   2             ⁢     
     ⁢           &lt;     1   4         ,           (   12   )               
which holds as long as c 2 ≧4.819.
 
     Therefore, using one layer, PIRS γ  raises an alarm with probability at least ½ on some w≠ γ v, and will not raise an alarm if w= γ v. By using log(1/δ) layers and reporting an alarm if at least one of these layers raises an alarm, the probability is boosted to 1−δ. So, for any w≠ γ v, PIRS γ  raises an alarm with probability at least 1−δ, and for any w= γ v, PIRS γ  does not raise an alarm. 
     In addition to the k log(1/δ) PIRS synopses, a hash function b mapping updates to buckets is generated. This is achieved by picking x and y uniformly at random from  , and computing b(i)=xi+y mod p mod k, where “mod” is used wherein for modulo. This generates a function that is pairwise-independent over the random choices of x and y. Verification can be performed by computing, in parallel, for the layers while making one pass over the answer w. Initialization, update, and verification for PIRS γ  appear in psuedcode below. 
     
       
         
           
               
             
               
                   
               
               
                 Algorithm 1: PIRS γ -INITIALIZE(Prime p, Threshold γ) 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
            
               
                   
                 1 
                 c = 4.819,k = ┌cγ 2 ┐ 
               
               
                   
                 2 
                 Generate x and y uniformly at random from    
               
               
                   
                 3 
                 for l = 1,...,┌log 1/δ┐ do 
               
               
                   
                 4 
                  | Layer L l  = [X 1 (v) := 0,...,X k (v) := 0] 
               
               
                   
                   
                  |_ // X j (v) is a PIRS synopsis with δ′ = 1/cγ 
               
               
                   
                   
               
            
           
         
       
     
     
       
         
           
               
             
               
                   
               
               
                 Algorithm 2: PIRS γ -UPDATE(Tuple s = (i, u)) 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
            
               
                   
                 1 
                 for l = 1,...,┌log 1/δ┐ do 
               
               
                   
                 2 
                  | b l (i) = xi + y mod k + 1 
               
               
                   
                 3 
                  |_ Update L l .X b     l     (i) (v) using s 
               
               
                   
                   
               
            
           
         
       
     
     
       
         
           
               
             
               
                   
               
               
                 Algorithm 3: PIRS γ -VERIFY(Vector w) 
               
               
                   
               
             
            
               
                   
               
            
           
           
               
               
               
            
               
                   
                 1 
                 for l = 1,...,┌log 1/δ┐ do 
               
               
                   
                 2 
                  | Layer M l  = [X 1 (w) := 0,...,X k (w) := 0] 
               
               
                   
                   
                  | // X j (w) is a PIRS synopsis with δ′ = 1/cγ 
               
               
                   
                 3 
                  | for i = 1,...,n do 
               
               
                   
                 4 
                  |  | b l (i) = xi + y mod k + 1 
               
               
                   
                 5 
                  |  |_ Update M l .X b     l     (i) (w) by s = (i, w i ) 
               
               
                   
                 6 
                  |_ if |{j | L i .X j (v) ≠ M i .X j (w),1 ≦ j ≦ k}| ≧ γ 
               
               
                   
                   
                  then Raise an alarm 
               
               
                   
                   
               
            
           
         
       
     
     PIRS γ  requires 
             O   ⁡     (       γ   2     ⁢   log   ⁢     1   δ     ⁢     (       log   ⁢           ⁢   m     +     log   ⁢           ⁢   n       )       )           
bits, spends
 
             O   ⁡     (     log   ⁢     1   δ       )           
time to process a tuple in the stream, and
 
             O   ⁡     (          w        ⁢     (     γ   +     log   ⁢     m        w              )     ⁢   log   ⁢     1   δ       )           
time to perform a verification. Careful analysis can facilitate a smaller constant in the asymptotic cost above. For a given γ, the minimum k is chosen such that equation (11) is at most ½, and 1/δ′ is chosen to be very large (close to the maximum allowed integer) so that equation (12) is almost zero. For instance
 
                   if   ⁢           ⁢   γ     =     2   ⁢           ⁢   and   ⁢           ⁢   3       ,     then   ⁢           ⁢   2   ⁢           ⁢   log   ⁢           ⁢       1   ⁢               1   δ       ⁢           ⁢   and   ⁢           ⁢   6   ⁢           ⁢     log     1   δ           ⁢                 
words suffice, respectively. For arbitrary γ, the storage requirement is
 
             2   ⁢           ⁢     γ   2     ⁢   log   ⁢           ⁢     1     1   δ             
words in the worst case.
 
     When there are a small number of errors (at most γ), PIRS γ  does not raise an alarm, which gives some leeway to the server  110 . This is often necessary so that the server can cope with large volumes of incoming data using some semantic load shedding strategies. However, in some critical applications, if the client  120  demands complete correctness, PIRS γ  may not be sufficient, since it may only indicate to the client  120  if there are less than γ errors, but not where they are. In some embodiments, a strengthened version of PIRS γ , referred to herein as PIRS γ *, can be implemented, that is able to identify which groups are affected by errors, and even compute the correct sums for the affected groups by taking advantage of a technique based on the binary decomposition of the group identifier. 
     Applying the binary decomposition to PIRS γ , the amount of information kept about each bucket is increased. In addition to keeping a PIRS synopsis of all items which fall into a given bucket, 2┌log n┐ number of PIRS synopses are maintained and arranged as a two-dimensional array A of size ┌log n┐×2. When an update to group i is placed into bucket b(i), the PIRS in A[j, bit(i, j)] is updated, for all 1≦j≦┌log n┐×2, where bit(i, j) denotes the jth bit in the binary representation of i. 
     To perform a query verification, the array A of PIRS synopses is computed for both the vector v and the answer w for each bucket. If all corresponding entries match, then (with high probability) there is no erroneous components in the bucket. If, for any j, the PIRS in both A[j, 0] and A[j, 1] do not match, then this indicates that there is more than one erroneous component in this bucket, because a single erroneous i cannot contaminate both A[j, 0] and A[j, 1]. Otherwise, there must be exactly one erroneous component falling into this bucket. This is the case for all erroneous components with high probability, providing that there are at most γ such components. In this case, for each j, exactly one of A[j, 0] and A[j, 1] do not match. If it is A[j, 1], this indicates that the jth bit of the identifier i of the erroneous group is 1 otherwise, it is 0. Using ┌log n┐ pairs of PIRS, the identifier can therefore be recovered exactly. 
     The erroneous components w i  in the answer w returned by the server  110  can be located. Moreover, enough information to recover each true v i  for each wrong result can exist. For example, suppose the bucket at layer l contains exactly one error, which is v i . Note that the data owner will return X b     t     (i) (v)=Π i (α−j) ν     j   . Since only v i  is unknown in this equation, v i  can be found by solving the equation. If PIRS-2 is used, the equation becomes as X b     t     (i) (v)=Σ j ν j α j . Thus, v i  can be found efficiently using field subtractions and divisions. 
     In PIRS γ *, each PIRS in PIRS γ  is replaced with an array of O(log n) PIRS, so the space and time increases by an O(log n) factor. PIRS γ * requires 
             O   ⁡     (       γ   2     ⁢   log   ⁢     1   δ     ⁢   log   ⁢           ⁢     n   ⁡     (       log   ⁢           ⁢   m     +     log   ⁢           ⁢   n       )         )           
bits, spends
 
             O   ⁡     (     log   ⁢     1   δ     ⁢   log   ⁢           ⁢   n     )           
time to process a tuple in the stream, and
 
             O   ⁡     (          w        ⁢     (     γ   +     log   ⁢     m        w              )     ⁢   log   ⁢     1   δ     ⁢   log   ⁢           ⁢   n     )           
time to perform a verification. For any w≠ γ v, PIRS γ * raises an alarm with probability 1−δ; for any w= γ v, PIRS γ * does not raise an alarm but correctly identifies and recovers the errors in the answer w with probability 1−δ.
 
     When the number of errors, for example λ, is no more than γ, PIRS γ * can recover all the errors with high probability. When λ&gt;γ, there may be too many errors to expect a complete recovery of all the query results. Nevertheless, PIRS γ * can recover a good portion of the results. For this analysis, precision and recall are used to measure the performance of the synopsis. Precision refers to the probability that an identified error is truly an actual error. Since PIRS does not have false positives, precision is always 1. Recall, is the percentage of the actual errors that have been recovered, or equivalently, the probability that any one error has been captured by the synopsis. For any given error ε, if the error ε falls into a bucket by itself in any of the layers, then PIRS γ * can correctly recover it. For a particular layer, because the errors are distributed into the buckets pairwise-independently and there are c 1 γ 2  buckets, the probability that the bucket containing ε is the same as the bucket for any of the other λ−1 errors is at most λ/(c 1 γ 2 ) following the union bound. Since the log(1/δ) layers are mutually independent, the probability that this collision happens in all layers is 
     
       
         
           
             
               
                 ( 
                 
                   λ 
                   
                     
                       c 
                       1 
                     
                     ⁢ 
                     
                       γ 
                       2 
                     
                   
                 
                 ) 
               
               
                 log 
                 ⁢ 
                 
                   1 
                   δ 
                 
               
             
             = 
             
               
                 
                   δ 
                   Ω 
                 
                 ⁡ 
                 
                   ( 
                   
                     log 
                     ⁡ 
                     
                       ( 
                       
                         
                           γ 
                           2 
                         
                         / 
                         λ 
                       
                       ) 
                     
                   
                   ) 
                 
               
               . 
             
           
         
       
     
     When there are λ&gt;γ errors, PIRS γ * raises an alarm with probability 1−δ and recovers the errors with a recall of 1−δ Ω(log(γ     2     /λ)) . 
     The exact solution is advantageous when only a small number of errors can be tolerated. In applications where γ is large, the quadratic space requirement can be prohibitive. If alarms can be raised when approximately γ errors have been observed, space-efficient synopsis can be implemented. This approximation is often acceptable since when γ is large, users may not be concerned if the number of errors detected deviates from γ by a small amount. An approximate solution, denoted with PIRS ±γ , guarantees that the PIRS ±γ  raises no alarm with probability at least 1−δ on any w= γ     −   v where 
               γ   -     =       (     1   -     c     ln   ⁢           ⁢   γ         )     ⁢     γ   .             
and raises an alarm with probability at least 1−δ on any w≠ γ     +   v where
 
                 γ   +     =       (     1   +     c     ln   ⁢           ⁢   γ         )     ⁢   γ       ,         
for and constant c&gt;−ln ln 2≈0.367. The multiplicative approximation ratio
 
             1   ±     c     ln   ⁢           ⁢   γ             
is close to 1 for large γ.
 
     PIRS ±γ  also contains multiple layers of buckets, where each bucket is assigned a subset of the components of vector v and summarized using PIRS ( FIG. 2 ). Focusing on one layer only, one goal is, for any w= γ     −   v, to not raise an alarm with probability at least ½+ε for some constant ε∈(0, ½), and on any w≠ γ     +   v to raise an alarm with probability at least ½+ε. By using 
             O   ⁡     (     log   ⁢     1   δ       )           
independent layers and reporting the majority of the results, the probabilistic guarantee will be boosted to 1−δ using Chernoff bounds described in “Randomized Algorithms”, by Motwani et al., the subject matter of which is incorporated by reference in its entirety.
 
     As an example, let k be the number of buckets per layer. The components of vector v are distributed into the k buckets in a γ + -wise independent fashion, and for each bucket the PIRS summary of those components is computed using δ′=1/γ 2 . Given some answer w, let this layer raise an alarm only if all the k buckets report alarms. If the answer w contains more than γ +  erroneous members, then the probability that every bucket gets at least one such component is high; and if the answer w contains fewer than γ −  erroneous members, then the probability that there exists some bucket that is not assigned any erroneous members is also high. 
     One factor that determines whether a layer could possibly raise an alarm is the distribution of erroneous components into buckets. The event that all buckets raise alarms is only possible if each bucket contains at least one inconsistent component. Consider all the inconsistent components in the answer w in some order, for example w 1 , w 2 , . . . , where of each of them can be considered a collector that randomly picks a bucket to “collect”. Assume that there are enough inconsistent elements, and let the random variable Y denote the number of inconsistent components required to collect all the buckets (i.e., Y is the smallest i such that w 1 , . . . , w i  have collected all the buckets). The problem becomes an instantiation of the coupon collector&#39;s problem (viewing buckets as coupons and erroneous components as trials). With k buckets, it is known that E(Y)=k ln k+O(k), therefore k is set such that γ=┌k ln k┐. It can be seen that k=O(γ/ln γ), hence the desired storage requirement. 
     For any constant c′,
 
 Pr[Y≦k ((ln  k−c ′)]≦ e   −e     c′     +o (1),  (13)
 
 Pr[Y≧k ((ln  k+c ′)]≦1− e   −e     −c′     +o (1),  (14)
 
where o(1) depends on k.
 
     Notice that ln γ≦2 ln k for any k≧2, so the above equations also implies that for any real constant c: 
     
       
         
           
             
               
                 
                   
                     
                       Pr 
                       ⁡ 
                       
                         [ 
                         
                           
                             Y 
                             ≤ 
                             
                               γ 
                               - 
                               
                                 c 
                                 ⁢ 
                                 
                                   γ 
                                   
                                     ln 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     γ 
                                   
                                 
                               
                             
                           
                           = 
                           
                             γ 
                             - 
                           
                         
                         ] 
                       
                     
                     ≤ 
                     
                       
                         ⅇ 
                         
                           - 
                           
                             e 
                             c 
                           
                         
                       
                       + 
                       
                         o 
                         ⁡ 
                         
                           ( 
                           1 
                           ) 
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
             
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       [ 
                       
                         
                           Y 
                           ≥ 
                           
                             γ 
                             + 
                             
                               c 
                               ⁢ 
                               
                                 γ 
                                 
                                   ln 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   γ 
                                 
                               
                             
                           
                         
                         = 
                         
                           γ 
                           + 
                         
                       
                       ] 
                     
                   
                   ≤ 
                   
                     1 
                     - 
                     
                       ⅇ 
                       
                         - 
                         
                           e 
                           
                             - 
                             c 
                           
                         
                       
                     
                     + 
                     
                       
                         o 
                         ⁡ 
                         
                           ( 
                           1 
                           ) 
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
     If w= γ     −   v, then the probability that these fewer than γ −  independent erroneous components cover all buckets is bounded by equation (15), which is also the upper bound for the probability that the layer raises an alarm. Thus, for any c≧0, the probability of raising a false alarm is (for large enough γ) at most
 
 e   −e     e   ≦1/ e.   (17)
 
If w≠ γ     +   v, then considering γ +  of the inconsistent components, which are independently distributed to the buckets, there are two cases in which a true alarm is not raised. First, when the γ +  components do not cover all buckets and second when all the buckets are covered but at least one of them fails to report an alarm. The probability that the first case occurs is bounded by equation (16), while the probability that the second case occurs is at most 1−(1−δ′) k . By the union bound, the total probability that a false negative is produced is at most
 
                     1   -     ⅇ     -     e     -   c           +     o   ⁡     (   1   )       +   1   -       (     1   -     δ     ′   ⁢                 )     k       ≤     2   -     ⅇ     e     -   c         -     2     -     2   γ         +       o   ⁡     (   1   )       .               (   18   )               
For γ large enough, there exists a constant ε&gt;0 such that this probability is at most ½−ε for any c&gt;−ln ln 2.
 
     To summarize, if c&gt;−ln ln 2≈0.367, then both the false positive and false negative probabilities are at most ½−ε for some constant ε at one layer with k=O(γ/log γ) buckets. 
     To drive down the error probabilities for both false positives and false negatives to δ, l=O(log(1/δ)) layers are used and the simple majority of their “votes” is reported. This probability is quantified for false negatives; the other case is symmetric. 
     Each layer can be viewed as a coin flip that raises a true alarm with probability at least ½+ε. Let the random variable Z denote the number of layers that raise alarms. This process is a sequence of independent Bernoulli trials, hence Z follows the binomial distribution. For l independent layers, the expectation of Z is at least μ=(½+ε)l. By the Chernoff bound, the probability that a majority of layers raise alarms is 
     
       
         
           
             
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       [ 
                       
                         Z 
                         &lt; 
                         
                           
                             1 
                             2 
                           
                           ⁢ 
                           ℓ 
                         
                       
                       ] 
                     
                   
                   = 
                   
                     
                       Pr 
                       ⁡ 
                       
                         [ 
                         
                           Z 
                           &lt; 
                           
                             
                               ( 
                               
                                 1 
                                 - 
                                 
                                   
                                     2 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ɛ 
                                   
                                   
                                     1 
                                     + 
                                     
                                       2 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       ɛ 
                                     
                                   
                                 
                               
                               ) 
                             
                             ⁢ 
                             μ 
                           
                         
                         ] 
                       
                     
                     &lt; 
                     
                       
                         ⅇ 
                         
                           
                             - 
                             
                               
                                 μ 
                                 ⁢ 
                                 
                                     
                                 
                               
                               2 
                             
                           
                           ⁢ 
                           
                             
                               ( 
                               
                                 
                                   
                                     2 
                                     ⁢ 
                                   
                                   ⁢ 
                                   
                                       
                                   
                                 
                                 
                                   
                                     1 
                                     + 
                                     
                                       2 
                                       ⁢ 
                                     
                                   
                                   ⁢ 
                                   
                                       
                                   
                                 
                               
                               ) 
                             
                             2 
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
     Therefore, it is ensured that 
                 ⅇ       -     μ   2       ⁢       (       2   ⁢       1   +     2   ⁢         )     2         ≤   δ     ,         
which can be satisfied by taking
 
     
       
         
           
             ℓ 
             = 
             
               
                 ⌈ 
                 
                   
                     
                       1 
                       + 
                       
                         2 
                         ⁢ 
                         ⁢ 
                         ɛ 
                       
                     
                   
                   ⁢ 
                   ln 
                   ⁢ 
                   
                     1 
                     δ 
                   
                 
                 ⌉ 
               
               . 
             
           
         
       
     
     A γ + -wise independent random hash function is generated to map groups to buckets. Using standard techniques, such a function can be generated using O(γlog n) truly random bits. Specifically, the technique for constructing t-universal hash families can be used. Let p be some prime between n and 2n, and α 0 , . . . , α γ−1  be γ random numbers chosen uniformly and independently from  . Then we set 
     
       
         
           
             
               
                 
                   
                     b 
                     ⁡ 
                     
                       ( 
                       i 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           0 
                         
                         
                           t 
                           - 
                           1 
                         
                       
                       ⁢ 
                       
                         
                           α 
                           j 
                         
                         ⁢ 
                         
                           i 
                           j 
                         
                         ⁢ 
                         mod 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         k 
                       
                     
                     + 
                     1. 
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
     This function is guaranteed to be drawn from a t-wise independent family of functions (so that, over the random choice of the function, the probability of t items colliding under the hash function is 1/k t−1 ). For an incoming tuple s=(i, u), b(i) is computed using the α j &#39;s in O(γ) time (using Horner&#39;s rule), and then perform the update to the corresponding PIRS. This requires the storage of O(γ + )=O(γ) truly random numbers per layer. As a result, PIRS ±γ  uses 
             O   ⁡     (     γ   ⁢           ⁢   log   ⁢     1   δ     ⁢     (       log   ⁢           ⁢   m     +     log   ⁢           ⁢   n       )       )           
bits of space, spends
 
             O   ⁡     (     γ   ⁢           ⁢   log   ⁢     1   δ       )           
time to process an update and
 
             O   ⁡     (          w        ⁢     (     γ   +     log   ⁢     m        w              )     ⁢           ⁢   log   ⁢     1   δ       )           
time to perform a verification. By allowing two-sided errors, the size of the synopsis can be reduced from quadratic in γ to linear.
 
     An improved solution, FM-PIRS for the CQV γ  problem can be generated, whose size and update cost only depend on the degree of approximation, but not γ, thus allowing it to scale well with γ. FM-PIRS directly estimates the number of errors in the result provided by the server, and then compares the estimate with γ. As a result, FM-PIRS can also support a wider range of values of γ, which can be given only at verification time. For small values of γ, the bounds and guarantees of PIRS γ  and PIRS ±γ  are preferred, but for larger values of γ, the cost of FM-PIRS is preferable. 
     As the name suggest, FM-PIRS is a combination of PIRS and an FM sketch, which is described in “Probabilistic Counting Algorithms For database Applications”, by Flajolet et al., the subject matter of which is incorporated herein by reference in its entirety. The FM sketch is used to estimate the number of distinct elements in a stream. The FM sketch is described as follows. Suppose that the universe is [n]={1, . . . , n}. A random hash function h:[n]→[2 L −1] is picked such that any h(i) is uniformly distributed over [2 L −1], where L=O(log n). For each element i in the stream h(i) is computed. The number of trailing zeros in the binary representation of h(i) are denoted by r(i). The FM sketch computes R=max{r(i), for all i in the stream} and then outputs k/φ·2 (R     1     + . . . +R     k     )/k , where φ≈0.7735. To improve accuracy, the universe is divided into k partitions using another random uniform hash function, and an R j  is computed for each partition. Finally the output is k/φ·2 (R     1     + . . . +R     k     )/k . 
     To illustrate the FM-PIRS synopsis, the basic FM sketch with k=1 is used although those skilled in the art will recognize that generalization to larger k is possible. Each “wrong” group i can be treated such that ν i ≠w i  is a distinct element in the universe [n], and then R=max{r(i), for all wrong groups i} can be computed. Generally, the data owner does not know whether i is a wrong group, so r(i) cannot be computed directly. Instead, a number L of PIRS&#39;s X 1 , . . . , X L  with δ′=δ/L are created. For any i, group i is put into X j  if j≦r(i). Thus X 1  gets half of the groups, X 2  gets a quarter of the groups, etc. 
     The value of R can be computed as follows. When all of X 1 , . . . , X L  correctly capture the errors in them, which happens with probability at least 1−δ′L=1−δ, R=arg max j  {X j  raises an alarm}. 
     For k partitions, fix any k, FM-PIRS has a size of O(k log n(log m+log n)) bits, processes a tuple in expected time O(1), and computes an estimate of the number of errors in the result in expected time O(|w|log m|w|). With probability at least 1−δ, the estimate has a bias bounded by 1+0.31/k and a standard error of 0.78/√k. 
     Since each partition keeps L=O(log n) PIRS&#39;s, the overall size of FM-PIRS is O(k log n(log m+log n)) bits. For an incoming tuple, only one partition gets affected, but 0 to L of the PIRS&#39;s in this partition can get updated. Since the hash function h is uniform, the expected number of PIRS&#39;s updated is O(1). Upon receiving the FM-PIRS synopses of vector v and an answer w from the server, we need to spend O(log w i ) expected time per non-zero entry of the answer w to compute the FM-PIRS synopses of the answer w. So the expected time needed for an estimation is 
     
       
         
           
             
               O 
               ( 
               
                 
                   ∑ 
                   i 
                 
                 ⁢ 
                 
                   log 
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     w 
                     i 
                   
                 
               
               ) 
             
             = 
             
               
                 O 
                 ⁡ 
                 
                   ( 
                   
                     
                        
                       w 
                        
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     log 
                     ⁢ 
                     
                       m 
                       
                          
                         w 
                          
                       
                     
                   
                   ) 
                 
               
               . 
             
           
         
       
     
     An analytical comparison of PIRS ±γ  and FM-PIRS can be provided. Since FM-PIRS computes an estimate of the number of errors in the answer w, FM-PIRS can be used to do the same task for which PIRS ±γ  is designed. For a fair comparison, k is set such that FM-PIRS provides the same probabilistic guarantee that PIRS ±γ  does. Since the standard error of FM-PIRS is O(1/√{square root over (k)}) and PIRS ±γ  allows a deviation of O(1/ln γ). 
     By setting k=O(log 2  γ), it can be guaranteed that FM-PIRS captures both false positives and false negatives with good probabilities (e.g., greater than ¾). Finally, by using 
             O   ⁡     (     log   ⁢     1   δ       )           
independent copies of FM-PIRS and taking the median, the success probability can be boosted to 1−δ, the same as what PIRS ±γ  guarantees. Finally, only L=O(log γ) are needed since estimating the number of errors when there are over, for example, 2γ of them is not required.
 
     Under this configuration, FM-PIRS uses 
                 O   ⁡     (       log   3     ⁢     γ   ⁡     (       log   ⁢           ⁢   m     +     log   ⁢           ⁢   n       )         )       ⁢   log   ⁢           ⁢     1   δ       )         
bits of space. Thus, asymptotically (as γ grows) FM-PIRS is better than PIRS ±γ . However, for small γ PIRS ±γ  should be better in terms of size, while FM-PIRS becomes better when γ exceeds some large threshold.
 
       FIG. 3  depicts an exemplary computing device  300  for implementing embodiments of the present invention. The computing device  300  can be a mainframe, personal computer (PC), laptop computer, workstation, handheld device, such as a PDA, or the like. The computing device  300  can be implemented as the server  110 , the client  120 , and/or the data owner  130 . In the illustrated embodiment, the computing device  300  includes a central processing unit (CPU)  302  and preferably a display device  304 . The display device  304  enables the computing device  300  to communicate directly with an operator through a visual display. The computing device  300  can further include data entry device(s)  306 , such as a keyboard, touch screen, and/or mouse. The computing device  300  can include storage  308  for storing data and instructions. The storage  308  can include such technologies as a floppy drive, hard drive, tape drive, Flash drive, optical drive, read only memory (ROM), random access memory (RAM), and the like. 
     Applications  310  can be resident in the storage  308 . The applications  310  can include instructions for implementing embodiments of the present invention. For embodiments where the computing device  300  is implemented as the data owner  130 , the applications  310  can include instructions for implementing the query verifier  132 . For embodiments where the computing device  300  is implemented as the untrusted server  110 , the applications  310  can include instructions for implementing the DSMS  112 . For embodiments where the computing device is implemented as the client  120 , the applications  310  can include instructions for implementing the queries, as well as for implementing the verification of query results using the synopsis  134  generated by the data owner. The storage  308  can be local or remote to the computing device  300 . The computing device  300  includes a network interface  312  for communicating with a network. The CPU  302  operates to run the application in storage  308  by performing instructions therein and storing data resulting from the performed instructions, which may be presented to an operator via the display  304  or by other mechanisms known to those skilled in the art, such a print out from a printer. 
     Although preferred embodiments of the present invention have been described herein with reference to the accompanying drawings, it is to be understood that the invention is not limited to those precise embodiments and that various other changes and modifications may be affected herein by one skilled in the art without departing from the scope or spirit of the invention, and that it is intended to claim all such changes and modifications that fall within the scope of the invention.