Patent Publication Number: US-2017359177-A1

Title: Method and System for Cryptographic Decision-making of Set Membership

Description:
FIELD OF THE INVENTION 
     The presently claimed invention relates generally to information technology. The invention also relates to cryptographic methods for secure decision-making of set-membership used in secure group communication. 
     BACKGROUND OF THE INVENTION 
     The ‘positive’ membership and ‘negative’ membership are two of most common binary relations. For a given set U={e 1 , . . . , e n } and any a subset S ⊂ U, the positive membership is usually expressed as ∈, e.g., e∈S denotes the element e is in the set S. Similarly, the negative membership is as ∉, e.g., e∉S denotes e is not in S. When there exists only one element in the set, the ‘positive’ membership and ‘negative’ membership are converted into the ‘equal’ and ‘unequal’ relationship, respectively. These two basic memberships also induce several complex relationships, including ‘inclusion’, ‘exclusion’, ‘set-equal’, ‘set-unequal’, etc. Especially, the ‘negative’ membership is also regarded as NOT-logic or Complement-logic that is used widely in decision analysis and logic judgment. 
     In cryptography, ‘positive’ and ‘negative’ membership are always used to make a secure decision on set membership, that is, the ‘positive’ and ‘negative’ membership denote whether a given element e exists (or does not exist) in a set S. This kind of decisions is required to be cryptographically secure, for example, if e∈S (or e∉S), no one can declare wrong relationship e∉S (or e∈S) to the others. 
     Cryptographic set operations over ‘positive’ and ‘negative’ membership and NOT-logic have an important value in theory and application for designing security protocols and secure computation algorithms, such as broadcast encryption (BE), attribute-based encryption (ABE), predicate encryption (PE), function encryption (FE), and privacy-protection keyword query (PPKQ), etc. The cryptographic ‘positive’ and ‘negative’ membership is in essence a secure computation technology, which is a basic mechanism to protect information assets under open network environment. This kind of technology has been widely used in the E-commerce, E-government, online trading, and even military networks. 
     Let us see an example in group-oriented broadcast encryption. We assume that a broadcaster wants to send an encrypted sensitive message to all users, but only specified users can use their private keys to decrypt received messages. It will be easy to implement with help of cryptographic ‘positive’ and ‘negative’ membership: Let S be a set of these specified users. The broadcaster encapsulates S into the encrypted message, and e is tied to user&#39;s private key. If e∈S, the user can decrypt the received message; otherwise, the user, even if he has the previous license, is unable to decrypt the received message. 
     Let us see another example in attribute-based encryption (ABE). An attribute set is composed of different values, e.g., City={‘Beijing’, ‘Shanghai’, ‘Shenzheng’, ‘London’, ‘New York’ . . . }. The message sender can choose some values from this set to form an ‘authorized’ or ‘non-authorized’ subset, which will decide what values will be authorized or unauthorized to decrypt the message. In addition, each member in cryptosystem is assigned some attribute values and the corresponding attribute-keys to identify his identity. With help of cryptographic decision-making method of set-membership in this invention, the receiver compares the values hidden by the attribute-keys with the encrypted subset in the ciphertext when he tries to recover the message. If the comparison result satisfies the ‘positive’ (or ‘negative’) membership over the subset, he can decrypt the message correctly. However, there does not exist this kind of cryptographic decision-making method of set-membership in the literature at present. Our method will fill the vacancy of this field in cryptography. 
     SUMMARY OF THE INVENTION 
     It is, accordingly, an object of this invention to provide a construction, method, and system for cryptographic decision-making of set membership, in order to solve the problem that there does not exist an effective method to implement cryptographic representation of set membership in the existing literature. 
     The present invention provides a cryptographic construction method for determining a set membership, comprising:
         acquiring any given set U={e 1 , . . . , e n }, and transforming each element e i  in the set U into a random point v i  in a cryptographic space;   acquiring a given set S={e′ 1 , . . . , e′ m } ⊂ U, determining a random point v′ i  corresponding to each element e′ i  in the set S according to the random point v i , and constructing a function ƒ S (x) according to the random point v′ i ;   introducing a random secret γ, determining a function ƒ S (γ) according to the function ƒ S (x), and determining a public parameter mpk according to the random secret γ; and   processing the function ƒ S (γ) by using the public parameter mpk as an input to generate a cryptographic representation of the set S via a cryptographic method.       

     Further, the random point comprises a random number or a random vector; constructing a function ƒ S (x) according to the random point v′ i  comprises:
         constructing a zeros-based polynomial ƒ S (x) by setting the random point v′ i  corresponding to each element e′ i  in the set S as a zero of the polynomial H(x); or   constructing a poles-based polynomial ƒ S (x) by setting the random point v′ i  corresponding to each element e′ i  in the set S as a pole of the polynomial H(x);   wherein H(x) is a rational polynomial with a form H(x)=P(x)/Q(x), which is the quotient of two polynomial P(x) and Q(x); for a variable z, the root z of P(x) is called a zero of H(x) if P(z)=0, and the root z of Q(x) is called a pole of H(x) if Q(z)=0;   the constructed function also comprises a Lagrange interpolation polynomial, Newton interpolation polynomials, Hermite interpolation polynomials, Bernstein polynomials and Fibonacci polynomials, Binomial polynomials or corresponding algebraic curves constructed from the random point v′ i .       

     Further, the processing the function ƒ S (γ) by using the public parameter mpk as an input to generate a cryptographic representation of the set S via a cryptographic method comprises:
         processing the function ƒ S (γ) by using the public parameter mpk as an input to generate an aggregation function Aggregate(mpk,S) of the set S via cryptographic method, wherein the aggregation function is called a zeros-based aggregation function ZerosAggr(mpk,S) if the function ƒ S (x) is a zeros-based polynomial, or the aggregation function is called a poles-based aggregation function PolesAggr(mpk,S) if the function ƒ S (x) is a poles-based polynomial; and   compressing the set S into a constant-size random number or random vector R S  by means of the aggregation function, wherein R S  is an aggregated value outputted by the aggregation function Aggregate(mpk,S), and the size of R S  is independent of the number of elements in the set S.       

     Further, after the compressing the set S into a constant-size random number R S  by means of the aggregation function, further comprising:
         constructing a cryptographic determination algorithm by means of the aggregation function for determining equality and inequality relationships between elements; and/or constructing a cryptographic determination method by means of the aggregation function for determining positive and negative affiliation memberships between elements and the set; and/or   constructing a cryptographic determination method by means of the aggregation function for determining positive and negative containment relationships between the sets.       

     Further, the constructing a cryptographic determination algorithm by means of the aggregation function for determining a positive affiliation membership between elements and the set comprises:
         acquiring an element e i , and when e i ∈S, setting S − =S\{e i }, then determining the aggregated value R S     −    by the zeros-based aggregation function ZerosAggr(mpk,S − ); and   when e i ∉S, setting S − =s\{e i }, then determining the aggregated value R S     −    by none of polynomial-time algorithms, the polynomial-time algorithms comprise ZerosAggr(mpk,S − );   the constructing a cryptographic determination algorithm by means of the aggregation function for determining a negative affiliation membership between elements and the set comprises:   acquiring an element e i , when e i ∉S, setting S + =S∪{e i }, then determining the aggregated value R S     +    by the pole-based aggregation function PoiesAggr(mpk,S + ); and   when e i ∈S, setting S + =S∪{e i }, then determining the aggregated value R S     +    by none of polynomial-time algorithms, the polynomial-time algorithms comprise PolesAggr(mpk,S + ).       

     Further, the constructing a cryptographic determination algorithm by means of the aggregation function for determining a positive affiliation membership between elements and the set comprises:
         constructing a commitment on the aggregated value R S  according to the outputted aggregated value R S  of the set S from the poles-based aggregation function PolesAggr(mpk,S);   for the element e i , when e i ∉S, verifying the commitment according to the determined aggregated value R S     −    outputted by the zeros-based aggregation function ZerosAggr(mpk,S − ); and   when e i ∈S, verifying the commitment by none of polynomial-time algorithms;   the constructing a cryptographic determination algorithm by means of the aggregation function for determining a negative affiliation membership between elements and the set comprises:   constructing a commitment on the aggregated value R S  according to the outputted aggregated value R S  of the set S from the zeros-based aggregation function ZerosAggr(mpk,S);   for the element e i , when e i ∈S, verifying the commitment according to the determined aggregated value R S     −    outputted by the poles-based aggregation function PolesAggr(mpk,S + ); and   when e i ∈S, verifying the commitment by none of polynomial-time algorithms.       

     A cryptographic construction system for determining a set membership, comprising:
         a randomizing unit, which is configured to acquire any given set U={e 1 , . . . , e n } and transform each element e i  in the set U into a random point v i  in a cryptographic space;   a function generating unit, which is configured to acquire a given set S={e′ 1 , . . . , e′ m } ⊂ U, determine a random point v′ i  corresponding to each element e′ i  in the set S according to the random point v i , and construct a function ƒ S (x) according to the random point v′ i ;   a secret point determining unit, which is configured to introduce a random secret γ, determine a function ƒ S (γ) according to the function ƒ S (x), and determine a public parameter mpk according to the random secret γ; and   a cryptographic processing unit, which is configured to process the function ƒ S (γ) by using the public parameter mpk as an input to generate a cryptographic representation of the set S via a cryptographic method.       

     Further, the cryptographic processing unit comprises:
         a processing module, which is configured to process the function ƒ S (γ) by using the public parameter mpk as an input to generate an aggregation function Aggregate(mpk,S) of the set S via cryptographic method, wherein the aggregation function is called a zeros-based aggregation function ZerosAggr(mpk,S) if the function ƒ S (x) is a zeros-based polynomial, or the aggregation function is called a poles-based aggregation function PolesAggr(mpk,S) if the function ƒ S (x) is a poles-based polynomial; and   a compressing module, which is configured to compress the set S into a constant-size random number or random vector R S  by means of the aggregation function, wherein R S  is an aggregated value outputted by the aggregation function Aggregate(mpk,S), and the size of R S  is independent of the number of elements in the set S.       

     Further, the cryptographic construction system further comprising:
         a first determination unit, which is configured to construct a cryptographic determination algorithm by means of the aggregation function for determining equality and inequality relationships between elements; and/or   a second determination unit, which is configured to construct a cryptographic determination algorithm by means of the aggregation function for determining positive and negative affiliation memberships between elements and the set; and/or   a third determination unit, which is configured to construct a cryptographic determination algorithm by means of the aggregation function for determining positive and negative containment relationships between the sets.       

     Further, the second determination unit is further configured to acquire an element e i , and when e i ∈S, set S − =S\{e i }, then determine the aggregated value R S     −    by the zeros-based aggregation function ZerosAggr(mpk,S − ); and when e i ∉S, set S − =S\{e i }, then determine the aggregated value R S     −    by none of polynomial-time algorithms, the polynomial-time algorithms comprise ZerosAggr(mpk,S − ); and
         the second determination unit is further configured to acquire an element e i , when e i ∉S, set S + =S∪{e i }, then determine the aggregated value R S     +    by the pole-based aggregation function PoiesAggr(mpk,S + ); and when e i ∈S, set S + =S∪{e i }, then determine the aggregated value R S     +    by none of polynomial-time algorithms, the polynomial-time algorithms comprise PoiesAggr(mpk,S + ).   According to the fourth aspect of the presented invention, there are provided some advantageous features comprising:       

     The Aggregation algorithm supports the aggregation of any number of elements in a given set, that is, there is no restrict on the number of aggregated elements, such that our system will provide the cryptographic decision-making for membership over a set of any size. 
     The presented system supports cryptographic decision-making for ‘positive’ and ‘negative’ membership, simultaneously. The reason is that these two kinds of decision-making methods only need two aggregation functions: PolesAggr(•) and ZerosAggr(•). 
     The presented decision-making method for ‘positive’ and ‘negative’ membership is secure with unforgeability and non-repudiation based on the difficulty in computing the aggregated values for two error settings, e i ∉S but S − =S\{e i }, and e i ∈S but S + =S∪{e i }. The reason is that the zeros-based (or poles-based) aggregation values R S     −    (or R S     +   ) cannot be computed by any polynomial-time algorithm (regarded as any attacker), including the aggregation function ZerosAggr(mpk,S − ) (or PolesAggr(mpk,S + )). 
     The presented cryptographic decision-making method may provide a foundation for the cryptography research on set theory. Considering that modern mathematic is foundation on set theory, the solution to the decision-making problem of basic membership inevitably lead to solving a series of related cryptographic problems, especially in secure (unilateral, two-party, multiparty) computing, including Privacy-based Data Retrieval, Keyword Search of Confidential Database, Group Encryption, Predicate Encryption, Attribute-based Encryption, Cryptography-based Access Control and so on. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a system diagram illustrating cryptographic decision-making of positive membership in accordance with the embodiment of the invention; 
         FIG. 2  is a system diagram illustrating cryptographic decision-making of negative membership in accordance with the embodiment of the invention; 
         FIG. 3  is a structural diagram of cryptosystem illustrating decision-making of membership in accordance with the embodiments of the invention. 
     
    
    
     DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS 
     In order that the invention may be more clearly understood, embodiments thereof will now be described, by way of example only, with reference to the accompanying drawings, in detail. 
     The presented invention aims at the issue that the set-membership cannot be expressed and decided in cryptography in the literature at present, and provide the cryptographic methods of secure decision-making of set-memberships. 
     An embodiment of the invention is described as follows: 
     (1) Aggregation Function 
     In this embodiment, the core notion is aggregation function based on cryptographic representation of subsets. Given a set U, an aggregation function is a cryptographic function to compress the information of any subset S ⊂ U into a constant-size value. The output of aggregation function is called the cryptographic representation of subset. This function is stated as follows: 
     Let PK denote the public key space over a group G and U={e 1 ,L,e n }, the function Aggregate: PK×2 U →G is a deterministic polynomial-time algorithm satisfying: 
       Aggregate( mpk,S )= R   S ,  (1)
 
     where mpk is the public key in PK, S ⊂ U, and R S  is an element in G. 
     Note that, the aggregation function is an open function because it merely takes as input the public key and does not require any secret information for its operation. 
     The aggregation function serves as the foundation for making cryptographic decisions on set memberships, i.e., positive membership e∈S and negative membership e∉S. More exactly, we construct two aggregation functions, ZerosAggr and PolesAggr, for decision-making on positive membership (e∈S) and negative membership (e∉S), respectively. 
     Before we present the two aggregation functions, we first give the definition of zeros and poles in a rational polynomial function as follows: 
     H(x) is a rational polynomial with a form H(x)=P(x)/Q(x), which is the quotient of two polynomial P(x) and Q(x); for a variable z, the root z of P(x) is called a zero of H(x) if P(z)=0, and the root z of Q(x) is called a pole of H(x) if Q(z)=0; 
     Based on this definition, there is provided a construction method for two aggregation functions, Zeros-based aggregation ZerosAggr and Poles-based aggregation PolesAggr. 
     (2) Construction of Zeros-Based Aggregation Function 
     Firstly, the function ZerosAggr is constructed according to four following phases: 
     1) Randomizing Phase 
     Let G be a multiplicative cyclic group of prime order p and g is a generator of G. Given a set U={e 1 ,L,e n }, each element e i  in U is converted into a random point v i  in one dimensional space. The collision-resistant Hash function hash is used to realize this conversation, that is, 
       ( v   1   ,L,v   n )=(hash( e   1 ), L ,hash( e   n ))∈¢ n   p   (2)
 
     Where, ¢ n   p  denotes the n integers under module p and each element e i  is represented by the arbitrary length binary string. We do not limit the size of U because the number of elements is usually far less than the size of ¢ n   p  (e.g., p&gt;2 256  for a secure elliptic curve). 
     2) Function-Generating Phase 
     Given a subset S={e′ 1 ,L,e′ m } ⊂ U, a zeros-based polynomial ƒ S (x) could be derived from all random points (v′ 1 ,L,v′ n )=(hash(e′ 1 ),L,hash(e′ n )) which are considered as the (negative) zeros of polynomial. Exactly, the polynomial ƒ S (x) is defined as: 
     
       
         
           
             
               
                 
                   
                     
                       f 
                       S 
                     
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         x 
                          
                         
                           ( 
                           
                             x 
                             + 
                             
                               v 
                               1 
                               ′ 
                             
                           
                           ) 
                         
                       
                        
                       
                           
                       
                        
                       … 
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           x 
                           + 
                           
                             v 
                             m 
                             ′ 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       x 
                       · 
                       
                         
                           ∏ 
                           
                             
                               e 
                               i 
                               ′ 
                             
                             ∈ 
                             S 
                           
                         
                          
                         
                             
                         
                          
                         
                           
                             ( 
                             
                               x 
                               + 
                               
                                 v 
                                 i 
                                 ′ 
                               
                             
                             ) 
                           
                            
                           mod 
                            
                           
                               
                           
                            
                           
                             p 
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
     3) Secret-Determining Phase 
     A random secret γ is introduced to generate ƒ S (γ) by using the polynomial ƒ S (x), that is, 
       ƒ S (γ)=γΣ e′     i     ∈S (γ+ v′   i )mod  p.   (4)
 
     And then produces the public parameter mpk=(g 1 ,g 2 ,L,g m )=(g γ ,g γ2 ,L,g γ     m   ) from γ. 
     4) Cipher-Processing Phase 
     In this phase, the zeros-based representation of set S is generated by using the function ƒ S (γ) and the public parameter mpk. Firstly, the zeros-based representation of set S is defined as 
     
       
         
           
             
               
                 
                   
                     
                       g 
                       
                         
                           f 
                           S 
                         
                          
                         
                           ( 
                           γ 
                           ) 
                         
                       
                     
                     = 
                     
                       
                         g 
                         
                           γ 
                            
                           
                               
                           
                            
                           
                             
                               ∏ 
                               
                                 
                                   e 
                                   i 
                                   ′ 
                                 
                                 ∈ 
                                 S 
                               
                             
                              
                             
                               ( 
                               
                                 γ 
                                 + 
                                 
                                   v 
                                   i 
                                   ′ 
                                 
                               
                               ) 
                             
                           
                         
                       
                       ∈ 
                       G 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
     where, g is the generator of group G. 
     Next ƒ S (x)=xΠ e′     i     ∈S (x+v′ i )=Σ k=0   m a k x k+1 , where the coefficient a k  can be computed only if all elements in S are known. According to Equation (5), the zeros-based aggregation value is also able to computed by using the public parameter mpk={g i =g γ     i   } i∈[1,m]  as follows: 
         G   S   =gΣ   k=0   m   a   k γ (k+1) =Π k=1   m+1   g   k   a     k−1   .  (6)
 
     Note that, when S=Ø, the output of this function is ZerosAggr(mpk,Ø)=g 1 =g γ . 
     In this embodiment, a function is called the Zeros-based Aggregation (in short, ZerosAggr) function since the hash values of all elements in S are used for the (negative) zeros in the polynomial ƒ S (x). The Zeros-based Aggregation is defined as follows: 
     Given a subset S={e 1 ,L,e n } ⊂ U and a cyclic group G, an algorithm is called Zeros-based Aggregation function if there exists a polynomial-time algorithm that outputs 
     
       
         
           
             
               
                 G 
                 S 
               
               = 
               
                 
                   ZerosAggr 
                    
                   
                     ( 
                     
                       mpk 
                       , 
                       S 
                     
                     ) 
                   
                 
                 = 
                 
                   g 
                   
                     γ 
                     · 
                     
                       
                         ∏ 
                         
                           
                             e 
                             i 
                             ′ 
                           
                           ∈ 
                           S 
                         
                       
                        
                       
                         ( 
                         
                           γ 
                           + 
                           
                             v 
                             i 
                           
                         
                         ) 
                       
                     
                   
                 
               
             
             , 
           
         
       
     
     where, mpk={g i =g γ     i   } i∈[1,|U|]  is the public parameter, g is a generator in G, v i =hash(e i ) and γ is a secret. 
     (3) Construction of Poles-Based Aggregation Function 
     Secondly, the poses-based aggregation function PolesAggr is constructed according to four following phases: 
     1) Randomizing Phase 
     Let G be the same cyclic group of prime order p in ZerosAggr and h is a generator of G. Given a set U={e 1 ,L,e n }, the collision-resistant Hash function hash is used to realize the mapping from elements to random points, that is, 
       ( v   1   ,L,v   n )=(hash( e   1 ), L ,hash( e   n ))∈¢ n   p .  (7)
 
     2) Function-Generating Phase 
     Given a subset S={e′ 1 ,L,e′ m } ⊂ U, a poles-based polynomial g S (x) could be derived from all points (v′ 1 ,L,v′ n )=(hash(e′ 1 ),L,hash(e′ n )) which are considered as the (negative) poles of polynomial. Exactly, the polynomial g S (x) is defined as: 
     
       
         
           
             
               
                 
                   
                     
                       g 
                       S 
                     
                      
                     
                       ( 
                       x 
                       ) 
                     
                   
                   = 
                   
                     
                       1 
                       
                         
                           ( 
                           
                             x 
                             + 
                             
                               v 
                               i 
                               ′ 
                             
                           
                           ) 
                         
                          
                         
                             
                         
                          
                         … 
                          
                         
                             
                         
                          
                         
                           ( 
                           
                             x 
                             + 
                             
                               v 
                               m 
                               ′ 
                             
                           
                           ) 
                         
                       
                     
                     = 
                     
                       
                         1 
                         
                           
                             ∏ 
                             
                               
                                 e 
                                 i 
                                 ′ 
                               
                               ∈ 
                               S 
                             
                           
                            
                           
                             ( 
                             
                               x 
                               + 
                               
                                 v 
                                 i 
                                 ′ 
                               
                             
                             ) 
                           
                         
                       
                        
                       mod 
                        
                       
                           
                       
                        
                       
                         p 
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
     3) Secret-Determining Phase 
     A random secret γ is introduced to generate g S (γ), that is, 
         g   S (γ)=Π e′     i     ∈S (γ+ v′   i ) −1  mod  p.   (9)
 
     And then produces the public parameter mpk=(h 1 ,h 2 ,L,h m )=(h 1/γ+v′     1   ,h 1/γ+v′     2   ,L,h 1/γ+v′     m   ) from γ. 
     4) Cipher-Processing Phase 
     The poles-based representation of set S is defined as 
     
       
         
           
             
               
                 
                   
                     
                       H 
                       S 
                     
                     = 
                     
                       
                         h 
                         
                           
                             g 
                             S 
                           
                            
                           
                             ( 
                             γ 
                             ) 
                           
                         
                       
                       = 
                       
                         
                           h 
                           
                             1 
                             
                               
                                 ∏ 
                                 
                                   
                                     e 
                                     i 
                                     ′ 
                                   
                                   ∈ 
                                   S 
                                 
                               
                                
                               
                                 ( 
                                 
                                   x 
                                   + 
                                   
                                     v 
                                     i 
                                     ′ 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ∈ 
                         G 
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
     where, h is the generator of cyclic group G. 
     We provide a fast recursive method to realize the PolesAggr function from the public parameter 
     
       
         
           
             mpk 
             = 
             
               
                 
                   { 
                   
                     
                       h 
                       i 
                     
                     = 
                     
                       h 
                       
                         1 
                         
                           y 
                           + 
                           
                             v 
                             i 
                           
                         
                       
                     
                   
                   } 
                 
                 
                   
                     e 
                     i 
                   
                   ∈ 
                   U 
                 
               
               . 
             
           
         
       
     
     Firstly, let us see the aggregation between two elements: given h i  and h j , it is easy to obtain the equation 
     
       
         
           
             
               
                 
                   
                     
                       
                         ( 
                         
                           
                             h 
                             j 
                           
                           / 
                           
                             h 
                             i 
                           
                         
                         ) 
                       
                       
                         1 
                         
                           
                             v 
                             i 
                             ′ 
                           
                           - 
                           
                             v 
                             j 
                             ′ 
                           
                         
                       
                     
                     = 
                     
                       
                         
                           ( 
                           
                             
                               h 
                               
                                 
                                   1 
                                   
                                     γ 
                                     + 
                                     
                                       v 
                                       j 
                                       ′ 
                                     
                                   
                                 
                                 / 
                               
                             
                              
                             
                               h 
                               
                                 1 
                                 
                                   γ 
                                   + 
                                   
                                     v 
                                     i 
                                     ′ 
                                   
                                 
                               
                             
                           
                           ) 
                         
                         
                           1 
                           
                             
                               v 
                               i 
                               ′ 
                             
                             - 
                             
                               v 
                               j 
                               ′ 
                             
                           
                         
                       
                       = 
                       
                         h 
                         
                           1 
                           
                             
                               ( 
                               
                                 γ 
                                 + 
                                 
                                   v 
                                   i 
                                   ′ 
                                 
                               
                               ) 
                             
                              
                             
                               ( 
                               
                                 γ 
                                 + 
                                 
                                   v 
                                   j 
                                   ′ 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
     where v i ≠v j  is a precondition for this equation for avoiding error with dividing by zero. Next, we expand this equation to multi-value cases. Set 
     
       
         
           
             
               
                 B 
                 
                   i 
                   , 
                   j 
                 
               
               = 
               
                 
                   h 
                   
                     1 
                     
                       
                         ∏ 
                         
                           k 
                           = 
                           i 
                         
                         j 
                       
                        
                       
                           
                       
                        
                       
                         ( 
                         
                           γ 
                           + 
                           
                             v 
                             k 
                             ′ 
                           
                         
                         ) 
                       
                     
                   
                 
                 = 
                 
                   h 
                   
                     
                       1 
                       
                         γ 
                         + 
                         
                           v 
                           i 
                           ′ 
                         
                       
                     
                      
                     L 
                      
                     
                       1 
                       
                         γ 
                         + 
                         
                           v 
                           j 
                           ′ 
                         
                       
                     
                   
                 
               
             
             , 
           
         
       
     
     The poles-based aggregation value 
     
       
         
           
             
               H 
               S 
             
             = 
             
               
                 B 
                 
                   1 
                   , 
                   m 
                 
               
               = 
               
                 h 
                 
                   1 
                   
                     
                       ∏ 
                       
                         
                           e 
                           i 
                           ′ 
                         
                         ∈ 
                         S 
                       
                       
                           
                       
                     
                      
                     
                       ( 
                       
                         x 
                         + 
                         
                           v 
                           i 
                           ′ 
                         
                       
                       ) 
                     
                   
                 
               
             
           
         
       
     
     can be computed by 
     
       
         
           
             
               
                 
                   { 
                   
                     
                       
                         
                           
                             B 
                             
                               i 
                               , 
                               i 
                             
                           
                           = 
                           
                             h 
                             i 
                           
                         
                       
                       
                         
                           ∀ 
                           
                             i 
                             ∈ 
                             
                               [ 
                               
                                 1 
                                 , 
                                 m 
                               
                               ] 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             B 
                             
                               i 
                               , 
                               j 
                             
                           
                           = 
                           
                             
                               ( 
                               
                                 
                                   B 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                 
                                 / 
                                 
                                   B 
                                   
                                     
                                       i 
                                       + 
                                       1 
                                     
                                     , 
                                     
                                       j 
                                       + 
                                       1 
                                     
                                   
                                 
                               
                               ) 
                             
                             
                               1 
                               
                                 
                                   v 
                                   
                                     j 
                                     + 
                                     1 
                                   
                                   ′ 
                                 
                                 - 
                                 
                                   v 
                                   i 
                                   ′ 
                                 
                               
                             
                           
                         
                       
                       
                         
                           
                             i 
                             ∈ 
                             
                               [ 
                               
                                 1 
                                 , 
                                 
                                   m 
                                   - 
                                   1 
                                 
                               
                               ] 
                             
                           
                           , 
                           
                             j 
                             ∈ 
                             
                               [ 
                               
                                 2 
                                 , 
                                 m 
                               
                               ] 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
     In this embodiment, a function is called the Poles-based Aggregation (in short, PolesAggr) function since the hash values of all elements in S are used for the (negative) poles in the polynomial g S (x). The Poles-based Aggregation is defined as follows: 
     Given a subset S={e 1 ,L,e m } ⊂ U and a cyclic group G, an algorithm is called Poles-based Aggregation function if there exists a polynomial-time algorithm that outputs 
     
       
         
           
             
               
                 H 
                 S 
               
               = 
               
                 
                   PolesAggr 
                    
                   
                     ( 
                     
                       mpk 
                       , 
                       S 
                     
                     ) 
                   
                 
                 = 
                 
                   h 
                   
                     1 
                     
                       
                         ∏ 
                         
                           
                             e 
                             i 
                             ′ 
                           
                           ∈ 
                           S 
                         
                       
                        
                       
                         ( 
                         
                           γ 
                           + 
                           
                             v 
                             i 
                           
                         
                         ) 
                       
                     
                   
                 
               
             
             , 
           
         
       
     
     where, 
     
       
         
           
             mpk 
             = 
             
               
                 { 
                 
                   
                     h 
                     i 
                   
                   = 
                   
                     h 
                     
                       1 
                       
                         y 
                         + 
                         
                           v 
                           i 
                         
                       
                     
                   
                 
                 } 
               
               
                 
                   e 
                   i 
                 
                 ∈ 
                 U 
               
             
           
         
       
     
     is the public parameter, h is a generator in G, v i =hash(e i ) and γ is a secret. 
     In this embodiment, the information of the set S is compressed and represented as a random number (or vector) in a cryptographic space by zeros-based aggregation function or poles-based aggregation function. Next, the aggregated value can decided the memberships in a cryptographic approach, such as: ‘equal’ and ‘unequal’ between two elements, ‘inclusion’ and ‘exclusion’ between two sets, and ‘positive’ and ‘negative’ membership whether one element is in a set of elements. 
     (4) Security of Zeros-Based Aggregation Function 
     The accuracy and reliability of decision-making of ‘positive’ membership depends on the security of the zeros-based aggregation function. In this embodiment, the security of zeros-based aggregation function satisfies the following requirements: 
     Given an element e i ∈U and a subset S ⊂ U, let S − =S\{e i } and 
     
       
         
           
             
               
                 
                   
                     G 
                     
                       S 
                       - 
                     
                   
                   = 
                   
                     
                       G 
                       
                         S 
                          
                         \ 
                          
                         
                           { 
                           
                             e 
                             i 
                           
                           } 
                         
                       
                     
                     = 
                     
                       
                         g 
                         
                           
                             
                               f 
                               S 
                             
                              
                             
                               ( 
                               γ 
                               ) 
                             
                           
                           
                             γ 
                             + 
                             
                               v 
                               i 
                             
                           
                         
                       
                       = 
                       
                         
                           g 
                           
                             
                               γ 
                                
                               
                                 
                                   ∏ 
                                   
                                     
                                       e 
                                       i 
                                       ′ 
                                     
                                     ∈ 
                                     S 
                                   
                                 
                                  
                                 
                                   ( 
                                   
                                     γ 
                                     + 
                                     
                                       v 
                                       i 
                                       ′ 
                                     
                                   
                                   ) 
                                 
                               
                             
                             
                               γ 
                               + 
                               
                                 v 
                                 i 
                               
                             
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
     A function on S is called the secure zeros-based aggregation if it has the following two properties:
         Easy to compute G S−  for e i ∈S, that is, the value G S     −    can be computed by       

     
       
         
           
             
               ZerosAggr 
                
               
                 ( 
                 
                   mpk 
                   , 
                   
                     S 
                     - 
                   
                 
                 ) 
               
             
             = 
             
               g 
               
                 γ 
                  
                 
                   
                     ∏ 
                     
                       
                         
                           e 
                           i 
                           ′ 
                         
                         ∈ 
                         S 
                       
                       , 
                       
                         
                           e 
                           i 
                           ′ 
                         
                         ≠ 
                         
                           e 
                           i 
                         
                       
                     
                   
                    
                   
                     ( 
                     
                       γ 
                       + 
                       
                         v 
                         i 
                         ′ 
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
     within a polynomial-time;
         Hard to compute G S−  for e i ∉S, that is, any PPT algorithm (including ZerosAggr(mpk,S − )) computing G S     −    succeeds with negligible probability.       

     These two properties can ensure the security of decision-making of positive membership. 
     (5) Security of Poles-Based Aggregation Function 
     The accuracy and reliability of decision-making of ‘negative’ membership depends on the security of the poles-based aggregation function. In this embodiment, the security of poles-based aggregation function satisfies the following requirements: 
     Given an element e i ∈U and a subset S ⊂ U, let S + =S\{e i } and 
     
       
         
           
             
               
                 
                   
                     H 
                     
                       S 
                       + 
                     
                   
                   = 
                   
                     
                       H 
                       
                         S 
                          
                         
                             
                         
                         ⋃ 
                         
                           { 
                           
                             e 
                             i 
                           
                           } 
                         
                       
                     
                     = 
                     
                       
                         h 
                         
                           
                             
                               g 
                               S 
                             
                              
                             
                               ( 
                               γ 
                               ) 
                             
                           
                           · 
                           
                             1 
                             
                               γ 
                               + 
                               
                                 v 
                                 i 
                               
                             
                           
                         
                       
                       = 
                       
                         h 
                         
                           
                             1 
                             
                               
                                 ∏ 
                                 
                                   
                                     e 
                                     i 
                                     ′ 
                                   
                                   ∈ 
                                   S 
                                 
                                 
                                     
                                 
                               
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   x 
                                   + 
                                   
                                     v 
                                     i 
                                     ′ 
                                   
                                 
                                 ) 
                               
                             
                           
                           · 
                           
                             1 
                             
                               
                                   
                               
                               
                                 ( 
                                 
                                   γ 
                                   + 
                                   
                                     v 
                                     i 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
     A function on S is called the secure poles-based aggregation if it has the following two properties:
         Easy to compute H S+  for e i ∉S, that is, the value H S+  can be computed by       

     
       
         
           
             
               PolesAggr 
                
               
                 ( 
                 
                   mpk 
                   , 
                   
                     S 
                     + 
                   
                 
                 ) 
               
             
             = 
             
               h 
               
                 
                   1 
                   
                     
                       ∏ 
                       
                         
                           e 
                           i 
                           ′ 
                         
                         ∈ 
                         S 
                       
                       
                           
                       
                     
                      
                     
                         
                     
                      
                     
                       ( 
                       
                         x 
                         + 
                         
                           v 
                           i 
                           ′ 
                         
                       
                       ) 
                     
                   
                 
                 · 
                 
                   1 
                   
                     
                         
                     
                     
                       ( 
                       
                         γ 
                         + 
                         
                           v 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
           
         
       
     
     within a polynomial-time;
         Hard to compute H S+  for e i ∈S, that is, any PPT algorithm (including PolesAggr(mpk,S + )) computing H S+  succeeds with negligible probability.       

     These two properties can ensure the security of decision-making of negative membership. 
     (6) Cryptographic Decision-Making of Positive Membership 
     In order to achieve the decision-making of positive membership, this invention introduces the concept of commitment. Commitment, which contains two processes: commitment-generating and commitment-verifying, is a basic concept in cryptography. No one can guess the secret in the commitment after the commitment is built, but we can verify the consistency between the commitment and its hidden secret if we obtain some specific values (called clues). 
     In this embodiment, the cryptographic decision-making of positive and negative membership is built on the general bilinear pairing system that can be indicated as S={p,G,G T ,e(•,•)}. In this system, G and G T  are two multiplicative cyclic groups of prime order p, and elements g and h are the generators of G T  and then the bilinear pairing can be indicated as e: G×G a G T . This system should have the following properties: 
     1) Bilinear: For any a,b belong to ¢* p , it can get e(g a ,h b )=e(g,h) ab ; 
     2) Non-degenerate: e(g,h)≠1; 
     3) Computable: There is a polynomial-time algorithm to calculate e(g,h). 
       FIG. 1  is a flow diagram that implementing cryptographic decision-making of positive membership, described as follows: 
     For any given set S, the poles-based aggregate function  1  PolesAggr(mpk,S) is invoked to calculate the aggregation value H S  of set S. And then, a random secret k is introduced to construct the value H S &#39;s commitment 
     
       
         
           
             
               H 
               S 
             
             = 
             
               
                 h 
                 
                   
                     
                       g 
                       s 
                     
                      
                     
                       ( 
                       γ 
                       ) 
                     
                   
                    
                   k 
                 
               
               = 
               
                 
                   h 
                   
                     k 
                     
                       
                           
                       
                       
                         
                           ∏ 
                           
                             
                               r 
                               i 
                             
                             ∈ 
                             S 
                           
                           
                               
                           
                         
                          
                         
                             
                         
                          
                         
                           ( 
                           
                             γ 
                             + 
                             
                               v 
                               i 
                             
                           
                           ) 
                         
                       
                     
                   
                 
                  
                 
                     
                 
                  
                 and 
                  
                 
                     
                 
                  
                 
                   
                     g 
                     
                       γ 
                        
                       
                           
                       
                        
                       k 
                     
                   
                   . 
                 
               
             
           
         
       
     
     For a given element e satisfying e∉S, let S − =S\{e}  2  according to the security definition of zeros-based aggregation function. 
     The zeros-based aggregation function  3  ZerosAggr(mpk,S − ) is invoked to calculate the aggregation value 
     
       
         
           
             
               
                 
                   
                     G 
                     
                       s 
                       - 
                     
                   
                   = 
                   
                     
                       ZerosAggr 
                        
                       
                         ( 
                         
                           mpk 
                           , 
                           
                             S 
                             - 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         G 
                         
                           S 
                            
                           \ 
                            
                           
                             { 
                             e 
                             } 
                           
                         
                       
                       = 
                       
                         
                           g 
                           
                             
                               f 
                               
                                 S 
                                 - 
                               
                             
                              
                             
                               ( 
                               γ 
                               ) 
                             
                           
                         
                         = 
                         
                           
                             g 
                             
                               
                                 
                                   f 
                                   S 
                                 
                                  
                                 
                                   ( 
                                   γ 
                                   ) 
                                 
                               
                               
                                 γ 
                                 + 
                                 v 
                               
                             
                           
                           = 
                           
                             
                               g 
                               
                                 
                                   γ 
                                    
                                   
                                     
                                       ∏ 
                                       
                                         
                                           e 
                                           i 
                                         
                                         ∈ 
                                         S 
                                       
                                     
                                      
                                     
                                       ( 
                                       
                                         γ 
                                         + 
                                         
                                           v 
                                           i 
                                         
                                       
                                       ) 
                                     
                                   
                                 
                                 
                                   γ 
                                   + 
                                   v 
                                 
                               
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
     Where, v=hash(e) and v i =hash(e i ). 
     The following secret value is recovered  4  from 
     
       
         
           
             
               
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           G 
                           
                             S 
                             - 
                           
                         
                         , 
                         
                           H 
                           S 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             g 
                             
                               
                                 
                                   f 
                                   S 
                                 
                                 - 
                               
                                
                               
                                 ( 
                                 γ 
                                 ) 
                               
                             
                           
                           , 
                           
                             h 
                             
                               
                                 
                                   g 
                                   S 
                                 
                                  
                                 
                                   ( 
                                   γ 
                                   ) 
                                 
                               
                                
                               k 
                             
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         e 
                         ( 
                         
                           
                             g 
                             
                               
                                 γ 
                                  
                                 
                                   
                                     ∏ 
                                     
                                       
                                         e 
                                         i 
                                       
                                       ∈ 
                                       S 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       γ 
                                       + 
                                       
                                         v 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               
                                 γ 
                                 + 
                                 v 
                               
                             
                           
                           , 
                           
                             h 
                             
                               k 
                               
                                 
                                   
                                     ∏ 
                                     
                                       
                                         e 
                                         i 
                                       
                                       ∈ 
                                       S 
                                     
                                   
                                    
                                   
                                     ( 
                                     
                                       γ 
                                       + 
                                       
                                         v 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                     
                                 
                               
                             
                           
                         
                         ) 
                       
                       = 
                       
                         
                           
                             e 
                              
                             
                               ( 
                               
                                 g 
                                 , 
                                 h 
                               
                               ) 
                             
                           
                           
                             
                               γ 
                               · 
                               k 
                             
                             
                               γ 
                               + 
                               v 
                             
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
     The above commitment is verified  5  by using 
     
       
         
           
             
               
                 
                   e 
                    
                   
                     ( 
                     
                       g 
                       , 
                       h 
                     
                     ) 
                   
                 
                 
                   
                     γ 
                      
                     
                         
                     
                      
                     k 
                   
                   
                     γ 
                     + 
                     v 
                   
                 
               
               = 
               
                 e 
                 ( 
                 
                   
                     g 
                     
                       γ 
                        
                       
                           
                       
                        
                       k 
                     
                   
                   , 
                   
                     h 
                     
                       1 
                       
                         γ 
                         + 
                         v 
                       
                     
                   
                 
                 ) 
               
             
             , 
           
         
       
     
     where is 
     
       
         
           
             h 
             
               1 
               
                 γ 
                 + 
                 v 
               
             
           
         
       
     
     directly derived from mpk. 
     Conversely, if e∉S, according to the security definition of zeros-based aggregation function, it is computably difficult to recover the particular value 
     
       
         
           
             
               
                 e 
                  
                 
                   ( 
                   
                     g 
                     , 
                     h 
                   
                   ) 
                 
               
               
                 
                   γ 
                   · 
                   k 
                 
                 
                   γ 
                   + 
                   v 
                 
               
             
             , 
           
         
       
     
     therefore the commitment verification  5  cannot be passed. 
     In summary, the above-mentioned method makes more efficient and precise for decision-making of positive membership. That is, it not only improves the efficiency of decision-making process, but also ensures the security and consistency of decision-making. 
     (7) Cryptographic Decision-Making of Negative Membership 
       FIG. 2  is a flow diagram that implementing cryptographic decision-making of negative membership, described as follows: 
     For any given set S, the zeros-based aggregate function  3  ZerosAggr(mpk,S) is invoked to calculate the aggregation value G S  of set S. And then, a random secret k is introduced to construct the value G S &#39;s commitment 
     
       
         
           
             
               G 
               s 
             
             = 
             
               
                 g 
                 
                   
                     
                       f 
                       s 
                     
                      
                     
                       ( 
                       γ 
                       ) 
                     
                   
                    
                   
                       
                   
                    
                   k 
                 
               
               = 
               
                 g 
                 
                   k 
                    
                   
                       
                   
                    
                   
                     
                       γΠ 
                       
                         
                           e 
                           i 
                         
                         ∈ 
                         S 
                       
                     
                      
                     
                       ( 
                       
                         γ 
                         + 
                         
                           v 
                           i 
                         
                       
                       ) 
                     
                   
                 
               
             
           
         
       
     
     and g γk . 
     For a given element e satisfying e∉S, let S + =S∪{e}  6  according to the security definition of poles-based aggregation function. 
     The poles-based aggregation function  1  PolesAggr(mpk,S+) is invoked to calculate the aggregation value 
     
       
         
           
             
               
                 
                   
                     H 
                     
                       S 
                       + 
                     
                   
                   = 
                   
                     
                       PolesAggr 
                        
                       
                         ( 
                         
                           mpk 
                           , 
                           
                             S 
                             + 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         H 
                         
                           S 
                           ⋃ 
                           
                             { 
                             e 
                             } 
                           
                         
                       
                       = 
                       
                         
                           h 
                           
                             g 
                             
                               
                                 S 
                                 + 
                               
                                
                               
                                 ( 
                                 γ 
                                 ) 
                               
                             
                           
                         
                         = 
                         
                           
                             h 
                             
                               
                                 
                                   g 
                                   S 
                                 
                                  
                                 
                                   ( 
                                   γ 
                                   ) 
                                 
                               
                               · 
                               
                                 1 
                                 
                                   γ 
                                   + 
                                   v 
                                 
                               
                             
                           
                           = 
                           
                             h 
                             
                               
                                 1 
                                 
                                   
                                     ∏ 
                                     
                                       k 
                                       = 
                                       s 
                                     
                                     r 
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     ( 
                                     
                                       γ 
                                       + 
                                       
                                         v 
                                         k 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               · 
                               
                                 1 
                                 
                                   
                                       
                                   
                                   
                                     ( 
                                     
                                       γ 
                                       + 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
     Where, v=hash(e) and v i =hash(e i ). 
     The following secret value is recovered  4  from 
     
       
         
           
             
               
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           G 
                           s 
                         
                         , 
                         
                           H 
                           
                             S 
                             + 
                           
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       e 
                        
                       
                         ( 
                         
                           
                             g 
                             
                               
                                 
                                   f 
                                   S 
                                 
                                  
                                 
                                   ( 
                                   γ 
                                   ) 
                                 
                               
                                
                               k 
                             
                           
                           , 
                           
                             h 
                             
                               
                                 g 
                                 
                                   S 
                                   + 
                                 
                               
                                
                               
                                 ( 
                                 γ 
                                 ) 
                               
                             
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         e 
                         ( 
                         
                           
                             g 
                             
                               k 
                                
                               
                                   
                               
                                
                               γ 
                                
                               
                                 
                                   ∏ 
                                   
                                     q 
                                     ∈ 
                                     S 
                                   
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   ( 
                                   
                                     γ 
                                     + 
                                     
                                       v 
                                       i 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                           , 
                           
                             h 
                             
                               
                                 1 
                                 
                                   
                                     ∏ 
                                     
                                       
                                         e 
                                         i 
                                       
                                       ∈ 
                                       s 
                                     
                                     
                                         
                                     
                                   
                                    
                                   
                                       
                                   
                                    
                                   
                                     ( 
                                     
                                       γ 
                                       + 
                                       
                                         v 
                                         i 
                                       
                                     
                                     ) 
                                   
                                 
                               
                               · 
                               
                                 1 
                                 
                                   
                                       
                                   
                                   
                                     ( 
                                     
                                       γ 
                                       + 
                                       v 
                                     
                                     ) 
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                       = 
                       
                         
                           e 
                            
                           
                             ( 
                             
                               g 
                               , 
                               h 
                             
                             ) 
                           
                         
                         
                           
                             γ 
                             · 
                             k 
                           
                           
                             γ 
                             + 
                             v 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
     The above value is verified  5  by using 
     
       
         
           
             
               
                 
                   e 
                    
                   
                     ( 
                     
                       g 
                       , 
                       h 
                     
                     ) 
                   
                 
                 
                   
                     γ 
                      
                     
                         
                     
                      
                     k 
                   
                   
                     γ 
                     + 
                     v 
                   
                 
               
               = 
               
                 e 
                 ( 
                 
                   
                     g 
                     
                       γ 
                        
                       
                           
                       
                        
                       k 
                     
                   
                   , 
                   
                     h 
                     
                       1 
                       
                         
                             
                         
                         
                           γ 
                           + 
                           v 
                         
                       
                     
                   
                 
                 ) 
               
             
             , 
           
         
       
     
     where 
     
       
         
           
             h 
             
               1 
               
                 
                     
                 
                 
                   γ 
                   + 
                   v 
                 
               
             
           
         
       
     
     is directly derived from mpk. 
     Conversely, if e∈S, according to the security definition of poles-based aggregation function, it is computably difficult to recover the particular value 
     
       
         
           
             
               
                 e 
                  
                 
                   ( 
                   
                     g 
                     , 
                     h 
                   
                   ) 
                 
               
               
                 
                   γ 
                   · 
                   k 
                 
                 
                   γ 
                   + 
                   v 
                 
               
             
             , 
           
         
       
     
     therefore the verification  5  cannot be passed. 
     In summary, the above-mentioned method makes more efficient and precise for decision-making of negative membership. That is, it not only improves the efficiency of decision-making process, but also ensures the security and consistency of decision-making. 
     In this embodiment of the invention, for instance, it can take some similar cryptographic implementation to verify other relationships, such as the equation relationship between two sets, the inclusion relationship between a set and another set, or the disjoint relationship (also known as not totally inclusion) of two sets. 
     Another embodiment of the invention is described as follows: 
     The invention also provides a specific embodiment of cryptographic system of secure decision-making of membership. Considering that the corresponding relation between the construction of this system and the above-mentioned embodiment of decision-making method of membership, the embodiment of cryptographic system can execute the above-mentioned decision-making method of membership to achieve the purpose of the invention. Therefore, the explanation of implementation of cryptographic method of decision-making of membership also applied to the implementation of cryptographic system of decision-making of membership. We do not repeat to explain in the following specific embodiment of the invention. 
       FIG. 3  is a structural diagram of cryptographic system of decision of membership on set, which includes:
         Randomizing Unit  101 , which is configured to acquire any given set U={e 1 , . . . , e n } and transform each element e i  in the set U into a random point v i  in a cryptographic space;   Function-Generating Unit  102 , which is configured to acquire a given set S={e′ 1 , . . . , e′ m } ⊂ U, determine a random point v′ i  corresponding to each element e′ i  in the set S according to the random point v i , and construct a function ƒ S (x) according to the random point v′ i ;   Secret-determining Unit  103 , which is configured to introduce a random secret γ, determine a function ƒ S (γ) according to the function ƒ S (x), and determine a public parameter mpk according to the random secret γ; and   Cipher-Processing Unit  104 , which is configured to process the function ƒ S (γ) by using the public parameter mpk as an input to generate a cryptographic representation of the set S via a cryptographic method.       

     During the procedure described above, all elements in a given set might be represented as a random number or a random vector in the cryptographic space, which can be used in cryptographic decision-making of membership between the set and the set, the set and the element, or the element and the element. 
     In this embodiment, optionally, the cipher-processing unit comprising: 
     Processing module, which is configured to process the function ƒ S (γ) by using the public parameter mpk as an input to generate an aggregation function Aggregate(mpk,S) of the set S via cryptographic method, wherein the aggregation function is called a zeros-based aggregation function ZerosAggr(mpk,S) if the function ƒ S (x) is a zeros-based polynomial, or the aggregation function is called a poles-based aggregation function PolesAggr(mpk,S) if the function ƒ S (x) is a poles-based polynomial; and 
     Compressing module, which is configured to compress the set S into a constant-size random number or random vector R S  by means of the aggregation function, wherein R S  is an aggregated value outputted by the aggregation function Aggregate(mpk,S), and the size of R S  is independent of the number of elements in the set S. 
     According to one or more embodiments of the present invention, the constant-size random number or random vector R S  is used to generate the cryptographic decision-making device, includes: 
     The First Decision-Making Unit, which is configured to construct a cryptographic determination algorithm by means of the aggregation function for determining equality and inequality relationships between elements; and/or 
     The Second Decision-Making Unit, which is configured to construct a cryptographic determination algorithm by means of the aggregation function for determining positive and negative affiliation memberships between elements and the set; and/or 
     The Third Decision-Making Unit, which is configured to construct a cryptographic determination algorithm by means of the aggregation function for determining positive and negative containment relationships between the sets. 
     In the foregoing specification, optionally, the embodiments of the invention can construct the second decision device that realizes the cryptographic system of decision-making of membership. The following processes may perform the decision-making of membership: 
     the second determination unit is further configured to acquire an element e i , and when e i ∈S, set S=S\{e i }, then determine the aggregated value R S     −    by the zeros-based aggregation function ZerosAggr(mpk,S − ); and when e i ∉S, set S − =S\{e i }, then determine the aggregated value R S     −    by none of polynomial-time algorithms, the polynomial-time algorithms comprise ZerosAggr(mpk,S − ); and 
     the second determination unit is further configured to acquire an element e i , when e i ∉S, set S + =S∪{e i }, then determine the aggregated value R S     +    by the pole-based aggregation function PolesAggr(mpk,S + ); and when e i ∈S, set S + =S∪{e i }, then determine the aggregated value R S     +    by none of polynomial-time algorithms, the polynomial-time algorithms comprise PolesAggr(mpk,S + ). 
     The preferred embodiment of the present invention is described above. It should be pointed out that the general technical individual of technical field can also make some improvement and polishing, without departing from the principles of the present invention, which should be regarded as the scope of protection.