# Patent

## Title
Exclusive set system constructions including, but not limited to, applications to broadcast encryption and certificate revocation

## Abstract

An (n,k,r,t)-exclusive set system over a set U includes elements Sƒ each of corresponds to a polynomial ƒ(u) in one or more coordinates of uεU. The polynomial is zero on U\Sƒ but is not zero on Sƒ. In some embodiments, an asymptotically low key complexity k is provided.

## Background
CROSS REFERENCE TO RELATED APPLICATIONS
The present application claims priority of U.S. provisional application No. 60/732,328, filed Oct. 31, 2005, incorporated herein by reference.


BACKGROUND OF THE INVENTION
This invention relates to data processing, and in particular to exclusive set systems such as can be used for cryptographic and other applications.
EXCLUSIVE SET SYSTEMS. In [8] Kumar and Russell formalized the notion of an exclusive set system, which is a family of sets for which every large subset of the universe can be written as the union of some collection of subsets from the family. More formally,
Definition 1. A family of subsets CC={S1, . . . , Sk} over [n] is (n,k,r,t)-exclusive if for any subset R⊂[n] with |R|≦r, we can write




  
    
      [
      n
      ]
    
    ⁢
    \
    ⁢
    R
  
  =
  
    
      ⋃
      
        j
        =
        1
      
      t
    
    ⁢
    
      S
      
        i
        j
      
    
  




for some 1≦ij≦k. Indices ij do not have to be distinct, so R can be the union of less than t distinct sets





  S
  
    i
    j
  




Here [n] denotes the set of positive integers {1, . . . , n}. Clearly, [n] can be replaced with any set U of n entities.

The family




  {
  
    
      S
      
        j
        1
      
    
    ,
    ...
    ⁢
    
      
    
    ,
    
      S
      
        j
        t
      
    
  
  }




is called a cover for the set [n]\R or a complement cover for R, and is sometimes denoted CR herein.

In the example of FIG. 1, the elements of [n] are shown as crosses in a two-dimensional plane. Each element iε[n] is marked with reference numeral 104.i. The set R consists of element 104.1, 104.2, 104.3 (r≧3). The set [n]\R is covered by three sets S1, S2, S3 (t≧3 and k≧3), where S1={4,5,6}, S2={6,7}, and S3={8}.
Determining the exact tradeoff between n,k,r, and t is a fundamental combinatorial problem with significant applications in computer science.
APPLICATION TO BROADCAST ENCRYPTION. In a broadcast encryption scheme, there is a server 210 (FIG. 2A) sending a broadcast to n clients 104.1-104.n. The broadcast content B is encrypted with some symmetric encryption algorithm 1 (as shown at 220) using a secret key bk. The encrypted content E1bk(B) is broadcast to the clients 104. Each client 104.i possesses an encryption key ki for a symmetric encryption algorithm 2. In this example, the set R of revoked clients consists of terminals {1, . . . , r}, i.e. {104.1, . . . , 104.r}. The server encrypts the key bk with the algorithm 2 (as shown at 230) n-r times using the respective keys kr+1, . . . , kn of the non-revoked clients. The resulting encryptions are shown as




  
    E
    ⁢
    
      
    
    ⁢
    
      2
      
        k
        
          r
          +
          1
        
      
    
    ⁢
    
      (
      bk
      )
    
  
  ,
  ...
  ⁢
  
    
  
  ,
  
    E
    ⁢
    
      
    
    ⁢
    
      2
      
        k
        n
      
    
    ⁢
    
      
        (
        bk
        )
      
      .
    
  




The server broadcasts these encryptions.

Each client 104 (FIG. 2B) receives these broadcasts. The non-revoked clients 104.r+1, . . . , 104.n each execute a decryption algorithm 2 (as shown at 240) corresponding to the encryption algorithm 2. At step 240, each of these clients i (i=r+1, . . . , n) uses the corresponding key ki and the encryption




  E
  ⁢
  
    
  
  ⁢
  
    2
    
      k
      i
    
  
  ⁢
  
    (
    bk
    )
  




to recover the key bk. The key bk and the broadcast encryption E1bk(B) are then provided as inputs to a decryption algorithm 1 corresponding to the encryption algorithm 1, as shown at 250. The output is the broadcast content B.

The revoked clients 104.1, . . . , 104.r cannot recover the broadcast content B because they do not receive the encryptions of the broadcast key bk with the keys k1, . . . , kr. 
In this example, each broadcast includes n-r encryptions at step 230. The number of encryptions can be reduced to at most t if each set Si is associated with an encryption key




  k
  
    S
    i
  




provided to all clients 104 which are members of the set Si. See FIG. 3. The server determines the set cover





  {
  
    
      
        
          S
          
            i
            j
          
        
        |
        j
      
      =
      1
    
    ,
    ...
    ⁢
    
      
    
    ,
    t
  
  }




for the set [n]\R. At step 230 (FIG. 4A), the server 210 encrypts the key bk using the corresponding keys





  k
  
    S
    
      i
      j
    
  




. Since only the non-revoked clients each have one or more of the keys





  
    k
    
      S
      
        i
        j
      
    
  
  ,




only these clients will be able to recover the key bk at step 240 (FIG. 4B) and recover the broadcast content B. At step 240, the client can use any key





  k
  
    S
    
      i
      j
    
  




for the set





  S
  
    i
    j
  




to which the client belongs. Any coalition of the revoked members (revoked clients) learns no information from the broadcast even if they collude.

Since each subset of t keys can correspond to at most one set [n]\R, we need




  
    
      (
      
        
          
            k
          
        
        
          
            t
          
        
      
      )
    
    ≥
    
      
        ∑
        
          i
          =
          0
        
        r
      
      ⁢
      
        (
        
          
            
              n
            
          
          
            
              i
            
          
        
        )
      
    
    ≥
    
      (
      
        
          
            n
          
        
        
          
            r
          
        
      
      )
    
  
  ,




or equivalently,





  k
  =
  
    
      Ω
      ⁡
      
        (
        
          
            t
            ⁡
            
              (
              
                
                  
                    n
                  
                
                
                  
                    r
                  
                
              
              )
            
          
          
            r
            /
            t
          
        
        )
      
    
    .
  




(The lower bound we use here is the same as that given by Lemma 11 in [11], and is unknown to be tight for general n,r, and t. We note that the bounds in that paper are generally not tight.) For instance, their Theorem 12 can be improved by using the sunflower lemma with relaxed disjointness (p. 82 in [6]) instead of the sunflower lemma. This general technique of using exclusive set systems for broadcast encryption in known in the art as the subset-cover framework.

APPLICATION TO CERTIFICATE REVOCATION. In FIG. 5, elements 104 are digital certificates used in public key infrastructures (PKI) to facilitate secure use and management of public keys in a networked computer environment. Each certificate 104 contains a user's public key PK and the user's name and may also contain the user's email address or addresses, the certificate's serial number SN (generated by a certificate authority 610 (FIG. 6A) to simplify the certificate management), the certificate issue date D1, the expiration date D2, an identification of algorithms to be used with the public and secret keys, an identification of the CA 610, validity proof data 104-V (described below) and possibly other data. The data mentioned above is shown at 104D. Certificate 104 also contains CA's signature 104-SigCA on the data 104D. CA 610 sends the certificate 104 to the user's (key owner's) computer system (not shown). Either the owner or the CA 610 can distribute the certificate to other parties to inform them of the user's public key PK. Such parties can verify the CA's signature 104-SigCA with the CA's public key to ascertain that the certificate's public key PK does indeed belong to the person whose name and email address are provided in the certificate.
If a certificate 104 is revoked, other parties must be prevented from using the certificate. Validity proof data 104-V is used to ascertain that the certificate is valid. In existing certificate revocation schemes known in the art, such as the one of Micali [13,14,15] and subsequently by Aiello et al., [1], in each period m (e.g. each day), certificate authority 610 issues a validation proof cm for each non-revoked certificate in the public-key infrastructure. CA's clients 620 (FIG. 6B) provide the validation proof cm for the certificate with the certificate's validity data 104-V to a verification algorithm, as shown at 630. The verification algorithm's output indicates whether or not the certificate is valid in the period m.
In the original work of Micali, one validation proof was issued per non-revoked certificate. Thus the overall communication complexity of the system was proportional to n-r where n is the total number of users and r is the number of non-revoked certificates. Aiello et al. observed that instead of having one validity proof apply to one individual user, one could instead group users together into various subsets Si as in the definition 1. In FIGS. 3 and 6A, each subset Si is associated with cryptographic information ksi from which the CA can generate a validation proof cm(Si) for the period m. This single validation proof proves the validity of all the certificates in the subset Si. For each period m, the CA determines a cover { Sij } for the set of non-revoked certificates, computes the validation proofs cm(Sij ), and distributes the validation proofs to the clients 620 (which may include the certificate owners and/or other parties).
Since each subset Si must be provided with a validity proof cm(Si), the number of total validity proofs may increase, but the communication complexity for transmitting the proofs is now proportional to the t parameter in the underlying exclusive-set system, and generally speaking, t<n−r, so the overall communication needed for this approach is less than that needed for the original Micali approach.
SUMMARY
This section summarizes some features of the invention. The invention is not limited to these features, as defined by the appended claims.
Some embodiments of the present invention provide an actual design of the exclusive-set systems to be used. By designing good set systems, one can achieve near optimal tradeoffs among the relevant parameters of interest. In the foregoing we illustrate the methods and apparatus of the present invention by means of the application to the broadcast encryption problem. It will be readily apparent to one skilled in the art that they can just as easily be used in other settings, such as the one for certificate revocation mentioned above.
Kumar and Russell [8] use the probabilistic method to show that for sufficiently large n and any r≦t, there exists an exclusive set system with size O(t3(nt)r/tln n). The main drawback of their scheme is that they do not give an efficient algorithm for generating




  
    S
    
      i
      1
    
  
  ,
  ...
  ⁢
  
    
  
  ,
  
    S
    
      i
      t
    
  




with





  
    
      [
      n
      ]
    
    ⁢
    \
    ⁢
    R
  
  =
  
    
      S
      
        i
        1
      
    
    ⁢
    U
    ⁢
    
      
    
    ⁢
    ...
    ⁢
    
      
    
    ⁢
    U
    ⁢
    
      
    
    ⁢
    
      
        S
        
          i
          t
        
      
      .
    
  




Moreover, their sets Si are chosen independently at random and so any algorithm for finding the Si can be used to solve Set-Cover, which is well-known to be NP-hard and ln n-inapproximable [3, 12]. Thus, with respect to known algorithms, in the worst-case broadcasting takes time exponential in n. Oftentimes, even time polynomial in n is considered too large, as r,t are usually much smaller. Hence, it is desirable to have algorithms running in time poly(r, t, log n). (If unspecified, logarithms are to the base 2.)

For some embodiments, the present invention provides an explicit construction of an (n,k,r,t)-exclusive set system with




  k
  =
  
    
      poly
      ⁡
      
        (
        
          r
          ,
          t
          ,
          
            log
            ⁢
            
              
            
            ⁢
            n
          
        
        )
      
    
    ⁢
    
      
        (
        
          
            
              n
            
          
          
            
              r
            
          
        
        )
      
      
        r
        /
        t
      
    
  




keys. Unlike previous constructions, the constructions presented in this disclosure work for any values of r,t and sufficiently large n. Moreover, the disclosure provides a deterministic poly(r, t, log n) algorithm, which given R, finds





  
    S
    
      i
      1
    
  
  ,
  ...
  ⁢
  
    
  
  ,
  
    S
    
      i
      t
    
  




with





  
    
      [
      n
      ]
    
    ⁢
    \
    ⁢
    R
  
  =
  
    
      S
      
        i
        1
      
    
    ⋃
    ...
    ⋃
    
      
        S
        
          i
          t
        
      
      .
    
  




Thus, broadcasting is extremely efficient. For the case when r and t are slow-growing functions of n, as is the case in broadcast encryption, we can optimize our storage complexity to





  
    k
    =
    
      O
      ⁡
      
        (
        
          
            rt
            ⁡
            
              (
              
                
                  
                    n
                  
                
                
                  
                    r
                  
                
              
              )
            
          
          
            r
            /
            t
          
        
        )
      
    
  
  ,




which is tight up to a factor of r. This improves the complexity of [8].

Some embodiments provide a computer-implemented method for generating data representing an exclusive set system for a set U (e.g., U=[n]) of entities such that each element of the exclusive set system is associated with cryptographic data. The method comprises obtaining one or more coordinate systems for the set U, wherein each coordinate system associates each entity in U with a plurality of coordinates; determining functions ƒ(u) each of which is defined on the set U, each function being a polynomial in one or more of the coordinates of u in at least one of the coordinate systems; determining, for each said functions ƒ, a corresponding subset Sƒ⊂U such that ƒ is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein said exclusive set system comprises the subsets Sƒ, and wherein each subset Sƒ is associated with cryptographic data.
Some embodiments provide a computer-implemented method for selecting a family of subsets of a set U such that each of said subsets is associated with cryptographic data, wherein the union of said subsets includes a predefined set of valid entities and excludes a predefined set R of invalid entities. The method comprises determining functions ƒ(u) each of which is defined on the set U, wherein each entity uεU is associated with ƒ, a plurality of coordinates in each of one or more coordinate systems, and each function ƒ(u) is a polynomial in one or more of the coordinates of u in at least one of the coordinate systems, wherein all of said functions are equal to a predefined value on any entity u in R, and wherein for each valid entity u, at least one of said functions is not equal to the predefined value on the valid entity; determining, for each said functions ƒ, a corresponding subset Sƒ of the valid entities on which the function is not equal to the predefined value, wherein said family of subsets comprises the subsets Sƒ, and wherein each subset Sƒ is associated with cryptographic data
Some embodiments provide a computer-implemented method for generating data representing an (n,k,r,t)-exclusive set system for a set U of entities such that each element of the exclusive set system is associated with cryptographic data, wherein n=|U|, and wherein k, r, and t are predefined positive integers. The method comprises obtaining one or more coordinate systems for the set U, wherein each coordinate system associates each entity in U with a plurality of coordinates; and determining one or more subsets S⊂U in the exclusive set system, each one of said subsets S is a subset Sƒ corresponding to a function ƒ(u) such that ƒ(u) is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein each function ƒ(u) is a polynomial in one or more of the coordinates of u in at least one of the coordinate systems, the degree of ƒ(u) being at most r, wherein each subset Sƒ is associated with cryptographic data. In some embodiments, at least one of the functions ƒ is a polynomial of degree r.
Some embodiments provide a computer-implemented method for selecting a cover from an (n,k,r,t)-exclusive set system, the system being defined for a set U of entities such that each element of the exclusive set system is associated with cryptographic data, wherein n=|U|, and wherein k, r, and t are predefined positive integers, the cover being for a set U\R where R⊂U and |R|≦r, the cover comprising at most t elements. The method comprises selecting, for the cover, one or more elements S from the exclusive set system, each one of said elements S is a subset Sƒ corresponding to a function ƒ(u) such that ƒ(u) is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein each function ƒ(u) is a polynomial in one or more of coordinates of u in at least one coordinate system, the degree of ƒ(u) being at most r, wherein each subset Sƒ is associated with cryptographic data.
Some embodiments provide a computer-implemented method for generating data representing an exclusive set system CC(U) for a set U of entities. The method comprises generating an exclusive set system CC(UB) for each of a plurality of subsets {UB} of U; obtaining the exclusive set system for U as a union of the systems CC(UB); wherein each element of the system CC(U) is associated with cryptographic data.
Some embodiments provide a computer-implemented method for selecting a family of subsets of a set U such that each of said subsets is associated with cryptographic information, wherein the union of said subsets includes a predefined set of valid entities and excludes a predefined set R of invalid entities. The method comprises determining a plurality of disjoint subsets {Uj} of the set U such that the union of the subsets Uj equals U, wherein each subset Uj is associated with an exclusive set system CC(Uj) with the maximum revoked set size rj≧|Rj|, where Rj=R∩Uj; for each subset Uj, selecting a cover for Uj\Rj from CC(Uj), wherein the union of said covers provides said family of subsets.
In some embodiments, each entity represents a user operable to receive encrypted information over a network, and each element S of the exclusive set system is associated with cryptographic data which includes a decryption key DKS provided to the users that are members of the element S, the key being provided for decrypting said information. In some embodiments, each entity represents a cryptographic digital certificate, and each element S of the exclusive set system is associated with said cryptographic data which includes validity data VDS certifying that the subset S contains only valid certificates or only invalid certificates.
The invention includes computer systems adapted to perform the methods described above; data carriers with computer data representing exclusive set systems described above; and data carriers with computer instructions for computers to perform the methods described above.
Other features of the invention are described below. The invention is defined by the appended claims.



BRIEF DESCRIPTION OF THE DRAWINGS
The subsequent description of the preferred embodiments of the present invention refers to the attached drawings, wherein:
FIG. 1 illustrates a prior art exclusive set system.
FIG. 2A illustrates a prior art server performing a broadcast encrypted for each non-revoked client.
FIG. 2B illustrates prior art clients receiving a broadcast performed as in FIG. 2A.
FIG. 3 illustrates a decryption key assigned to a set of clients.
FIG. 4A illustrates a prior art server performing a broadcast encrypted once for each of sets of non-revoked client.
FIG. 4B illustrates prior art clients receiving a broadcast performed as in FIG. 4A.
FIG. 5 illustrates a prior art digital certificate.
FIG. 6A illustrates a prior art certificate authority (CA) transmitting proofs of certificate validity.
FIG. 6B illustrates a prior art client verifying a proof of certificate validity.
FIG. 7 illustrates server and client computer systems and an exclusive set system generation method according to some embodiments of the present invention.
FIG. 8 is a flowchart for constructing a set cover according to some embodiments of the present invention.
FIG. 9 illustrates a polynomial scheme used for exclusive set systems according to some embodiments of the present invention.
FIG. 10 is a flowchart of an exclusive set system generation method according to some embodiments of the present invention.
FIG. 11 is a flowchart for constructing a set cover according to some embodiments of the present invention.
FIGS. 12 and 13 illustrate data structures according to some embodiments of the present invention.
FIG. 14 is a flowchart for constructing a set cover according to some embodiments of the present invention.
FIGS. 15 and 16 illustrate data structures according to some embodiments of the present invention.
FIGS. 17 and 18 are flowcharts of methods used to construct set covers according to some embodiments of the present invention.
FIGS. 19 and 20 illustrate data structures according to some embodiments of the present invention.
FIG. 21 is a flowchart of an exclusive set system generation method according to some embodiments of the present invention.
FIG. 22 is a flowchart for constructing a set cover according to some embodiments of the present invention.
FIG. 23 illustrates data structures according to some embodiments of the present invention.
FIG. 24 is a flowchart of an exclusive set system generation method according to some embodiments of the present invention.
FIG. 25 is a flowchart for constructing a set cover according to some embodiments of the present invention.



DESCRIPTION OF SOME EMBODIMENTS
The present invention will be understood more fully from the detailed description given below and from the accompanying drawings of various embodiments of the invention, which, however, should not be taken to limit the invention to the specific embodiments, but are for explanation and understanding only.
In the following description, numerous details are set forth to provide a more thorough explanation of the present invention. It will be apparent, however, to one skilled in the art, that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form, rather than in detail, in order to avoid obscuring the present invention.
Some portions of the detailed descriptions that follow are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is a method for doing something. The method may require physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the following discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.
The present invention also relates to apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMS, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of media suitable for storing computer instructions, and each coupled to a computer system bus.
The present invention is not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the invention as described herein. Computer programs can be stored on a data carrier such as a computer-readable medium. Computer programs can also be carried by data carrier signals over networks. A computer-readable medium includes any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computer). For example, a machine-readable medium includes read only memory (“ROM”); random access memory (“RAM”); magnetic disk storage media; optical storage media; flash memory devices; electrical, optical, acoustical or other form of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.); etc.
1 Preliminaries
COMPUTATIONAL ASSUMPTIONS. It is known to one of ordinary skill in the cryptographic arts that the security of many cryptographic inventions relies upon making certain computational intractability assumptions; for example, one may try to prove that a cryptosystem is secure so long as it is difficult to decompose a specific number into its prime factors efficiently. The term “computational” is often used in the art to identify this class of cryptographic inventions. The present invention provides a computational scheme for password authenticated key exchange. The term “information theoretic” or “unconditional” is often used in the art in conjunction with schemes that are mathematically seen to meet a specific meaningful security definition without making any type of assumption.
While it is generally preferable from a pure security perspective not to have any computational assumptions whatsoever, there are instances of problems that cannot be solved without making such an assumption (the present invention serves as such an example). Further, it is generally known by those skilled in the art that cryptographic methods can sometimes be made more efficient by incorporating computational assumptions.
It also worth noting that often times one assumption implies another. That is, if one of the assumptions were actually true, then another assumption would be seen to be true by a mathematically logical argument. Typically the means used by those skilled in the art to show such an implication, is a transformation (often known in the art as a reduction) that converts a mechanism for violating the second assumption to a mechanism for violating the first assumption. In such cases, the first assumption is called “stronger” or the second “weaker.” In general, weaker assumptions are preferable.
The issue of computational versus information-theoretic is orthogonal to the methods and apparatus of the present invention. More specifically, the applications of exclusive-set systems can be practiced using either computational or information-theoretic cryptographic mechanisms.
EXISTENCE ARGUMENTS. It is known to one of ordinary skill in the mathematical arts that determining the existence of a mathematical object satisfying certain properties is not equivalent to actually demonstrating how one can find the object efficiently. In particular, it is sometimes possible to prove that objects with certain properties exist without there being a clear efficient procedure for actually constructing (or finding) tangible instances of such objects. In previous work, Kumar and Russell [8] showed that exclusive set systems satisfying certain tradeoffs existed. They essentially did so by showing that within a very large space of possible options, at least one of them would work. However, this space is so large, that one cannot exhaustively search it to find the actual instance. Furthermore, it appears quite unlikely that a more efficient procedure exists. Finally, even if one were to find the appropriate set systems, it is not clear (in fact, it is even unlikely) that they can incorporated into broadcast encryption schemes in a practical manner. The invention covered by the present disclosure gives the first explicit constructions of such set systems. Furthermore, our systems can be efficiently incorporated into existing broadcast encryption systems.
RANDOMIZED ALGORITHMS. It is known to one of ordinary skill in the data processing arts that many algorithms leverage a source of randomly generated bits to improve performance. One of the methods here does the same. Roughly speaking, using such bits can allow an algorithm to avoid any especially bad cases where it might not perform well. The upshot is that for any input choice (even one specifically crafted to make the algorithm perform bad), a large percentage of the time the algorithm will run efficiently (despite the malicious input choice).
USE OF MATHEMATICAL PROOFS WHEN DESCRIBING METHODS. The methods disclosed herein have their basis in fundamental mathematical concepts. The description of the methods herein prescribes that certain algorithmic steps be executed. However, the key questions of whether the steps can indeed be executed and whether executing them leads to a desired result (in this case an efficient exclusive set system meeting certain performance characteristics) must be addressed by means of a formal mathematical argument. Familiarity with these arguments is not necessary for implementing or practicing the methods disclosed herein. Such arguments merely enable one skilled in the art to determine that the procedures are indeed correct and lead to the desired outcome. Therefore, for completeness, we have included, where appropriate, these arguments in the present disclosure. However the arguments about the correctness, feasibility, and performance of the schemes themselves should be decoupled from the actual methods and apparatus provided in this disclosure.
Previous Solutions
The foregoing reviews common techniques in the art for constructions of exclusive set systems.
Motivated by cryptographic applications, there have been many other constructions of exclusive set systems. Gafni, Staddon, and Y in [5] provide an (n,(r log n/log r)2,r,(r log n/log r)2)-exclusive set system. Also, Lotspiech, Naor, and Naor [9] give (n,2n,r,r log n) and (n,n log n,r,r)-exclusive set systems based on binary trees. Using algebraic-geometric codes, Kumar, Rajagopalan, and Sahai [7] construct explicit (n,r3 log n/log r,r,r3 log n/log r)-exclusive set systems. The main disadvantage of these schemes is that once n and r are chosen, both the broadcast size t and the number of keys k are determined. However, as pointed out in [8], it is clear that given n,r and t, for sufficiently large k there exists an (n,k,r,t)-exclusive set system. In contrast, some embodiments of the present invention can support arbitrary n,r, and t. Thus, in some sense, our construction is believed to be the first general result for information-theoretic broadcast encryption.
The foregoing description will focus primarily on the construction of (n,k,r,t)-exclusive set systems for different settings of the relevant parameters n,k,r,t . Once specified, these set systems can then be incorporated in a straightforward way in any apparatus for broadcast encryption in the subset-cover framework (or in any apparatus for multi-certificate validation as discussed in the work of Aiello et al. [1]).
TECHNIQUES. In some embodiments, we first construct exclusive set systems for the case when r and t are much smaller than n. Then, exclusive set systems for general n,r, and t are constructed with a divide-and-conquer approach: roughly speaking, we partition the universe [n] into blocks and use our smaller set systems independently on each block.
The construction for small r,t is algebraic in nature. Namely, we associate [n] with points in affine space. Sets then correspond to functions ƒ on this space. More precisely, a set corresponds to the points on which ƒ does not vanish. An exclusive set system then corresponds to a set of functions. A cover of the set of privileged users corresponds to a set of t functions (say, ƒ0, . . . , ƒt−1). Then a point u belongs to the broadcast (i.e. is a privileged user) provided it does not vanish on all the t functions ƒ0, . . . , ƒt−1 in the broadcast. Algebraically, this means that u is not in the variety of ƒ0, . . . , ƒt−1. The main problem is to find a small explicit collection of functions ƒ for which every set R of at most r points is the variety of some t functions ƒ0, . . . , ƒt−1 in the collection. To keep the collection small, we use multivariate polynomials in a novel way, together with various other algebraic tools known by those well versed in the art, including certain expanders and MDS codes (Maximum Distance Separable codes).
2 Constructing Exclusive Set Systems Using Polynomials
Some embodiments of the system of the present invention are run on a server computer system 610 (FIG. 7) and a client computer system 620 which communicate with signals transmitted over a network 624. Systems 610 and 620 can be replaced with any systems, not necessarily client and server. Server 610 contains one or more computer processors 730 executing computer instructions. Server 610 also contains computer storage 734 (semiconductor memory, magnetic or optical disks, and/or other types of storage) to store instructions and data. Client 620 contains one or more processors 740 to execute computer instructions, and storage 744 to store instructions and data. The client and the server may also contain other equipment as needed.
We start by describing a simplified method under a choice for the parameters wherein:

rαt2≦n1/t  (1)

for a constant α>2 to be specified. The reason for this choice will become clear in the foregoing description.

Let

p≧n1/t  (2)

be prime, and let F=Fp. For xε[n], we identify x with a point (x0, . . . , xt−1)εFt, i.e. we define an injective mapping:

A(x)=(x0, . . . , xt−1)εFt  (3)

Since the points of [n] are thus identified with points in Ft, we will sometimes speak of x as a point in Ft, and write x=(x0, . . . , xt−1).

Our method works by choosing a collection CF of polynomials in x0, . . . , xt−1, which can be thought of as polynomials in the ring F[X0, . . . , Xt−1] which are evaluated on (X0, . . . , Xt−1)=(x0, . . . , xt−1), where X0, . . . , Xt−1 are formal variables. If ƒ(X0, . . . , Xt−1) is such a polynomial, then we will define ƒ(x) as:

ƒ(x)=ƒ(x0, . . . , xt−1)  (4)

At set-up step 750, for each ƒεCF, the server 610 determines a set Sƒ consisting of all the points u in Ft for which ƒ(u)≠0. At step 760, for each set Sƒ, the server generates the corresponding data kSƒ (see FIG. 3). At step 770, for each client x (i.e. each client 620), the server determines all the sets Sƒ containing x, and sends the corresponding data




  k
  
    S
    f
  




to the client over the network 624. In some embodiments, these transmission are done via secure channels, using prior art techniques.

The broadcasts are performed as in FIGS. 4A, 4B. FIG. 7 illustrates how the server 610 determines the set cover




  {
  
    S
    
      i
      j
    
  
  }




of t sets or fewer. Given the set R⊂[n] with |R|≦r, the server finds at step 810 a set SF(R) of at most t functions ƒ0, . . . , ƒt−1 εCF for which Var(ƒ0, . . . , ƒt−1)=R, where Var(ƒ0, . . . , ƒt−1) denotes the common zeros of ƒ0, . . . , ƒt−1, that is, the variety of these functions. By construction, any u ε[n]\R occurs in some set, while any uεR does not. At step 820, the server determines





  k
  
    S
    f
  




for each function ƒ in SF(R), and performs the broadcast as in FIG. 4A. Each non-revoked client 620 decrypts the broadcast as in FIG. 4B.

The problem is therefore to find an explicit polynomial collection CF with the properties (1). Consider first the following collection CF1:




  
    
      
        
          
            CF
            1
          
          =
          
            {
            
              
                
                  
                    ∏
                    
                      j
                      =
                      1
                    
                    
                      r
                      ′
                    
                  
                  ⁢
                  
                    (
                    
                      
                        X
                        0
                      
                      -
                      
                        i
                        j
                      
                    
                    )
                  
                
                |
                
                  0
                  ≤
                  
                    r
                    ′
                  
                  ≤
                  r
                
              
              ,
              
                distinct
                ⁢
                
                  
                
                ⁢
                
                  i
                  1
                
              
              ,
              ...
              ⁢
              
                
              
              ,
              
                
                  i
                  
                    r
                    ′
                  
                
                ∈
                F
              
            
            }
          
        
        ⁢
        
          

        
        ⁢
        
          U
          ⁢
          
            
              {
              
                
                  
                    
                      g
                      ⁡
                      
                        (
                        
                          X
                          
                            i
                            -
                            1
                          
                        
                        )
                      
                    
                    -
                    
                      X
                      i
                    
                  
                  |
                  
                    1
                    ≤
                    i
                    ≤
                    
                      t
                      -
                      1
                    
                  
                
                ,
                
                  
                    deg
                    ⁡
                    
                      (
                      g
                      )
                    
                  
                  ≤
                  
                    r
                    -
                    1
                  
                
              
              }
            
            .
          
        
      
    
    
      
        (
        5
        )
      
    
  




By convention herein, the product of zero terms is equal to 1, so





  
    
      ∏
      
        j
        =
        1
      
      0
    
    ⁢
    
      (
      
        
          X
          0
        
        -
        
          i
          j
        
      
      )
    
  
  =
  1




Hence, CF1 includes the constant polynomial ƒ≡1, i.e. CC includes the set [n].

It should be apparent to one versed in the art that the number of polynomials of the form




  
    
      
        
          
            ∏
            
              j
              =
              1
            
            
              r
              ′
            
          
          ⁢
          
            
              (
              
                
                  X
                  0
                
                -
                
                  i
                  j
                
              
              )
            
            ⁢
            
              
            
            ⁢
            is
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  r
                
                ⁢
                
                  (
                  
                    
                      
                        p
                      
                    
                    
                      
                        i
                      
                    
                  
                  )
                
              
              ≤
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  r
                
                ⁢
                
                  p
                  i
                
              
            
            =
            
              
                
                  
                    p
                    
                      r
                      +
                      1
                    
                  
                  -
                  1
                
                
                  p
                  -
                  1
                
              
              ≤
              
                2
                ⁢
                
                  
                
                ⁢
                
                  p
                  r
                
              
            
          
          ,
        
      
    
    
      
        (
        6
        )
      
    
  




and the number of univariate polynomials g of degree at most r−1 is at most pr. Hence, the size of CF1 is O(tpr).

Intuition: Before proceeding, we provide some intuition behind the scheme. The idea we use is that polynomials of the form ƒi=g(Xi−1)−Xi, where i>0, implement a Boolean AND operation between adjacent coordinates. More particularly, denote the points of R as u(1), u(2), . . . (see FIG. 9). For each j≦|R|, denote

u(j)=(u0(j),u1(j), . . . , ut−1(j)).  (7)

Then each polynomial ƒi(i>0) imposes constraints on the adjacent coordinates ui−1,ui as defined by the set R. Each of these polynomials has degree at most r−1, so we can only use a given polynomial to implement r constraints. By chaining t of the polynomials together, we can exclude exactly those points in R, coordinate by coordinate. Finally, we need polynomials in u0 of the form





  
    
      f
      0
    
    ⁡
    
      (
      
        X
        0
      
      )
    
  
  =
  
    
      ∏
      
        j
        =
        1
      
      
        r
        ′
      
    
    ⁢
    
      (
      
        
          X
          0
        
        -
        
          i
          j
        
      
      )
    
  




for the base case, that is, to begin the chaining. These degree-r polynomials impose constraints on the u0 coordinates. One important observation is that by using polynomials to implement these local constraints, we greatly reduce the total number of sets k. The reason is that the mapping from sets of r constraints to polynomials is many-to-one.

We first consider the situation that for each i in [t], no two points in R have the same ith coordinate. (By convention herein, in (3), the ith coordinate is xi+1, i.e. the coordinates are numbered beginning with 1.) For example, for t=4, R may consist of three points (1,2,2,4), (2,1,4,3), and (5,6,7,8).
We now describe the formal method for finding the functions ƒ0, . . . , ƒt−1 of the set SF(R) (FIG. 7) in this circumstance. Since the coordinates have distinct values and |R|≦r, we can choose




  
    
      
        
          f
          0
        
        =
        
          
            
              f
              0
            
            ⁡
            
              (
              
                
                  X
                  0
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  X
                  
                    t
                    -
                    1
                  
                
              
              )
            
          
          =
          
            
              ∏
              
                u
                =
                
                  
                    (
                    
                      
                        u
                        0
                      
                      ,
                      ...
                      ,
                      
                        u
                        
                          t
                          -
                          1
                        
                      
                    
                    )
                  
                  ∈
                  R
                
              
            
            ⁢
            
              
            
            ⁢
            
              (
              
                
                  X
                  0
                
                -
                
                  u
                  0
                
              
              )
            
          
        
      
    
    
      
        (
        8
        )
      
    
  




Clearly, ƒ0εCF1 as defined by (5). Now, for each fixed i=1, . . . , t−1, we find a polynomial giεF[X] by interpolating from

gi(ui−1)=ui for each u=(u0, . . . , ut−1)εR  (9)

More particularly (see FIG. 9):





  
    
      
        
          
            g
            i
          
          ⁡
          
            (
            X
            )
          
        
        =
        
          
            ∑
            j
          
          ⁢
          
            
              u
              i
              
                (
                j
                )
              
            
            ⁢
            
              
                
                  ∏
                  
                    s
                    ≠
                    j
                  
                
                ⁢
                
                  (
                  
                    X
                    -
                    
                      u
                      
                        i
                        -
                        1
                      
                      
                        (
                        s
                        )
                      
                    
                  
                  )
                
              
              
                
                  ∏
                  
                    s
                    ≠
                    j
                  
                
                ⁢
                
                  (
                  
                    
                      u
                      
                        i
                        -
                        1
                      
                      
                        (
                        j
                        )
                      
                    
                    -
                    
                      u
                      
                        i
                        -
                        1
                      
                      
                        (
                        s
                        )
                      
                    
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




We set:

ƒi=gi(Xi−1)−Xi  (11)

Clearly, the functions ƒ0, . . . , ƒt−1 vanish on R. Conversely, for any point x∉R, at least one of these functions does not vanish on x. Indeed, if x=(x0, . . . , xt−1)εVar(ƒ0, . . . , ƒt−1), then ƒ0(x0)=0, so that x0=u0 for some u=(u0, . . . , ut−1)εR. For that u, since gi(ui−1)=ui, it inductively follows that ui=gi(ui−1)=gi(xi−1)=xi, showing that x=u, which would be a contradiction. Therefore, it follows that if x∉R, then x∉Var(ƒ0, . . . , ƒt−1), which is the desired condition.
The above construction serves as a proof of the following lemma.
Lemma 1. Suppose that for each i in [t], no two points in R have the same ith coordinate.
Then we can find (ƒ0, . . . , ƒt−1)εCF1 for which Var(ƒ0, . . . , ƒt−1)=R.
Clearly, each ƒ0 depends only on X0, and has degree r. Each ƒi(i>0) depends only on Xi−1, Xi, and is a sum of a polynomial gi(Xi−1) depending only on Xi−1 and having degree at most |R|−1 (or 0 if r=0), and a polynomial (−Xi) depending only on Xi and having degree |R|.
Let CC1 denote the collection of the sets Sƒ corresponding to the polynomials in CF1. Then the expressions (8) and (11) correspond, respectively, to the following elements of CC1:

Sƒ0=Sƒ0(R)={xε[n]|x0≠u0 for each uεR}

Sƒi=Sƒi(R)={xε[n]|gi(xi−1)≠xi},i=1, . . . , t−1  (12)

CC1 is thus the set of all subsets Sƒi(R)(i=0, . . . , t−1) for all R such that |R|≦r. In other words, CC1 consists of all the sets S of the form:

S={xε[n]|x0∉{i1, . . . , ir′}}, where 0≦r′≦r, i1, . . . , ir′εF, or

S={xε[n]|g(xi−1)≠xi}, where gεF[X], deg(g)≦r−1.  (13)

The construction of Lemma 1 can be extended to the case when points in R share coordinates. One idea is to carefully choose a small set of invertible linear transformations L1, . . . , Lm:

LB: Ft→Ft

so that for any set R, there is some index B for which the points of LBR do not share coordinates, i.e. each row of LBR consists of distinct entries. Here, LB is interpreted as a t×t matrix and R as a t×r matrix. Each such linear transformation L defines a new coordinate system, i.e. a new way to represent each element xεF with t elements of Ft:

Lx=(Lx0, . . . , Lxt−1)  (14)

where





  
    Lx
    i
  
  =
  
    
      ∑
      
        j
        =
        0
      
      
        t
        -
        1
      
    
    ⁢
    
      
        L
        ⁡
        
          (
          
            i
            ,
            j
          
          )
        
      
      ⁢
      
        
      
      ⁢
      
        x
        j
      
    
  




where xj are coordinates of x in coordinate system (3), and L(i,j) is the element in the ith row and jth column of L (the rows and columns are numbered starting with 0). Likewise, if X=(X0, . . . , Xt−1) is a vector of formal variables, then we define





  
    LX
    i
  
  =
  
    
      ∑
      
        j
        =
        0
      
      
        t
        -
        1
      
    
    ⁢
    
      
        L
        ⁡
        
          (
          
            i
            ,
            j
          
          )
        
      
      ⁢
      
        
      
      ⁢
      
        X
        j
      
    
  




Given an index B such that the points of LBR do not share coordinates, we can proceed as in (5)-(13) in this new coordinate system. In this case we say that LB is good for R. By analogy with (5), we define CF to be UB CFB, wherein for each B, CFB is given by





  
    
      
        
          
            CF
            B
          
          =
          
            {
            
              
                
                  
                    ∏
                    
                      j
                      =
                      1
                    
                    
                      r
                      ′
                    
                  
                  ⁢
                  
                    (
                    
                      
                        
                          L
                          B
                        
                        ⁢
                        
                          X
                          0
                        
                      
                      -
                      
                        i
                        j
                      
                    
                    )
                  
                
                |
                
                  0
                  ≤
                  
                    r
                    ′
                  
                  ≤
                  r
                
              
              ,
              
                distinct
                ⁢
                
                  
                
                ⁢
                
                  i
                  1
                
              
              ,
              ...
              ⁢
              
                
              
              ,
              
                
                  i
                  
                    r
                    ′
                  
                
                ∈
                F
              
            
            }
          
        
        ⁢
        
          

        
        ⁢
        
          U
          ⁢
          
            
              {
              
                
                  
                    
                      g
                      ⁡
                      
                        (
                        
                          
                            L
                            B
                          
                          ⁢
                          
                            X
                            
                              i
                              -
                              1
                            
                          
                        
                        )
                      
                    
                    -
                    
                      
                        L
                        B
                      
                      ⁢
                      
                        X
                        i
                      
                    
                  
                  |
                  
                    1
                    ≤
                    i
                    ≤
                    
                      t
                      -
                      1
                    
                  
                
                ,
                
                  g
                  ∈
                  
                    F
                    ⁡
                    
                      [
                      X
                      ]
                    
                  
                
                ,
                
                  
                    deg
                    ⁡
                    
                      (
                      g
                      )
                    
                  
                  ≤
                  
                    r
                    -
                    1
                  
                
              
              }
            
            .
          
        
      
    
    
      
        (
        15
        )
      
    
  




The size of CF is O(mtpr).

Step 810 (FIG. 8) is performed as follows. For a given R with |R|≦r, we find an index B for which LB is good for R, and then apply the previous scheme (expressions (5)-(13)) using the sets in CFB. The polynomial set SF(R) will consist of the polynomials ƒ0, . . . , ƒt−1 constructed as follows (see ((8)-(11)):




  
    
      
        
          f
          0
        
        =
        
          
            
              f
              
                0
                ,
                R
              
            
            ⁡
            
              (
              
                
                  X
                  0
                
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  X
                  
                    t
                    -
                    1
                  
                
              
              )
            
          
          =
          
            
              ∏
              
                u
                ∈
                R
              
            
            ⁢
            
              (
              
                
                  
                    L
                    B
                  
                  ⁢
                  
                    X
                    0
                  
                
                -
                
                  
                    L
                    B
                  
                  ⁢
                  
                    u
                    0
                  
                
              
              )
            
          
        
      
    
    
      
        (
        16
        )
      
    
  




For each fixed i=1, . . . , t−1, we find a polynomial gi,R=giεF[X] by interpolating from

gi(LBui−1)=LBui for each u=(u0, . . . , ut−1)εR  (17)

This is possible because all LBui−1 are distinct. More particularly, denote the points of R as u(1), u(2), . . . . For each j≦|R|, denote

u(j)=(u0(j),u1(j), . . . , ut−1(j)).  (18)

Then:





  
    
      
        
          
            g
            i
          
          ⁡
          
            (
            X
            )
          
        
        =
        
          
            ∑
            j
          
          ⁢
          
            
              L
              B
            
            ⁢
            
              u
              i
              
                (
                j
                )
              
            
            ⁢
            
              
                
                  ∏
                  
                    s
                    ≠
                    j
                  
                
                ⁢
                
                  (
                  
                    X
                    -
                    
                      
                        L
                        B
                      
                      ⁢
                      
                        u
                        
                          i
                          -
                          1
                        
                        
                          (
                          s
                          )
                        
                      
                    
                  
                  )
                
              
              
                
                  ∏
                  
                    s
                    ≠
                    j
                  
                
                ⁢
                
                  (
                  
                    
                      
                        L
                        B
                      
                      ⁢
                      
                        u
                        
                          i
                          -
                          1
                        
                        
                          (
                          j
                          )
                        
                      
                    
                    -
                    
                      
                        L
                        B
                      
                      ⁢
                      
                        u
                        
                          i
                          -
                          1
                        
                        
                          (
                          s
                          )
                        
                      
                    
                  
                  )
                
              
            
          
        
      
    
    
      
        (
        19
        )
      
    
  




We set:

ƒi=ƒi,R=gi(LBXi−1)−LBXi  (20)

For a given B, let CCB denote the collection of the all sets Sƒ corresponding to the polynomials ƒεCFB. Then the expressions (16) and (20) correspond, respectively, to the following elements of CCB⊂CC:

Sƒ0=Sƒ0(R)={xε[n]|LBx0≠LBu0 for each uεR}

Sƒi=Sƒi(R)={xε[n]|gi(LBxi−1)≠LBxi}, i=1, . . . , t−1  (21)

CCB is thus the set of all subsets Sƒi (R) (i=0, . . . , t−1) for all R such that |R|≦r. CC can be chosen as the collection of all the sets S of the form (22) below for all B:

S={xε[n]|LBx0∉{i1, . . . , ir′}}, where 0≦r′≦r, distinct i1, . . . , ir′εF, or

S={xε[n]|g(LBxi−1)≠xi}, where gεF[X], deg(g)≦r−1}.  (22)

Of note, at step 750, the server can use the expression (13) or (22) directly without considering polynomials. See FIG. 10. At step 750 of FIG. 10, the server receives the parameters n, r, t and defines an (n,k,r,t)-exclusive set system CC such that at least one element of CC is the set Sƒ corresponding to a polynomial ƒ(x)εF[X0, . . . , Xt−1] of degree exactly r. CC may contain other sets Sƒ corresponding to polynomials ƒ(x)εF[X0, . . . , Xt−1] of degree less than r. Also, the system CC may contain additional sets S not representable as sets on which a polynomial of a degree at most r is not zero. In any case, at step 760 (FIG. 10), the server defines the data kS for the sets SεCC. At step 770, for each client x, the server determines all the sets S containing x, and sends the corresponding data ks to the client over a secure channel.

During the broadcast (FIG. 11), the server accepts a description of the revoked set R and finds a cover for R. If R is not empty, the cover contains a set Sƒ corresponding to a polynomial ƒ(x)εF[X0, . . . , Xt−1] of degree |R|. The set R may have any cardinality up to r, where r can be any predefined number, possibly greater than 1.
To complete the specification, we specify an explicit set of m=rt linear transformations L1, . . . , Lm such that for all R⊂[n] of size at most r, there is some LB that is good for R.
To do so, we first define m=r2t disjoint blocks B1, . . . , Bm, wherein each of these blocks B consists of some elements b1, . . . , bt in F. See FIG. 12, where the elements of F are represented as circles in a two-dimensional plane. It should be recognized that such choice of blocks B is possible because, as seen from (1), (2), r2t2≦n1/t≦p. The blocks can be defined in an arbitrary way. For example, we can define B1={0, . . . , t−1}, B2={t, . . . , 2t−1}, and so on. Then define the linear transformations:




  
    
      
        
          L
          B
        
        =
        
          
            [
            
              
                
                  1
                
                
                  
                    b
                    0
                  
                
                
                  
                    b
                    0
                    2
                  
                
                
                  ...
                
                
                  
                    b
                    0
                    
                      t
                      -
                      1
                    
                  
                
              
              
                
                  1
                
                
                  
                    b
                    1
                  
                
                
                  
                    b
                    1
                    2
                  
                
                
                  ...
                
                
                  
                    b
                    1
                    
                      t
                      -
                      1
                    
                  
                
              
              
                
                  ...
                
                
                  ...
                
                
                  ...
                
                
                  ...
                
                
                  ...
                
              
              
                
                  1
                
                
                  
                    b
                    
                      t
                      -
                      1
                    
                  
                
                
                  
                    b
                    
                      t
                      -
                      1
                    
                    2
                  
                
                
                  ...
                
                
                  
                    b
                    
                      t
                      -
                      1
                    
                    
                      t
                      -
                      1
                    
                  
                
              
            
            ]
          
          .
        
      
    
    
      
        (
        23
        )
      
    
  




(We sometimes use the blocks B as indices instead of numbers 1 through m.) The LB are invertible. For each b,xεF, we define




  
    
      
        
          
            p
            x
          
          ⁡
          
            (
            b
            )
          
        
        =
        
          
            ∑
            
              i
              =
              0
            
            
              t
              -
              1
            
          
          ⁢
          
            
              x
              i
            
            ⁢
            
              
                b
                i
              
              .
            
          
        
      
    
    
      
        (
        24
        )
      
    
  




Then

LB(x)=(px(b0), . . . , px(bt−1))  (25)

Clearly, each px(b) is a polynomial of degree at most t−1 in b and is linear in each of x0, . . . , xt−1.

As two distinct polynomials of degree t−1 can agree on at most t−1 points, it follows that for any given R, at most




  
    
      (
      
        
          
            r
          
        
        
          
            2
          
        
      
      )
    
    ⁢
    
      (
      
        t
        -
        1
      
      )
    
  
  <
  
    
      r
      2
    
    ⁢
    t
  




blocks of t elements each can be such that px(v)=py(v) for some v in a block for distinct x,yεR. Therefore, one of the LB is good for R.

For this choice of LB, we can re-write (15) as follows. We represent each CFB as

CFB=CFB0U CFB1,  (26)

where:





  
    
      
        
          CF
          
            B
            ⁢
            
              
            
            ⁢
            0
          
        
        =
        
          {
          
            
              
                
                  ∏
                  
                    j
                    =
                    1
                  
                  
                    r
                    ′
                  
                
                ⁢
                
                  (
                  
                    
                      
                        ∑
                        
                          s
                          =
                          0
                        
                        
                          t
                          -
                          1
                        
                      
                      ⁢
                      
                        
                          b
                          0
                          s
                        
                        ⁢
                        
                          X
                          s
                        
                      
                    
                    -
                    
                      i
                      j
                    
                  
                  )
                
              
              |
              
                0
                ≤
                
                  r
                  ′
                
                ≤
                r
              
            
            ,
            
              distinct
              ⁢
              
                
              
              ⁢
              
                i
                1
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              
                i
                
                  r
                  ′
                
              
              ∈
              F
            
          
          }
        
      
    
    
      
        (
        27
        )
      
    
  
  
    
      
        
          CF
          
            B
            ⁢
            
              
            
            ⁢
            1
          
        
        =
        
          {
          
            
              
                
                  
                    g
                    ⁡
                    
                      (
                      
                        
                          ∑
                          
                            s
                            =
                            0
                          
                          
                            t
                            -
                            1
                          
                        
                        ⁢
                        
                          
                            b
                            
                              i
                              -
                              1
                            
                            s
                          
                          ⁢
                          
                            X
                            s
                          
                        
                      
                      )
                    
                  
                  -
                  
                    
                      ∑
                      
                        s
                        =
                        0
                      
                      
                        t
                        -
                        1
                      
                    
                    ⁢
                    
                      
                        b
                        i
                        s
                      
                      ⁢
                      
                        X
                        s
                      
                    
                  
                
                |
                
                  1
                  ≤
                  i
                  ≤
                  
                    t
                    -
                    1
                  
                
              
              ;
              
                g
                ∈
                
                  F
                  ⁡
                  
                    [
                    X
                    ]
                  
                
              
            
            ,
            
              
                deg
                ⁡
                
                  (
                  g
                  )
                
              
              ≤
              
                r
                -
                1
              
            
          
          }
        
      
    
    
      
        (
        28
        )
      
    
  




Here b0, bi−1, bi are elements of the block B corresponding to CFB.

Of note, expressions (15) through (28) are also appropriate for the case when no two points in R have the same ith coordinate for all i, i.e. the case considered above in connection with expression (8). Indeed, one of LB's will be good for any such R.
The above construction serves as a proof of the following mathematical lemma:
Lemma 2. There is an explicit set of m=r2t linear transformations such that for all R⊂[n] of size at most r, one of the transformations is good for R.
By Lemma 2 we can set m=r2t in the discussion above. Thus k=O((rt)2pr). Using a standard result in the art [2], we can find a prime p with n1/t≦p<n1/t+nβ/t for any constant β>0.525 and sufficiently large n1/t. Since t≦n1/t, we have




  
    t
    =
    
      O
      ⁡
      
        (
        
          
            log
            ⁢
            
              
            
            ⁢
            n
          
          
            log
            ⁢
            
              
            
            ⁢
            log
            ⁢
            
              
            
            ⁢
            n
          
        
        )
      
    
  
  ,




and thus





  
    n
    
      1
      /
      t
    
  
  =
  
    
      Ω
      ⁡
      
        (
        
          
            log
            ⁢
            
              
            
            ⁢
            n
          
          
            log
            ⁢
            
              
            
            ⁢
            log
            ⁢
            
              
            
            ⁢
            n
          
        
        )
      
    
    .
  




Therefore we can find such a prime for sufficiently large n. The number of keys is bounded by





  
    
      
        
          O
          ⁡
          
            (
            
              
                
                  (
                  rt
                  )
                
                2
              
              ⁢
              
                p
                r
              
            
            )
          
        
        =
        
          
            O
            ⁡
            
              (
              
                
                  
                    (
                    rt
                    )
                  
                  2
                
                ⁢
                
                  
                    (
                    
                      
                        n
                        
                          1
                          /
                          t
                        
                      
                      +
                      
                        n
                        
                          β
                          /
                          t
                        
                      
                    
                    )
                  
                  r
                
              
              )
            
          
          =
          
            O
            ⁡
            
              (
              
                
                  
                    (
                    rt
                    )
                  
                  2
                
                ⁢
                
                  
                    
                      n
                      
                        r
                        /
                        t
                      
                    
                    ⁡
                    
                      (
                      
                        1
                        +
                        
                          n
                          
                            
                              (
                              
                                β
                                -
                                1
                              
                              )
                            
                            /
                            t
                          
                        
                      
                      )
                    
                  
                  r
                
              
              )
            
          
        
      
    
  
  
    
      
        
          =
          
            
              O
              ⁡
              
                (
                
                  
                    
                      (
                      rt
                      )
                    
                    2
                  
                  ⁢
                  
                    n
                    
                      r
                      /
                      t
                    
                  
                  ⁢
                  
                    e
                    
                      r
                      /
                      
                        n
                        
                          
                            (
                            
                              1
                              -
                              β
                            
                            )
                          
                          /
                          t
                        
                      
                    
                  
                
                )
              
            
            =
            
              O
              ⁡
              
                (
                
                  
                    
                      (
                      rt
                      )
                    
                    2
                  
                  ⁢
                  
                    n
                    
                      r
                      /
                      t
                    
                  
                
                )
              
            
          
        
        ,
      
    
  




provided that (for the last equality) r=O(n(1−β)/t), or r1/(1−β)=O(n1/t). The time for broadcasting is dominated by the search for a good LB and the t−1 degree-(r−1) polynomial interpolations, each of which can be done in poly(r, t, log n) time.

The performance characteristics of the exclusive set system can be summarized in the following theorem (in which α can be thought of as 1/(1−β):
Theorem 3. Let




  
    α
    >
    
      1
      
        1
        -
        .525
      
    
  
  =
  
    40
    /
    19
  




be any constant, and assume max(rα,r2t2)=O(n1/t). For sufficiently large n, there is an explicit (n, O((rt)2nr/t),r,t)-exclusive set system. Further, broadcasting can be done in poly(r, t, log n) time.

3 Constructing Exclusive Set Systems Using Graphs
We can improve on the previous method with a slightly different way of handling points in R that share coordinates.
Intuition: The previous method had r2t coordinate systems defined by the transformations LB, each of which was good for a different collection of R⊂[n]. In each system we interpreted a point xεFt as a polynomial px, and evaluated the polynomial on t elements b1, . . . , bt of F. The system LB corresponding to b1, . . . , bt was good for R if for each of the t elements b1, . . . , bt each of the at most r polynomials px, corresponding to the points in R had different evaluations. The disadvantage is that even if only two polynomials collided on just one element bi, the coordinate system could not be used for R. In the worst case this happens less than r2t times, so we used r2t systems, formed using r2t2 elements bi of F.
But given a set R of r points corresponding to r polynomials, only some number less than r2t of elements bi of F can have collisions on these polynomials. If we had r2t+t elements bi, for any R we could find t elements bi to use for a coordinate system LB. However, if we allow any two elements to occur together in a system, the number of sets (i.e., the number of polynomial constraints) needed would be too large. Interpreting the elements bi as nodes of a graph and pairs of elements that can occur together as edges, the property we want is that the graph is well-connected (i.e. has many paths from one node to another) and has low degree. This is exactly the property of an expander graph. We will find a connected component of size t amongst collision-free elements and use this as a coordinate system.
We will identify the points of [n] with vertices b of a graph G=(V,E). The graph is shown at 1310 in FIG. 13. Here V is the set of vertices, and E is the set of edges. A set of polynomials similar to (28) will be constructed for each pair of adjacent vertices, and another set similar to (27) for each vertex. More particularly:




  
    
      
        CF
        =
        
          
            {
            
              
                
                  
                    ∏
                    
                      j
                      =
                      1
                    
                    
                      r
                      ′
                    
                  
                  ⁢
                  
                    (
                    
                      
                        
                          ∑
                          
                            i
                            =
                            0
                          
                          
                            t
                            -
                            1
                          
                        
                        ⁢
                        
                          
                            b
                            i
                          
                          ⁢
                          
                            X
                            i
                          
                        
                      
                      -
                      
                        i
                        j
                      
                    
                    )
                  
                
                |
                
                  0
                  ≤
                  
                    r
                    ′
                  
                  ≤
                  r
                
              
              ,
              
                distinct
                ⁢
                
                  
                
                ⁢
                
                  i
                  1
                
              
              ,
              ...
              ⁢
              
                
              
              ,
              
                
                  i
                  
                    r
                    ′
                  
                
                ∈
                F
              
              ,
              
                b
                ∈
                V
              
            
            }
          
          ⁢
          
            

          
          ⋃
          
            
              {
              
                
                  
                    
                      g
                      ⁡
                      
                        (
                        
                          
                            ∑
                            
                              i
                              =
                              0
                            
                            
                              t
                              -
                              1
                            
                          
                          ⁢
                          
                            
                              b
                              i
                            
                            ⁢
                            
                              X
                              i
                            
                          
                        
                        )
                      
                    
                    -
                    
                      
                        ∑
                        
                          i
                          =
                          0
                        
                        
                          t
                          -
                          1
                        
                      
                      ⁢
                      
                        
                          c
                          i
                        
                        ⁢
                        
                          X
                          i
                        
                      
                    
                  
                  |
                  
                    g
                    ∈
                    
                      F
                      ⁡
                      
                        [
                        X
                        ]
                      
                    
                  
                
                ,
                
                  
                    deg
                    ⁡
                    
                      (
                      g
                      )
                    
                  
                  ≤
                  
                    r
                    -
                    1
                  
                
                ,
                
                  
                    (
                    
                      b
                      ,
                      c
                    
                    )
                  
                  ∈
                  E
                
              
              }
            
            .
          
        
      
    
    
      
        (
        29
        )
      
    
  




CF corresponds to the exclusive set system CC which contains all the sets S of the form:





  
    
      
        
          
            S
            =
            
              {
              
                
                  x
                  ∈
                  
                    [
                    n
                    ]
                  
                
                |
                
                  
                    
                      ∑
                      
                        i
                        =
                        0
                      
                      
                        t
                        -
                        1
                      
                    
                    ⁢
                    
                      
                        b
                        i
                      
                      ⁢
                      
                        x
                        i
                      
                    
                  
                  ∉
                  
                    {
                    
                      
                        i
                        1
                      
                      ,
                      ...
                      ⁢
                      
                        
                      
                      ,
                      
                        i
                        
                          r
                          ′
                        
                      
                    
                    }
                  
                
              
              }
            
          
          ,
          
            
              where
              ⁢
              
                
              
              ⁢
              0
            
            ≤
            
              r
              ′
            
            ≤
            r
          
          ,
          
            distinct
            ⁢
            
              
            
            ⁢
            
              i
              1
            
          
          ,
          ...
          ⁢
          
            
          
          ,
          
            
              i
              
                r
                ′
              
            
            ∈
            F
          
          ,
          
            b
            ∈
            V
          
          ,
          or
        
        ⁢
        
          

        
        ⁢
        
          
            S
            =
            
              {
              
                
                  x
                  ∈
                  
                    [
                    n
                    ]
                  
                
                |
                
                  
                    g
                    ⁡
                    
                      (
                      
                        
                          ∑
                          
                            i
                            =
                            0
                          
                          
                            t
                            -
                            1
                          
                        
                        ⁢
                        
                          
                            b
                            i
                          
                          ⁢
                          
                            x
                            i
                          
                        
                      
                      )
                    
                  
                  ≠
                  
                    
                      ∑
                      
                        i
                        =
                        0
                      
                      
                        t
                        -
                        1
                      
                    
                    ⁢
                    
                      
                        c
                        i
                      
                      ⁢
                      
                        x
                        i
                      
                    
                  
                
              
              }
            
          
          ,
          
            
              where
              ⁢
              
                
              
              ⁢
              g
            
            ∈
            
              F
              ⁡
              
                [
                X
                ]
              
            
          
          ,
          
            
              deg
              ⁡
              
                (
                g
                )
              
            
            ≤
            
              r
              -
              1
            
          
          ,
          
            
              (
              
                b
                ,
                c
              
              )
            
            ∈
            
              E
              .
            
          
        
      
    
    
      
        (
        30
        )
      
    
  




At step 750 (FIG. 7 or 10), the server obtains an appropriate graph G, and constructs the exclusive set system (30), possibly from polynomials (29).
Step 810 (FIG. 8 or 11) is performed as shown in FIG. 14. We will say that an element v is good for a set R if, using the notation of Lemma 2, for any distinct x, yεR, px(v)≠py(v). We assume |R|≧2, since the step 810 is trivial for the case |R| being 0 or 1. Given a revoked set R, at step 810.1 the server finds a connected subgraph (FIG. 15) of at least t vertices that are good for R. This can be done using techniques described below. FIG. 15 shows an example subgraph 1510 of 9 vertices (t=9) labeled with integers for ease of reference. At step 810.2, the server defines a tree 1610 (FIG. 16) which is a subgraph of the subgraph 1510. This means that the server defines, in storage 734, the parent-child relationship among the nodes. Any such tree will do, and in some embodiments the tree is constructed using a graph traversal similar to a breadth-first search (BFS). (The server does not do a search however.) More particularly, a queue (not shown) is defined in the server's storage 734. Then (see FIG. 17):
1. At step 1710, a node is picked for a root of the tree (node 5 in FIG. 16; we use “node” and “vertex” interchangeably), and put in the queue. This can be any node in the graph. The server also marks the node to indicate that it has been in the queue during this processing.
2. At step 1720, a node is dequeued from the queue (this will be node 5 in our example). Take all the unmarked nodes adjacent to this node in the subgraph 1510 (nodes 8, 9, 4, 2 in our example), and add them to the queue (in any order) and mark them. Make these nodes to be the children of the pulled node in the tree (nodes 8, 9, 4, 2 are children of 5 in FIG. 16).
Repeat step 1720 until the queue is empty (as shown by steps 1724, 1730). Thus, the next node to be pulled from the queue will be 8, and its adjacent node 0 will become its child in the tree. It will also be added to the queue and marked, and so on.
We note that a tree 1610 is roughly analogous to a transformation LB of (23). The tree has t nodes, similar to the elements b0, . . . , bt−1 of the block B. By analogy with the coordinate system of (25), each element xεF can be represented by a set of values of px on the tree nodes:

{px(b)| b is a node of tree 1610}  (31)

Each node b in the tree corresponds to one of the coordinates in the coordinate system (31).

By analogy with (5)-(28), we can construct t polynomials {ƒb|b is a node of tree 1610} for SF(R), one polynomial for each coordinate. The server performs this operation at step 810.3. Let v be the root of the tree (node 5 in FIG. 16). For any other vertex b in the tree, let p(b) be its parent. The polynomial ƒv will impose constraints on the vth coordinate. Every other polynomial ƒb will impose constraints on the pair of b and p(b). More particularly, the server sets




  
    
      
        
          f
          v
        
        =
        
          
            ∏
            
              u
              ∈
              R
            
          
          ⁢
          
            (
            
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    t
                    -
                    1
                  
                
                ⁢
                
                  
                    v
                    i
                  
                  ⁢
                  
                    X
                    i
                  
                
              
              -
              
                
                  p
                  u
                
                ⁡
                
                  (
                  v
                  )
                
              
            
            )
          
        
      
    
    
      
        (
        32
        )
      
    
  




For each b≠v, the server finds a polynomial gb of degree at most |R|−1 by interpolating from





  
    
      
        
          
            
              g
              b
            
            ⁡
            
              (
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    t
                    -
                    1
                  
                
                ⁢
                
                  
                    
                      p
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    i
                  
                  ⁢
                  
                    u
                    i
                  
                
              
              )
            
          
          =
          
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  t
                  -
                  1
                
              
              ⁢
              
                
                  b
                  i
                
                ⁢
                
                  u
                  i
                
                ⁢
                
                  
                
                ⁢
                for
                ⁢
                
                  
                
                ⁢
                all
                ⁢
                
                  
                
                ⁢
                u
              
            
            =
            
              
                (
                
                  
                    u
                    0
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    u
                    
                      t
                      -
                      1
                    
                  
                
                )
              
              ∈
              R
            
          
        
        ,
        
          

        
        ⁢
        
          i
          .
          e
          .
        
        ,
      
    
    
      
        (
        33
        )
      
    
  
  
    
      
        
          
            
              g
              b
            
            ⁡
            
              (
              
                
                  p
                  u
                
                ⁡
                
                  (
                  
                    p
                    ⁡
                    
                      (
                      b
                      )
                    
                  
                  )
                
              
              )
            
          
          =
          
            
              
                
                  p
                  u
                
                ⁡
                
                  (
                  b
                  )
                
              
              ⁢
              
                
              
              ⁢
              for
              ⁢
              
                
              
              ⁢
              all
              ⁢
              
                
              
              ⁢
              u
            
            ∈
            R
          
        
        ,
      
    
    
      
        (
        34
        )
      
    
  




and sets





  
    
      
        
          f
          b
        
        =
        
          
            
              g
              b
            
            ⁡
            
              (
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    t
                    -
                    1
                  
                
                ⁢
                
                  
                    
                      p
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    i
                  
                  ⁢
                  
                    X
                    i
                  
                
              
              )
            
          
          -
          
            
              ∑
              
                i
                =
                0
              
              
                t
                -
                1
              
            
            ⁢
            
              
                b
                i
              
              ⁢
              
                X
                i
              
            
          
        
      
    
    
      
        (
        35
        )
      
    
  




We show now that Var({ƒb})=R. Indeed, in view of (34), every uεR vanishes on these t functions {ƒb} (i.e. the functions are zero on R). It will be apparent to one skilled in the art after reviewing the foregoing argument that no other point xεF vanishes. Indeed, let us assume the contrary, i.e. that a point xεF\R vanishes on all ƒb. Then




  
    
      
        f
        v
      
      ⁡
      
        (
        
          
            ∑
            
              i
              =
              0
            
            
              t
              -
              1
            
          
          ⁢
          
            
              v
              i
            
            ⁢
            
              x
              i
            
          
        
        )
      
    
    =
    0
  
  ,




so (32) implies that





  
    
      ∑
      
        i
        =
        0
      
      
        t
        -
        1
      
    
    ⁢
    
      
        v
        i
      
      ⁢
      
        x
        i
      
    
  
  =
  
    
      p
      u
    
    ⁡
    
      (
      v
      )
    
  




for some uεR since ƒv has only |R| zeros. In other words, px(v)=pu(v). Denote this particular u as uu. Proceeding inductively on the height of the tree starting from the root, we see that

px(b)=puu(b)  (36)

for all vertices b in the tree. Indeed, suppose p(b)=c, and assume that (36) has been proven for this parent node c, i.e. px(c)=puu(c). Then, since ƒb vanishes on uu and x, we obtain from (35):

gb(puu(c))=puu(b), and gb(px(c))=px(b),

and hence (36) holds for the node b. Thus, (36) holds for all the t vertices. Since px, puu are degree-(t−1) polynomials, px=puu, so x=uu, a contradiction.

The invention is not limited to particular graphs or to embodiments in which the number |CF| of polynomials is smaller than in the case of FIG. 10. However, we show now how a graph of FIG. 13 can be chosen to obtain a small |CF|. Choose m=γr2t elements (say, 1, . . . , m) in F, where γ>2 is a constant to be determined. From the proof of Lemma 2, for any R we can find (γ−1)r2t good elements for R.
The idea is to consider graphs G with constant degree d, vertex set [m], and the property that any induced subgraph on a large constant fraction of vertices has a connected component of size at least m/2≧t. This property holds for certain expander graphs. Recall that a graph G=(V,E) with the vertex set V and the edge set E is an (m,d,c)-expander if it has m-vertices, each vertex has degree d, and for every set of vertices W⊂V with |W|≦m/2, there are at least c|W| vertices in V\W adjacent to some vertex in W.
Consider an (m,d,c)-expander G. It will be apparent to one skilled in the art after reviewing the foregoing argument that any induced subgraph H on more than




  
    d
    ⁢
    
      
    
    ⁢
    m
  
  
    c
    +
    d
  




vertices has a connected component of size at least m/2. Specifically, let C1, . . . , Ck be the connected components of H. Now, G is an expander and if |Ci|<m/2 for all 1≦i≦k, then Ci is incident to at least c|Ci| distinct vertices in G\Ci, and thus in G\H. Therefore, the multiset of vertices in G\H connected to H has cardinality more than





  
    c
    ⁢
    
      
        d
        ⁢
        
          
        
        ⁢
        m
      
      
        c
        +
        d
      
    
  
  ,




which is impossible since each of the (at most)





  
    m
    -
    
      
        d
        ⁢
        
          
        
        ⁢
        m
      
      
        c
        +
        d
      
    
  
  =
  
    
      c
      ⁢
      
        
      
      ⁢
      m
    
    
      c
      +
      d
    
  




vertices in G\H can occur at most d times. It follows therefore, that at least one connected component has m/2≧t vertices. The above argument proves the following lemma:

Lemma 4. Let G be an (m,d,c)-expander. Then any induced subgraph on more than




  
    d
    ⁢
    
      
    
    ⁢
    m
  
  
    c
    +
    d
  




vertices of G has a connected component of size at least m/2.

Now, there are many known constructions in the art of expander graphs with desirable parameters. In particular, some of the methods described in the present disclosure will make use of such known constructions. For an explicit family of expanders, we use the following.
Fact 5 (See [10]). There is an explicit family of




  (
  
    
      m
      i
    
    ,
    6
    ,
    
      
        1
        2
      
      -
      
        
          5
        
        6
      
    
  
  )




expanders with mi<mi+1<mi(1+o(1)).

In some embodiments, we use a graph G (for the graph of FIG. 13) that satisfies the conditions summarized in Lemma 4. Given R, the server can find (γ−1)r2t vertices good for R, and in order for the corresponding induced subgraph to have a component of size m/2 as guaranteed by Lemma 4, we want that:




  
    
      
        
          
            (
            
              γ
              -
              1
            
            )
          
          ⁢
          
            r
            2
          
          ⁢
          t
        
        >
        
          
            d
            ⁢
            
              
            
            ⁢
            m
          
          
            c
            +
            d
          
        
      
    
    
      
        (
        37
        )
      
    
  




We use Fact 5 to construct an





  (
  
    
      m
      =
      
        γ
        ⁢
        
          
        
        ⁢
        
          r
          2
        
        ⁢
        t
      
    
    ,
    6
    ,
    
      
        1
        2
      
      -
      
        
          5
        
        6
      
    
  
  )




expander. This value of m belongs to the set {mi} as in Fact 5. With this value of m, (37) becomes:





  
    
      
        
          
            γ
            -
            1
          
          γ
        
        >
        
          
            6
            
              6
              +
              
                1
                2
              
              -
              
                
                  5
                
                6
              
            
          
          .
          
            

          
          ⁢
          or
        
      
    
    
      
        (
        38
        )
      
    
  
  
    
      
        γ
        >
        
          
            39
            -
            
              5
            
          
          
            3
            -
            
              5
            
          
        
      
    
    
      
        (
        39
        )
      
    
  




(for example, γ can be 49 or greater). At step 750 (FIG. 7 or 10), the server identifies G=(V,E)'s vertices V with [m]⊂F, and defines CC as in (30). The size of CF as defined in (29), and thus k, is O(mdpr). As was apparent in the argument leading up to Theorem 3, we can choose p so that this quantity is O(r2tnr/t).

Step 810.1 (FIG. 14) is performed as follows. Given R, the server finds (γ−1)r2t vertices in G which are good for R. Then, the server finds a connected component C of at least m/2≧t vertices good for R (note that our choice of γ and the argument leading up to Lemma 4 guarantees that such a connected component exists). The component C includes the subgraph 1510 (FIG. 15), and may include other nodes and edges.
At step 810.2, the procedure of FIG. 17 is performed on the connected component C until the number of nodes in the tree 1610 reaches t (i.e. step 1720 is performed until the number of nodes in the tree reaches t). Then step 810.3 is performed as described above.
The time complexity is dominated by the search for good vertices for R, the tree generation (step 810.2), and the polynomial interpolations, all of which can be carried out in poly(r, t, log n) time using techniques known in the art.
The results from the above construction can be summarized by means of the following theorem.
Theorem 6. Let




  α
  >
  
    1
    
      1
      -
      .525
    
  




be any constant, and assume max(rα,r2t)=O(n1/t). For sufficiently large n, there is an explicit (n, O(r2tnr/t),r,t)-exclusive set system. Further, broadcasting can be done in poly(r, t, log n) time.

4. Randomized Method for Constructing Exclusive Set Systems
The main drawback of randomized constructions in the prior art [8] is that whenever we want to find Si1, . . . , Sil whose union is [n]\R, we need to solve an instance of Set-Cover. We removed this problem with the explicit construction above, and further achieved size O(r2tnr/t) versus the O(t3nr/t log n) complexity in [8], which held only for r≦t.
We now describe a method to improve the complexity further to O(rtnr/t) via a randomized construction. Although the construction is randomized, it does not suffer from the efficiency problems of [8]. Rather, broadcasting can still be done in poly(r, t, log n) time.
Intuition: The idea is to choose the set of m points b for the graph of FIG. 13 randomly from F. For a given R it then becomes unlikely that we will choose many points with collisions on R. We show this allows us to choose O(rt) points rather than O(r2t).
Lemma 7. Let ε>0 and γ>1 be any constants. Assume r2t<n(1−ε)/t, and choose a set of S of m=2γrt/ε elements uniformly at random from F. Then with probability 1−n−Θ(r), for all R, the set S contains 2(γ−1)rt/ε good elements for R. (As conventional, Θ(r) denotes a value Y such that the lower and upper limits of Y/r are positive and finite when r approaches infinity.)
Proof: Fix a revoked set R⊂[n]. For sεS, let v be the probability that s is not good for R, that is, there exist distinct x,yεR for which px(s)=py(s). For fixed x≠y, we have Prs[px(s)=py(s)]≦(t−1)/p, and thus




  v
  ≤
  
    
      (
      
        
          
            r
          
        
        
          
            2
          
        
      
      )
    
    ⁢
    
      
        (
        
          t
          -
          1
        
        )
      
      /
      p
    
  
  ≤
  
    
      r
      2
    
    ⁢
    
      t
      /
      
        n
        
          1
          /
          t
        
      
    
  
  <
  
    n
    
      
        -
        ɛ
      
      /
      t
    
  




by the assumption of the lemma. The probability that more than 2rt/ε elements of S are not good for R is bounded by





  
    
      
        ∑
        
          i
          =
          
            2
            ⁢
            
              
            
            ⁢
            
              rt
              /
              ɛ
            
          
        
        m
      
      ⁢
      
        
          (
          
            
              
                m
              
            
            
              
                i
              
            
          
          )
        
        ⁢
        
          
            
              v
              i
            
            ⁡
            
              (
              
                1
                -
                v
              
              )
            
          
          
            m
            -
            i
          
        
      
    
    ≤
    
      m
      ⁢
      
        
      
      ⁢
      
        2
        m
      
      ⁢
      
        v
        
          2
          ⁢
          
            
          
          ⁢
          
            rt
            /
            ɛ
          
        
      
    
    <
    
      
        2
        
          2
          ⁢
          
            
          
          ⁢
          m
        
      
      ⁢
      
        n
        
          
            -
            2
          
          ⁢
          
            
          
          ⁢
          r
        
      
    
  
  =
  
    
      n
      
        
          
            -
            2
          
          ⁢
          
            
          
          ⁢
          r
        
        +
        
          2
          ⁢
          
            
          
          ⁢
          
            m
            /
            log
          
          ⁢
          
            
          
          ⁢
          n
        
      
    
    .
  




For any n−Θ(r)≦δ<1, this is less than δn−r if −2r+2m/log n≦−r+log δ/log n, or equivalently, r log n≧2m+log 1/δ. By assumption, this holds for sufficiently large n because m=O(rt) and δ>n−Θ(r), while t=O(log n/loglog n) since t<n1/t. Then the probability there exists an R for which more than 2rt/ε elements of S are not good for R is less than





  
    
      ∑
      
        i
        =
        0
      
      r
    
    ⁢
    
      
        (
        
          
            
              n
            
          
          
            
              i
            
          
        
        )
      
      ⁢
      δ
      ⁢
      
        
      
      ⁢
      
        n
        
          -
          r
        
      
    
  
  ≤
  
    
      n
      
        -
        
          Θ
          ⁡
          
            (
            r
            )
          
        
      
    
    .
  




In some embodiments, we use the set S as the vertex set of an (m=2γrt/ε, 6, 1⁄2−√{square root over (5⁄6)} expander (FIG. 13) as described earlier in Fact 5, with m being equal to some mi as in Fact 5. At step 810.1 (FIG. 14), the server finds 2(γ−1)rt/ε vertices that are good for R. By Lemma 4, the corresponding induced subgraph has a connected component of size at least m/2 provided that

2(γ−1)rt/ε>dm/(c+d)=12γrt/[ε(6+1⁄2−√{square root over (5⁄6)})]

This inequality is equivalent to (38). Therefore, the connected component exists if γ satisfies (39).

The size of the polynomial set CF corresponding to S is O(mdpr)=O(rtpr). As was apparent in the argument leading up to Theorem 3, we can choose p so that this quantity is o(rtnr/t). We conclude:
Theorem 8. Let




  α
  >
  
    1
    
      1
      -
      .525
    
  




and ε>0 be any constants, and assume max(rα, r2t)<n(1−ε)/t. There is an efficient algorithm that with probability 1−n−Θ(r), generates an (n, O(rtnr/t),r,t)-exclusive set system. Further, broadcasting can be done in poly(r, t, log n) time.

6. Method for Balancing Key Complexity in Exclusive Set Systems
We have shown how to achieve complexity k=O(rtnr/t). We now describe a method to achieve




  k
  =
  
    
      O
      ⁡
      
        (
        
          
            rt
            ⁡
            
              (
              
                
                  
                    n
                  
                
                
                  
                    r
                  
                
              
              )
            
          
          
            1
            /
            t
          
        
        )
      
    
    .
  




To illustrate the technique, we first apply it to the scheme of Theorem 3. There are two types of sets Sƒ, those corresponding to polynomials of the form





  f
  =
  
    
      ∏
      
        j
        =
        1
      
      
        r
        ′
      
    
    ⁢
    
      (
      
        
          
            L
            B
          
          ⁢
          
            X
            0
          
        
        -
        
          i
          j
        
      
      )
    
  




for r′≦r and distinct i1, . . . , ir′εF, and those corresponding to polynomials of the form g(LBXi−1)−LBXi, where g is a polynomial of degree at most r−1. If m is the number of linear combinations LB, then the number of sets of the first type is





  m
  ⁢
  
    
      ∑
      
        
          r
          ′
        
        =
        0
      
      r
    
    ⁢
    
      
        (
        
          
            
              p
            
          
          
            
              
                r
                ′
              
            
          
        
        )
      
      .
    
  




To apply Theorem 3, we assume r2t2=O(n1/t), so that r=O(p1/2). It follows that





  
    m
    ⁢
    
      
        ∑
        
          i
          =
          0
        
        r
      
      ⁢
      
        (
        
          
            
              p
            
          
          
            
              i
            
          
        
        )
      
    
  
  =
  
    
      Θ
      ⁡
      
        (
        
          m
          ⁡
          
            (
            
              
                
                  p
                
              
              
                
                  r
                
              
            
            )
          
        
        )
      
    
    .
  




(To see this, for any constant





  c
  ,
  
    
      
        (
        
          
            
              p
            
          
          
            
              
                c
                ⁢
                
                  p
                
              
            
          
        
        )
      
      /
      
        (
        
          
            
              p
            
          
          
            
              
                c
                ⁢
                
                  
                    p
                    -
                    1
                  
                
              
            
          
        
        )
      
    
    =
    
      Θ
      ⁡
      
        (
        
          p
        
        )
      
    
  
  ,




so that





  
    
      
        ∑
        
          
            r
            ′
          
          =
          0
        
        
          c
          ⁢
          
            p
          
        
      
      ⁢
      
        (
        
          
            
              p
            
          
          
            
              
                r
                ′
              
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                p
              
            
            
              
                
                  c
                  ⁢
                  
                    p
                  
                
              
            
          
          )
        
        +
        
          
            ∑
            
              
                r
                ′
              
              =
              0
            
            
              c
              ⁢
              
                
                  p
                  -
                  1
                
              
            
          
          ⁢
          
            (
            
              
                
                  p
                
              
              
                
                  
                    r
                    ′
                  
                
              
            
            )
          
        
      
      =
      
        Θ
        ⁡
        
          (
          
            (
            
              
                
                  p
                
              
              
                
                  
                    c
                    ⁢
                    
                      p
                    
                  
                
              
            
            )
          
          )
        
      
    
  
  ;




in these equalities, a loose notation is used: √{square root over (p)} denotes an integer close to the real value of √{square root over (p)}, e.g. the integer closest to the real value of √{square root over (p)}). On the other hand, the number of sets of the second type is m(t−1)pr.

Intuition: The complexity is dominated from sets of the second type. We will reduce the alphabet size p to some prime q, while including more alphabet symbols (other than just the first) in sets of the first type. This effectively balances the contribution to the complexity from the two types.
Using [2], for large enough n we can choose a prime q in the interval




  
    
      
        
          [
          
            
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
              
                1
                /
                
                  (
                  rt
                  )
                
              
            
            ,
            
              
                
                  (
                  
                    
                      
                        n
                      
                    
                    
                      
                        r
                      
                    
                  
                  )
                
                
                  1
                  /
                  
                    (
                    rt
                    )
                  
                
              
              +
              
                
                  (
                  
                    
                      
                        n
                      
                    
                    
                      
                        r
                      
                    
                  
                  )
                
                
                  β
                  /
                  
                    (
                    rt
                    )
                  
                
              
            
          
          ]
        
        ,
        
          
            i
            .
            e
            .
            
              

            
            ⁢
            
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
              
                1
                /
                
                  (
                  rt
                  )
                
              
            
          
          ≤
          q
          ≤
          
            
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
              
                1
                /
                
                  (
                  rt
                  )
                
              
            
            +
            
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
              
                β
                /
                
                  (
                  rt
                  )
                
              
            
          
        
      
    
    
      
        (
        40
        )
      
    
  




for any constant β>0.525. This follows if we assume

max(r1+ε,t)≦n1/t  (41)

for some constant ε>0. Indeed, this implies n/r=nΩ(1) and t=O(log n/loglog n), so





  
    
      
        (
        
          
            
              n
            
          
          
            
              r
            
          
        
        )
      
      
        1
        /
        
          (
          rt
          )
        
      
    
    ≥
    
      
        (
        
          n
          /
          r
        
        )
      
      
        1
        /
        t
      
    
  
  ,




and the latter tends to ∞. We will show k=O(mtqr). Note that





  
    O
    ⁡
    
      (
      
        mtq
        r
      
      )
    
  
  =
  
    
      
        O
        ⁡
        
          (
          
            
              mt
              ⁡
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
            
            
              1
              /
              t
            
          
          )
        
      
      ⁢
      
        
      
      ⁢
      for
      ⁢
      
        
      
      ⁢
      r
    
    ≤
    
      
        
          (
          
            
              
                n
              
            
            
              
                r
              
            
          
          )
        
        
          
            (
            
              1
              -
              β
            
            )
          
          /
          t
        
      
      .
    
  




Since




  
    
      (
      
        n
        /
        r
      
      )
    
    r
  
  ≤
  
    (
    
      
        
          n
        
      
      
        
          r
        
      
    
    )
  
  ≤
  
    
      (
      
        n
        ⁢
        
          
        
        ⁢
        
          e
          /
          r
        
      
      )
    
    r
  




(where e is the base of the natural logarithm), there is a constant 1≦c≦e, with





  
    
      
        
          (
          
            
              
                n
              
            
            
              
                r
              
            
          
          )
        
        =
        
          
            
              (
              
                nc
                /
                r
              
              )
            
            r
          
          .
        
      
    
    
      
        (
        42
        )
      
    
  




We represent [n] by points in the (t+1)-dimensional space

D=[┌r/c┐]×Fqt.

This allows elements of [n] to have distinct representations. Indeed, taking into account (40) and (42),





  
    
      
        
          
            
            D
            
          
          ≥
          
            
              (
              
                r
                /
                c
              
              )
            
            ×
            
              q
              t
            
          
          ≥
          
            
              (
              
                r
                /
                c
              
              )
            
            ×
            
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
              
                1
                /
                r
              
            
          
        
        =
        n
      
    
    
      
        (
        43
        )
      
    
  




Our exclusive set system CC will contain sets Sƒ where each ƒ(X0, X1, . . . , Xt) is independent of X0 and is a polynomial in the space F[X1, . . . , Xt] of degree at most r−1. In addition, CC will contain sets SR defined below.
For the moment, assume our revoked set R is such that no two members of R share their ith coordinate for any i>1 (i.e. for any coordinate corresponding to Fqt). The set R corresponds to a set SR of the first type, and in particular the set of those points x=(x0, x1, . . . , xt) whose first two coordinates (x0, x1) do not agree with those of any element of R, i.e.

SR={x=(x0, x1, . . . , xt)εD|(x0, x1)≠(u0,u1) for all (u0, u1, . . . , ut)εR}.  (44)

Note that SR is similar to Sƒ0 of (12). No representation is being made as to whether or not the set SR corresponds to a polynomial of degree at most r.

Since no two members of R share their ith coordinate for any i>1, the number of sets SR for all R such that |R| is some fixed number




  
    r
    ′
  
  ≤
  
    r
    ⁢
    
      
    
    ⁢
    is
    ⁢
    
      
    
    ⁢
    
      
        ⌈
        
          r
          /
          c
        
        ⌉
      
      
        r
        ′
      
    
    ⁢
    
      
        (
        
          
            
              q
            
          
          
            
              
                r
                ′
              
            
          
        
        )
      
      .
    
  




Hence, the total number of sets SR is





  
    
      
        ∑
        
          
            r
            ′
          
          =
          0
        
        r
      
      ⁢
      
        
          
            (
            
              ⌈
              
                r
                /
                c
              
              ⌉
            
            )
          
          
            r
            ′
          
        
        ⁢
        
          (
          
            
              
                q
              
            
            
              
                
                  r
                  ′
                
              
            
          
          )
        
      
    
    =
    
      Θ
      ⁡
      
        (
        
          
            
              (
              
                ⌈
                
                  r
                  /
                  c
                
                ⌉
              
              )
            
            r
          
          ⁢
          
            (
            
              
                
                  q
                
              
              
                
                  r
                
              
            
            )
          
        
        )
      
    
  
  ,




since the fact that





  r
  ≤
  
    
      (
      
        
          
            n
          
        
        
          
            r
          
        
      
      )
    
    
      
        (
        
          1
          -
          β
        
        )
      
      /
      t
    
  




(at least when r is sufficiently large) implies that r=O(√{square root over (q)}), so that the binomial sum is dominated by the last term.

Sets of the second type correspond to the polynomial collection:

CF2={g(Xi−1)−Xi|gεFq[X], 2≦i≦t, deg(g)≦r−1}  (45)

Since i≧2, these polynomials do not involve the first coordinate (i.e. the coordinate which corresponds to [┌r/c┐]). Let CC2 be the corresponding family of subsets, i.e.

CC2={Sƒ|ƒεCF2}  (46)

where Sƒ={xεD|ƒ(x)≠0}. Here, ƒ(x)=g(xi−1)−g(xi) for some gεFq[X]. The number of sets Sƒ of this type is (t−1)qr. We denote

CC1={SR||R|≦r}U CC2  (47)

To show that |CC1|=O(tqr), we bound the number of sets {SR}. Up to a constant factor, this number is,




  
    
      
        
          
            ⌈
            
              r
              c
            
            ⌉
          
          r
        
        ⁢
        
          (
          
            
              
                q
              
            
            
              
                r
              
            
          
          )
        
      
      ≤
      
        
          
            ⌈
            
              r
              c
            
            ⌉
          
          r
        
        ⁢
        
          
            (
            
              qc
              r
            
            )
          
          r
        
      
      ≤
      
        
          (
          
            
              (
              
                
                  r
                  c
                
                +
                1
              
              )
            
            ⁢
            
              qc
              r
            
          
          )
        
        r
      
      ≤
      
        
          
            (
            
              1
              +
              
                c
                r
              
            
            )
          
          r
        
        ⁢
        
          q
          r
        
      
      ≤
      
        
          e
          c
        
        ⁢
        
          q
          r
        
      
    
    =
    
      O
      ⁡
      
        (
        
          q
          r
        
        )
      
    
  
  ,




where we used that since





  
    (
    
      
        
          n
        
      
      
        
          r
        
      
    
    )
  
  =
  
    
      (
      
        nc
        /
        r
      
      )
    
    r
  




and q≦n, then





  
    (
    
      
        
          q
        
      
      
        
          r
        
      
    
    )
  
  ≤
  
    
      
        (
        
          qc
          /
          r
        
        )
      
      r
    
    .
  




For constant




  α
  >
  
    
      1
      
        1
        -
        β
      
    
    +
    
      1
      t
    
  




and β>0.525 and assuming max(r60 ,r2+1/tt2)=O(n1/t), and for sufficiently large n, we describe an explicit





  (
  
    n
    ,
    
      O
      ⁡
      
        (
        
          
            
              (
              rt
              )
            
            2
          
          ⁢
          
            
              (
              
                
                  
                    n
                  
                
                
                  
                    r
                  
                
              
              )
            
            
              1
              /
              t
            
          
        
        )
      
    
    ,
    r
    ,
    t
  
  )




exclusive set system. Further, broadcasting in this system can be done in poly(r, t, log n) time.

For each x=(x0, x1, . . . , xt)εD, we define x′=(x1, . . . , xt)εFqt, i.e. x′ is the projection of x on Fqt. Let R′ denote the projection of R on Fqt, i.e. R′={xεD|x′εR}. Clearly, |R′|≦|R|. If the revoked set R is such that no two members share their ith coordinate for any i>1, the corresponding cover of t sets consists of the set SR and the sets Sƒi={xεD|ƒi(x)≠0}, i=2, . . . , t, wherein each ƒi does not depend on X0 and in fact belongs to Fq[X1, . . . , Xt]. Thus, we can write ƒi(x) as ƒi(x′), and

Sƒi=[┌r/c┐]×{x′|ƒi(x′)≠0}  (48)

Each ƒi is constructed as in (11). More particularly, the server constructs a polynomial giεFq[X] of a degree at most r−1 such that

gi(ui−1)=ui for each u=(u0, . . . , xt)εR

This is possible because for each i≧2, all ui−1 are distinct in R. See (10). Then the server sets:

ƒi=gi(X−1)−Xi

Clearly, ƒiεCF2 as defined by (45).

The union CR of the set SR of (44) and the sets Sƒi(i=2, . . . , t) equals the compliment of R. Indeed, if xεR, then x does not belong to SR, and ƒi(x)=0 for all i. Hence, x∉CR. Vice versa, if x∉CR, then its first two coordinates must agree with those of some uεR. It follows from distinctness and our construction that x=u.
For sets R which may or may not share their ith coordinate for some i>1, we proceed as in Lemma 2, ignoring the first coordinate. More particularly, at step 750, the server defines m=r2t disjoint blocks B1, . . . , Bm, wherein each of these blocks B consists of some elements b1, . . . , bt in Fq (see FIG. 12). This is possible if r2t2≦q. For each of these blocks B, the server defines a linear transformation LB:Fqt→Fqt as in (23). The server then defines CFB as in (15), and/or CFB1 as in (28), except that the server uses Fq instead of F (and Fq[X] instead of F[X]). For each x′εFqt, we let LBx′i denote the ith coordinate of LBx′, where i=1, . . . , t. The exclusive set system is as follows:

CC={SR,B||R|≦r, Bε{B1, . . . , Bm}}U{Sƒ|ƒεCFB for some Bε{B1, . . . , Bm}}  (49)

where

SR,B={x=(x0, x1, . . . , xt)εD|(x0,LBx1)≠(u0,LBu1) for all (u0,u1, . . . , ut)εR}  (50)

Alternatively, we can write:

CC={SR,B| for all |R|≦r and all B}U{Sƒ|ƒεCFB1 for some B}  (51)

where CFB1 is defined as in (28) except that F[X] is replaced with Fq[X].

Step 810 (FIG. 11) is performed as follows. For a given R⊂D, the server finds a block B for which LB is good for R′. The server constructs a cover CR for D\R as follows. One element of the cover is the set SR,B (50). The remaining elements are the sets {Sƒ|ƒε{ƒ2, . . . , ƒt}} where the polynomials ƒi (i≧2) are constructed as follows. For each fixed i=2, . . . , t the server finds a polynomial gi,R=giεFq[X] by interpolating from

gi(LBui−1)=LBui for each u′εR′

This is possible because all LBui are distinct. See (19). The server sets:

ƒi=gi(LBXi−1)−LBXi  (52)

Hence, CR={SR,B, Sƒ2, . . . , Sƒt}, where

Sƒi=Sƒi(R)={xε[n]|gi(LBxi−1)≠LBxi}  (53)

This technique works both for the sets R that share their ith coordinate for some i>1 and for the sets R that do not.
It will be apparent to one skilled in the art that if max(r60 ,r2+1/tt2)=O(n1/t), then it follows that




  
    
      
        
          max
          ⁡
          
            (
            
              
                r
                
                  1
                  +
                  ɛ
                
              
              ,
              t
            
            )
          
        
        ≤
        
          n
          
            1
            /
            t
          
        
      
    
    
      
        (
        54
        )
      
    
  
  
    
      
        r
        ≤
        
          
            (
            
              
                
                  n
                
              
              
                
                  r
                
              
            
            )
          
          
            
              (
              
                1
                -
                β
              
              )
            
            /
            t
          
        
      
    
    
      
        (
        55
        )
      
    
  
  
    
      
        
          
            r
            2
          
          ⁢
          
            t
            2
          
        
        ≤
        q
      
    
    
      
        (
        56
        )
      
    
  




The above argument constitutes a proof of the following theorem, which summarizes the parameters of our construction:
Theorem 9 Let




  α
  >
  
    
      1
      
        1
        -
        β
      
    
    +
    
      1
      t
    
  




and β>0.525 be any constants, and assume max(r60 ,r2+1/tt2)=O(n1/t). Then for sufficiently large n, there is an explicit





  (
  
    n
    ,
    
      O
      ⁡
      
        (
        
          
            
              (
              rt
              )
            
            2
          
          ⁢
          
            
              (
              
                
                  
                    n
                  
                
                
                  
                    r
                  
                
              
              )
            
            
              1
              /
              t
            
          
        
        )
      
    
    ,
    r
    ,
    t
  
  )




exclusive set system. Further, broadcasting can be done in poly(r, t, log n) time.

To apply the technique to the graph-based construction of Theorem 6, we replace (56) with

r2t=O(q)  (57)

At step 750 (FIG. 10), the server constructs a graph 1310 (FIG. 13) and associates its vertices b with the points of U′={x′|xε[n]} (the projection of [n] on Fqt). The server defines the exclusive set system CC as follows:

CC={SR||R|≦r}U CCƒ  (58)

where CCƒ is a set of polynomials in Fq[Xi, . . . , xt] of degree at most r. CCƒ is defined similarly to (30):





  
    
      
        
          CF
          f
        
        =
        
          
            {
            
              
                
                  
                    
                      
                        
                          
                            ∏
                            
                              j
                              =
                              1
                            
                            
                              r
                              ′
                            
                          
                          ⁢
                          
                            
                              (
                              
                                
                                  
                                    ∑
                                    
                                      i
                                      =
                                      0
                                    
                                    
                                      t
                                      -
                                      1
                                    
                                  
                                  ⁢
                                  
                                    
                                      b
                                      i
                                    
                                    ⁢
                                    
                                      X
                                      
                                        i
                                        +
                                        1
                                      
                                    
                                  
                                
                                -
                                
                                  i
                                  j
                                
                              
                              )
                            
                            ⁢
                            
                              ❘
                            
                            ⁢
                            0
                          
                        
                        ≤
                        
                          
                        
                        ⁢
                        
                          r
                          ′
                        
                        ≤
                        
                          
                        
                        ⁢
                        r
                      
                      ,
                    
                    ⁢
                    
                      
                    
                  
                
              
              
                
                  
                    
                      distinct
                      ⁢
                      
                        
                      
                      ⁢
                      
                        i
                        1
                      
                    
                    ,
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      
                        i
                        
                          r
                          ′
                        
                      
                      ∈
                      
                        F
                        q
                      
                    
                    ,
                    
                      b
                      ∈
                      V
                    
                  
                
              
            
            }
          
          ⋃
          
            {
            
              
                
                  
                    
                      
                        
                          g
                          ⁡
                          
                            (
                            
                              
                                ∑
                                
                                  i
                                  =
                                  0
                                
                                
                                  t
                                  -
                                  1
                                
                              
                              ⁢
                              
                                
                                  b
                                  i
                                
                                ⁢
                                
                                  X
                                  
                                    i
                                    +
                                    1
                                  
                                
                              
                            
                            )
                          
                        
                        -
                        
                          
                            ∑
                            
                              i
                              =
                              0
                            
                            
                              t
                              -
                              1
                            
                          
                          ⁢
                          
                            
                              c
                              i
                            
                            ⁢
                            
                              X
                              
                                i
                                +
                                1
                              
                            
                            ⁢
                            
                              ❘
                            
                            ⁢
                            g
                          
                        
                      
                      ∈
                      
                        
                          F
                          q
                        
                        ⁡
                        
                          [
                          X
                          ]
                        
                      
                    
                    ,
                  
                
              
              
                
                  
                    
                      
                        deg
                        ⁢
                        
                          
                        
                        ⁢
                        
                          (
                          g
                          )
                        
                      
                      ≤
                      
                        r
                        -
                        1
                      
                    
                    ,
                    
                      
                        (
                        
                          b
                          ,
                          c
                        
                        )
                      
                      ∈
                      E
                    
                  
                
              
            
            }
          
        
      
    
    
      
        (
        59
        )
      
    
  




CCƒ consists of the corresponding sets {xεD|ƒ(x)≠0} for ƒεCFƒ, and thus of all the sets S of the form:





  
    S
    =
    
      {
      
        x
        ∈
        
          
            [
            n
            ]
          
          ⁢
          
            ❘
          
          ⁢
          
            
              ∑
              
                i
                =
                0
              
              
                t
                -
                1
              
            
            ⁢
            
              
                b
                i
              
              ⁢
              
                x
                
                  i
                  +
                  1
                
              
            
          
        
        ∉
        
          {
          
            
              i
              1
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              i
              
                r
                ′
              
            
          
          }
        
      
      }
    
  
  ,




where 0≦r′≦r, distinct i1, . . . , ir′εFq, bεV, or





  
    S
    =
    
      {
      
        x
        ∈
        
          
            
              [
              n
              ]
            
            ⁢
            
              ❘
            
            ⁢
            
              g
              ⁡
              
                (
                
                  
                    ∑
                    
                      i
                      =
                      0
                    
                    
                      t
                      -
                      1
                    
                  
                  ⁢
                  
                    
                      b
                      i
                    
                    ⁢
                    
                      x
                      
                        i
                        +
                        1
                      
                    
                  
                
                )
              
            
          
          ≠
          
            
              ∑
              
                i
                =
                0
              
              
                t
                -
                1
              
            
            ⁢
            
              
                c
                i
              
              ⁢
              
                x
                
                  i
                  +
                  1
                
              
            
          
        
      
      }
    
  
  ,




where gεFq[X], deg(g)≦r−1, (b,c)εE.

At step 810 (FIG. 11), given a revoked set R, the server constructs a cover CR for [n]\R as shown in FIG. 18. Steps 810.1-810.3 of FIG. 18 are similar to the respective steps of FIG. 14 but are performed on R′ and Fqt instead of R and Ft. At step 810.1 (FIG. 18), the server finds a connected subgraph 1510 (FIG. 15) of at least t vertices that are good for R′. This can be done using techniques described above in connection with FIG. 14. Of note, |R′|≦|R|. At step 810.2 (FIG. 18), the server defines a tree 1610 (FIG. 16) which is a subgraph of the subgraph 1510. This again can be done as in FIG. 14.

At step 810.3 (FIG. 18), the server then constructs a cover CR as follows. Let v be the root of the tree 1610 constructed at step 810.2. One element of CR is:

SR,v={x=(x0, x1, . . . , xt)εD|(x0, px′(v))≠(u0,pu′(v) for all uεR}  (61)

For each non-root node b in the tree, the server finds a polynomial gb of degree at most |R′|−1 by interpolating from





  
    
      
        
          
            
              g
              b
            
            ⁡
            
              (
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    t
                    -
                    1
                  
                
                ⁢
                
                  
                    
                      p
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    i
                  
                  ⁢
                  
                    u
                    
                      i
                      +
                      1
                    
                  
                
              
              )
            
          
          =
          
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  t
                  -
                  1
                
              
              ⁢
              
                
                  b
                  i
                
                ⁢
                
                  u
                  
                    i
                    +
                    1
                  
                
                ⁢
                
                  
                
                ⁢
                for
                ⁢
                
                  
                
                ⁢
                all
                ⁢
                
                  
                
                ⁢
                
                  u
                  ′
                
              
            
            =
            
              
                (
                
                  
                    u
                    1
                  
                  ,
                  ...
                  ⁢
                  
                    
                  
                  ,
                  
                    u
                    t
                  
                
                )
              
              ∈
              
                R
                ′
              
            
          
        
        ,
        
          

        
        ⁢
        
          i
          .
          e
          .
        
        ,
      
    
    
      
        (
        62
        )
      
    
  
  
    
      
        
          
            
              g
              b
            
            ⁡
            
              (
              
                
                  p
                  
                    u
                    ′
                  
                
                ⁡
                
                  (
                  b
                  )
                
              
              )
            
          
          =
          
            
              
                
                  p
                  
                    u
                    ′
                  
                
                ⁡
                
                  (
                  b
                  )
                
              
              ⁢
              
                
              
              ⁢
              for
              ⁢
              
                
              
              ⁢
              all
              ⁢
              
                
              
              ⁢
              
                u
                ′
              
            
            ∈
            
              R
              ′
            
          
        
        ,
        
          

        
        ⁢
        
          and
          ⁢
          
            
          
          ⁢
          set
        
      
    
    
      
        (
        63
        )
      
    
  
  
    
      
        
          f
          b
        
        =
        
          
            
              g
              b
            
            ⁡
            
              (
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    t
                    -
                    1
                  
                
                ⁢
                
                  
                    
                      p
                      ⁡
                      
                        (
                        b
                        )
                      
                    
                    i
                  
                  ⁢
                  
                    X
                    
                      i
                      +
                      1
                    
                  
                
              
              )
            
          
          -
          
            
              ∑
              
                i
                =
                0
              
              
                t
                -
                1
              
            
            ⁢
            
              
                b
                i
              
              ⁢
              
                X
                
                  i
                  +
                  1
                
              
            
          
        
      
    
    
      
        (
        64
        )
      
    
  




Then CR={SR,v, Sƒb} is indeed a cover for [n]|R, as can be shown in a way similar to that given for Theorem 6.

If we use an




  (
  
    
      m
      =
      
        γ
        ⁢
        
          
        
        ⁢
        
          r
          2
        
        ⁢
        t
      
    
    ,
    6
    ,
    
      
        1
        2
      
      -
      
        
          5
        
        6
      
    
  
  )




expander graph is in Theorem 6, with γ as in (38), we arrive at the following theorem.

Theorem 10 Let




  α
  >
  
    
      1
      
        1
        -
        β
      
    
    +
    
      1
      t
    
  




and β>0.525 be any constants, and assume max(r60 ,r2+1/tt)=O(n1/t) . For sufficiently large n, there is an explicit





  (
  
    n
    ,
    
      O
      ⁡
      
        (
        
          
            
              r
              2
            
            ⁢
            
              
                t
                ⁡
                
                  (
                  
                    
                      
                        n
                      
                    
                    
                      
                        r
                      
                    
                  
                  )
                
              
              
                1
                /
                t
              
            
          
          ,
          r
          ,
          t
        
        )
      
    
  




-exclusive set system. Further, broadcasting can be done in poly(r, t, log n) time.

To adapt Theorem 8, we just need to change the third assumption (56) to r2t=O(q1−ε) for some ε>0. Indeed, as in the proof of Lemma 7, one skilled in the art can infer that the probability v that some sεS is not good for R can be bounded above by q−ε. By our assumption that r1+ε≦n1/t, we have n/r=nΩ(1) so that q−ε=n−Ω(1/t), and the proof of Lemma 7 goes through (with larger constants).
These arguments constitute a proof of the following theorem, which summarizes the parameters of the method described herein.
Theorem 11 Let




  
    α
    >
    
      
        1
        
          1
          -
          β
        
      
      +
      
        1
        t
      
    
  
  ,




β>0.525, and ε>0 be any constants, and assume that we have max(rα, r2+(1−ε)/tt)<n(1−ε)/t. Then there is an efficient algorithm that with probability 1−n−Θ(r), generates an





  (
  
    n
    ,
    
      O
      ⁡
      
        (
        
          
            r
            2
          
          ⁢
          
            
              t
              ⁡
              
                (
                
                  
                    
                      n
                    
                  
                  
                    
                      r
                    
                  
                
                )
              
            
            
              1
              /
              t
            
          
        
        )
      
    
    ,
    r
    ,
    t
  
  )




-exclusive set system. Broadcasting takes time poly(r, t, log n).

6 Method for Constructing Exclusive Set Systems from Smaller Exclusive Set Systems
The above methods were shown to provide low k values for restricted choices of n,r,t. We now show how to extend these methods to provide similar k values for arbitrary n,r,t. We construct many small exclusive set systems on different subsets of [n] and take their union to obtain the final explicit exclusive set system. Each of the small systems will be constructed with parameters nB,rB,tB (where B is some index) satisfying the requirements of the schemes in the previous Sections.
FIG. 19 illustrates this technique. Let U be the set of all users (e.g. U=[n]). U is subdivided into disjoint subsets UB, say U1, U2, . . . . Denote nB=|UB|. Suppose that an (nB,kB,rB,tB)-exclusive set system CC(UB) is defined over UB for each B. Let R⊂U. Denote RB=R∩UB, and suppose |RB|≦rB for all B. Then each UB\RB can be covered with at most tB elements {SB,1,SB,2, . . . } of CC(UB), and hence U\R can be covered with the union of these elements over all B:




  
    U
    ⁢
    \
    ⁢
    R
  
  =
  
    
      ⋃
      
        B
        ,
        j
      
    
    ⁢
    
      S
      
        B
        ,
        j
      
    
  




The union contains at most ΣtB sets SBj.

Of note, an (nB,kB,rB,tB)-exclusive set system for UB can be build from an (n,kB,rB,tB)-exclusive set system for a larger set U′B⊃UB (FIG. 20), with |U′B|=n. Indeed, if sets {S} form an (n,kB,rB,tB)-exclusive set system for U′B, then the sets {S∩UB} form an (nB,kB′,rB,tB)-exclusive set system for UB with kB′≦kB. The set U′B can be constructed by augmenting UB with any additional points.
In FIG. 19, the sets UB were chosen so that |R∩UB|≦rB. We may need many subset collections {UB} to enable such choice for all the sets R with |R|≦r. We denote the total collection of such subsets as {UB}. In some embodiments, at the set-up stage (FIG. 21), the server defines a family of subsets UB⊂U (step 2110), and defines one or more exclusive set systems CC(UB) for each UB (step 2120). In some embodiments, at step 2120, the server performs step 750 of FIG. 7 or 10 for each UB,. In some embodiments, each system CC(UB) meets the requirements of some of the previous constructions, e.g. of Theorem 3, 6, 9, 10 or 11.
The exclusive set system CC(U) output by the server is the union of systems CC(UB). The server performs steps 760, 770 (FIG. 7 or 10) for each SεCC(U).
To perform a broadcast (FIG. 22), given a revoked set R, the server finds a family of disjoint subsets UB (step 2210), and applies the technique of FIG. 19. In particular, the subsets UB are chosen so that their union is U, and further the corresponding exclusive set systems CC(UB) constructed at step 2120 are (nB,kB,rB,tB)-exclusive set systems such that |RB|≦rB where RB=R∩UB. The server then selects a cover for each UB\RB from the respective system CC(UB). See step 2220. This step may include the steps 810, 820 (FIG. 8 or 11) for each B. The union of these covers provides a cover for U\R. Then the server performs a broadcast as in FIG. 4A.
In some embodiments, the size of our system CC(U) will be k=poly(r, t, log n)nr/t, matching the lower bound up to the poly(r, t, log n) factor and the optimizations described in conjunction with key complexity balancing (Theorems 9-11). Here poly(r, t, log n) denotes a polynomial in r, t and log n.
We now describe one embodiment of this construction. In this embodiment, for each index B, the server constructs up to four exclusive set systems CC(UB) at step 2120 as described below. A separate familty of the UB sets is performed for each revoked set size r′ such that 0≦r′≦r. At the broadcast stage, given a set R with |R|=r′, the server will use the exclusive set systems constructed for the revoked set size r′. The key complexity is largest for the revoked set size of r, so the union will be at most r+1 times larger.
We now describe how to construct the family for a fixed r′. We may assume r′≧1, because the construction is trivial for r′=0 (just take the entire set U as the element of the exclusive set system).
In some embodiments, the sets UB are chosen as follows. First, the server defines (d+1)-dimensional coordinate systems on U where

d=log n/log r′2  (65)

More particularly, let

q≧r′2d  (66)

be prime (possibly, but not necessarily, the smallest prime satisfying (66)). Then

qd+1≧n,  (67)

so the points in U can be identified with points in Fqd+1 using some injective mapping A:

A(x)=(x0, . . . , xd)εFqd+1  (68)

as shown in FIG. 23. We will sometimes write x=(x0, . . . , xd). Further, each point x=(x0, . . . , xd) can be identified with a degree-d polynomial px(X)εFq[X] as in (24):

px(X)=x0+x1X+. . . +xdXd  (69)

Since q>d (see (66)), each polynomial px (and hence each point x) is completely defined by its values on any given (d+1) points of Fq. These values serve as coordinates for our coordinate systems. We define a coordinate system ei for each element iεFq by choosing a sequence of (d+1) points {bi,0, bi,1, . . . , bi,d} of Fq. This sequence of points will define the system ei in a way similar to the blocks B in FIGS. 12 and (23)-(25). Any sequence of points can be chosen. In some embodiments, different sets of points are chosen for different i. In the embodiment being described, bi,0=i for all i.
In each coordinate system ei, each xεU is represented as

x=(px(bi,0), px(bi,1), . . . , px(bi,d))εFqd+1  (70)

In our case, bi,0=i, so

x=(px(i), px(bi,1), . . . , px(bi,d))  (71)

See FIG. 23. To avoid ambiguity when specifying coordinates in this coordinate system, we will sometimes use the subscript i at the end as follows:

x=(x0, x1, . . . , xd)i

This expression means therefore that xj=px(bi,j), j=0, . . . , d (to distinguish from (68)).

We will say that an element iεFq is “good for R” if

pu(i)≠pv(i) for any u, vεR  (72)

Otherwise, i will be called “bad for R”.

At step 2210 (FIG. 22), the server will choose a coordinate system ei such that i is good for R. Such a coordinate system exists because for any r′ degree-d polynomials in Fq[X] there is a point in Fq on which the polynomials all differ. Indeed, any two degree-d polynomials agree on at most d points, so for a set of r′ polynomials, the number of points on which at least two of the polynomials agree has cardinality at most




  
    
      (
      
        
          
            
              r
              ′
            
          
        
        
          
            2
          
        
      
      )
    
    ⁢
    d
  
  ,




which is less than q (see (66)).

At step 2210 the server finds i good for R and also finds disjoint subsets U1,U2, . . . ε{UB}, see FIG. 19, such that |R∩UB|≦rB for all UB. Since all the elements u=(u0, . . . , ud)i of R have different first coordinates u0=pu(i)εFq (see (72)), the sets UB are constructed based on the first coordinates. More particularly, loosely speaking, the server subdivides Fq into non-empty disjoint intervals [aj,bj] (j=1, 2, . . .) each of which contains at most some number rB of first coordinates of R:

|{u0|u=(u0, . . . , ud)iεR}∩[aj,bj]|≦rB  (73)

For each B, UB is defined as follows:

UB=[aj,bj]×Fqd  (74)

Actually, we can define UB as the subset of [aj,bj]×Fqd which is the set of all points in U whose first coordinate is in [aj,bj] in the ei coordinate system.

To enable such a construction, the sets UB are defined as follows at step 2110. One set UB is defined for each coordinate system ei and each non-empty interval [a,b]ε[0,q−1]:

UB=Ui,[a,b]=[a,b]×Fqd  (75)

or rather UB is the set of all the points in U whose first coordinate is in [a,b] in the ei coordinate system. Clearly, the number of non-empty intervals [a,b] is less than q2, so the total number of sets UB (for all the systems ei, i=0, . . . , q−1) is less than q3.

For each UB, the server defines up to four exclusive set systems at step 2120, as described below.
Clearly, if UB=Ui,[a,b], then nB=b−a+1. However, we will use the technique of FIG. 20 to set nB=n. The exclusive set systems will be (n,kB,rB,tB)-exclusive, with up to four different combinations of parameters kB,rB,tB. More particularly, we will define parameters ρ and τ such that rB=ρ or ρ−1, and tB=τ or τ+1.
In constructing the systems CC(UB), let us apply, for example, the scheme of Theorem 3, 6, 9, 10 or 11. In particular, we choose some β>0.525 such that (1−β)−1ε(2,3). Then α<4, and rBα<rB4. Turning to Theorem 9 for example, we see that rB2+1/tB≦rB3. Thus, the Theorem 9 condition is satisfied if:

max(rB4,rB3tB2)=O(n1/t).  (76)

This condition is satisfied in turn if

rB4tB2<n1/tB  (77)

This last condition is satisfied if

rB4tB<n1/2tB  (78)

The inequality (78) is also sufficient to accommodate Theorems 3, 6, 10 and 11. We will therefore define the exclusive set systems CC(UB) such that

rB4tB<n1/2tB  (79)

The CC(UB) key complexity is O((rBtB)2nrB/tB) for Theorem 3, O(rB2tB nrB/tB) for Theorem 6,




  O
  ⁡
  
    (
    
      
        
          (
          
            
              r
              B
            
            ⁢
            
              t
              B
            
          
          )
        
        2
      
      ⁢
      
        
          (
          
            
              
                n
              
            
            
              
                
                  r
                  B
                
              
            
          
          )
        
        
          1
          /
          
            t
            B
          
        
      
    
    )
  




for Theorem 9,





  O
  ⁡
  
    (
    
      
        r
        B
        2
      
      ⁢
      
        
          
            t
            B
          
          ⁡
          
            (
            
              
                
                  n
                
              
              
                
                  
                    r
                    B
                  
                
              
            
            )
          
        
        
          1
          /
          
            t
            B
          
        
      
    
    )
  




for Theorem 10, and





  O
  ⁡
  
    (
    
      
        r
        B
      
      ⁢
      
        
          
            t
            B
          
          ⁡
          
            (
            
              
                
                  n
                
              
              
                
                  
                    r
                    B
                  
                
              
            
            )
          
        
        
          1
          /
          
            t
            B
          
        
      
    
    )
  




for Theorem 11. Since





  
    
      
        (
        
          
            
              n
            
          
          
            
              
                r
                B
              
            
          
        
        )
      
      
        1
        /
        
          t
          B
        
      
    
    ≤
    
      n
      
        
          r
          B
        
        /
        
          t
          B
        
      
    
  
  ,




the key complexity for these cases does not exceed

poly(rB,tB)nrB/tB

where poly(rB,tB) is a suitable polynomial in rB,tB (the polynomial is equal to (rBtB)2 for Theorems 3 and 9, rB2tB for Theorems 6 and 10, and rBtB for Theorem 11). We will therefore choose rB and tB so that

rB/tB≈r′/t

In fact, we will choose ρ and τ so that

ρ/τ≈r′/t  (80)

Loosely speaking, if each RB has about rB≈ρ points at step 2210, then the number of sets UB is roughly r′/ρ. If each cover CC(UB) constructed at step 2220 has about tB≈τ sets, the total complement cover CR will have about (r′/ρ)τ sets. By virtue of (80), this number is about t, which is what we need for a complement cover.
Given the parameters n,r′,t, if r′4t<n1/2τ(as in (78)), the server may use the scheme of Theorem 3, 6, 9, 10 or 11 directly to define a single (n,k,r′,t)-exclusive set system for U, without subdividing U into subsets UB. Otherwise, if possible, we will choose ρ and τ to satisfy subject to the constraint




  
    
      
        
          
            Ω
            ⁡
            
              (
              
                n
                
                  1
                  
                    4
                    ⁢
                    
                      
                    
                    ⁢
                    τ
                  
                
              
              )
            
          
          ≤
          
            
              ρ
              4
            
            ⁢
            τ
          
          <
          
            n
            
              1
              
                2
                ⁢
                
                  
                
                ⁢
                τ
              
            
          
        
        ,
      
    
    
      
        (
        81
        )
      
    
  
  
    
      
        
          
            ρ
            -
            1
          
          τ
        
        <
        
          
            r
            ′
          
          t
        
        ≤
        
          
            ρ
            τ
          
          .
        
      
    
    
      
        (
        82
        )
      
    
  




The following algorithmic procedure illustrates how to find ρ and τ.

Procedure Generate(r′,t):

    
    
        1. Set integer variables ρ=r′ and τ=t.
        2. i=2.
        3. While τ>1,
        
            (a) If ρ4τ<1/2τ, then exit.
            (b) Else,
            
                i. τ=└t/i┘.
                ii. Choose ρ so that
            
            
        
        
    
    






  
    
      ρ
      -
      1
    
    τ
  
  <
  
    
      r
      ′
    
    t
  
  ≤
  
    
      ρ
      τ
    
    .
  




    
    
        
        
            
            
                iii. i=i+1.
            
            
        
        
    
    


End of Generate
It will be apparent to one skilled in the art after reviewing the foregoing argument that the above procedure leads to finding such ρ and τ. It should be borne in mind, however, that the invention may be practiced without knowledge of the details of this proof. These details are included to demonstrate the correctness and feasibility of the steps outlined toward achieving the objectives of the present invention.
Lemma 12. If Generate outputs (ρ,τ)≠(r′,t) and τ≠1, then ρ,τ satisfy constraints (81) and (82).
Proof: Suppose τ≠1. Then in some iteration we have ρ4τ<n1/(2τ). If this occurs in the first iteration, then we have (ρ,τ)=(r′,t). Otherwise, consider the last time for which ρ4τ≧n1/(2τ). Suppose τ=└t/i┘, and let τ′=└t/(i+1)┘ be the value of τ in the next iteration. Note that τ,τ′>1. Then τ′/τ=└t/(i+1)┘/└t/i┘. Suppose └t/(i+1)┘=c. Then t≦(c+1)(i+1)−1, so that




  
    
      ⌊
      
        t
        /
        i
      
      ⌋
    
    ≤
    
      ⌊
      
        
          
            (
            
              
                i
                +
                1
              
              i
            
            )
          
          ⁢
          
            (
            
              c
              +
              1
            
            )
          
        
        -
        
          1
          i
        
      
      ⌋
    
  
  =
  
    
      ⌊
      
        c
        +
        1
        +
        
          c
          /
          i
        
      
      ⌋
    
    .
  




Thus,

τ′/τ≧c/(c+1+c/i)≧1/(1+1/c+1/i)≧1/2,

since c,i>1 are integers. We also claim that ρ′≧ρ/4, where ρ′ is the value of ρ in the next iteration. Indeed, if ρ≦4, this follows from the fact that ρ′ is a positive integer. On the other hand, if for ρ>4 we had ρ′<ρ/4, then





  
    
      
        
          ρ
          ′
        
        
          τ
          ′
        
      
      <
      
        
          ρ
          /
          4
        
        
          τ
          /
          2
        
      
    
    =
    
      
        
          ρ
          /
          2
        
        τ
      
      <
      
        
          ρ
          -
          1
        
        τ
      
      ≤
      
        
          r
          ′
        
        t
      
    
  
  ,




contradicting constraint (82), which holds because of step 3(b)ii. Thus,





  
    
      
        
          
            (
            
              ρ
              ′
            
            )
          
          4
        
        ⁢
        
          τ
          ′
        
      
      ≥
      
        
          
            ρ
            4
          
          ⁢
          τ
        
        
          2
          ·
          
            4
            4
          
        
      
      ≥
      
        
          n
          
            1
            
              2
              ⁢
              
                
              
              ⁢
              τ
            
          
        
        
          2
          ·
          
            4
            4
          
        
      
    
    =
    
      Ω
      ⁡
      
        (
        
          n
          
            1
            
              4
              ⁢
              
                
              
              ⁢
              
                τ
                ′
              
            
          
        
        )
      
    
  
  ,




which shows that constraint (81) holds.

We can now, for instance, apply the explicit construction of Theorem 3, 6, 9, 10 or 11 to individual sets UB=Ui,[a,b].
At the set-up stage (FIG. 24), at step 2410, the server determines if r4t<n1/(2t). If so, the server constructs CC(U) as in Theorem 3, 6, 9, 10, or 11 (step 2420). If not, step 2421 is performed for each r′ value from r down to 0. At step 2422, the server determines if r′4t<n1/(2t). If so, the server constructs an (n,kB,r′,t)-exclusive set system CC(U) as in Theorem 3, 6, 9, 10, or 11 (step 2424). The same complement cover will work for smaller r′ values, so in some embodiments the set-up stage terminates at this step. If the inequality of step 2422 does not hold, then at step 2430 (FIG. 24), the server determines d, q as in (65), (66), and runs Generate (r′,t) to obtain ρ and τ. The server also selects some mapping A as in (68), as shown at 2440. At step 2450, the server defines the coordinate systems ei by choosing the blocks (bi,0bi,1, . . . , bi,d) for each i (see FIG. 23), possibly with bi,0=i. At step 2460, the server generates an (n,kB,ρ−1,τ)-exclusive set system, an (n,kB,ρ,τ)-exclusive set system, an (n,kB,ρ−1,τ+1)-exclusive set system, and an (n,kB,ρ−1,τ+1)-exclusive set system (which can be collectively denoted as CC(Ui,[a,b])) for each Ui,[a,b]. Each of these exclusive set systems is generated as in Theorem 3, 6, 9, 10 or 11, with suitable (possibly different) kB parameters as defined in these Theorems.
To broadcast with a revoked set R (FIG. 25) of a size r′, if r4<n1/2t) (step 2510), then the server constructs a complement cover from the corresponding exclusive set system constructed at step 2420 (FIG. 24). If the inequality of step 2510 does not hold, but r′4<n(1/2t) (step 2522), the server constructs a complement cover from the corresponding exclusive set system constructed at step 2424. If the inequality of step 2522 does not hold, the server uses the d, q, A parameters determined at steps 2430, 2440 (or re-computes these parameters). For these parameters, the server finds a coordinate system ei good for R, i.e. a system in which the elements of R all differ on their first coordinate (if r′=1, any system ei will do). See step 2530. At step 2540, the server partitions the interval [0,q−1] into one or more disjoint intervals [aj,bj] (j=1, 2, . . . ) such that each interval [aj,bj] contains rj values of the first coordinates of R, where rj is either ρ−1 or ρ. At step 2550, for each j (i.e. for each interval [aj,bj]), the server determines the corresponding tj value for the complement cover size, such that tj is either τ or τ+1 and Σtj=t. Then the server selects a cover for each set UB\RB, where UB corresponds to [aj,bj]×Fqd and RB=R∩UB. Each cover is selected from the corresponding (n,kB,rj,tj)-exclusive set system constructed at step 2460 (FIG. 24). The union of these covers forms a cover for U\R in CC(U), as explained above in connection with FIG. 19.
In the foregoing, the key complexity is derived. It should be borne in mind, however, that the following argument is provided to demonstrate that the methods presented herein achieve the desired performance claims and that the invention may be practiced without reference to this argument. It should be apparent to one skilled in the art after reviewing the following argument that the set system described herein uses poly(r, t, log n)nr/t keys. In particular, for each value of r′, there are q coordinate systems ei. For each system ei, there are no more than q2 intervals [a,b]. Each interval corresponds to an exclusive set system generated by Theorem 3, 6, 9, 10 or 11 on n points with the number rB of revoked users being either ρ or ρ−1 and the cover size tB either τ or τ+1. To analyze the number of keys per interval, we divide the output of Generate into two cases (recall that at this point we need only consider (ρ,τ)≠(r,t)).
Case 1: τ≠1. In this case the number of keys per interval is at most

poly(rB,tB)nrB/tB≦poly(r,t)nρ/τ

≦poly(r,t)nr/tn1/τ

≦poly(r,t)nr/t,

where the second inequality follows by constraint (82) and the third by constraint (81).

Case 2: τ=1. Then by the analysis in Lemma 12, we have ρ4=Ω(n1/4). We have exactly the same sequence of inequalities as in case 1, where the second inequality follows again by constraint (82), but now the third inequality follows from the fact that r≧rB=nΩ(1), so that poly(r)=n1/τ.
Thus, the total number of keys is q·q2·poly(r, t, log n)nr/t=poly(r, t, log n)nr/t.
The above argument constitutes a proof to the following theorem which summarizes the performance parameters achieved by our construction.
Theorem 13. Let n,r,t be positive integers and suppose n is sufficiently large. There is an explicit (n, poly(r, t, log n)nr/t,r,t)-exclusive set system. Broadcasting can be done in poly(r, t, log n) time.
Remark 14. It should be apparent to one skilled in the art that a number of optimizations are possible. For example, we can use randomness in the generation of the coordinate systems so that the n points are evenly-distributed along the interval [0,q−1]. We can also use random permutations of [0,q−1] so that for a given broadcast, each interval has about n/r users, resulting in complexity




  
    
      poly
      ⁡
      
        (
        
          r
          ,
          t
          ,
          
            log
            ⁢
            
              
            
            ⁢
            n
          
        
        )
      
    
    ⁢
    
      
        (
        
          
            
              n
            
          
          
            
              r
            
          
        
        )
      
      
        1
        /
        t
      
    
  
  ,




together with a smaller poly(r, t, log n) factor.

The invention is not limited to the embodiments described above. For example, instead of covering [n]\R with sets Sƒ on which some functions ƒ are not zero, one can cover [n]\R with sets on which some functions ƒ are not equal to some other predefined value, e.g. 1. For Theorems 9-11, the sets SR may involve more than two coordinates. For example, (61) can be replaced with:

SR,v={x=(x0, x1, . . . , xt)εD|(x0, x1,px′′(v))≠(u0,pu′′(v) for all uεR}

where x′′=(x2, . . . , xt) and the pertinent graphs are defined on Fqt−1. Other embodiments and variations are within the scope of the invention, as defined by the appended claims.

Regarding the terminology, if a function is a polynomial in some variables e.g. xi−1and xi, then the function can be referred to as a polynomial in a larger number of variables, e.g. x0 through xt, even though the function is independent of the variables other than xi−1and xi. For example, the functions ƒb in (64) depend only on X1, . . . , Xt, but can be referred to as polynomials in X0, . . . Xt, or in x0, . . . , xt.
The following references are incorporated herein by reference.
REFERENCES


    [1] W. Aiello, S. Lodha, and R. Ostrovsky. Fast digital identity revocation. In In proceedings of Asiacrypt '01, 2001.
    [2] R. C. Baker, G. Harman, and J. Pintz. The difference between consecutive primes II, London Math. Soc. (3) 83 (2001), pp. 532.562.
    [3] U. Feige. A threshold of ln n for approximating set cover, JACM, 1998, pp. 634-652.
    [4] A. Fiat and M. Naor. Broadcast encryption, Crypto, 1993, pp. 480-491.
    [5] E. Gafni, J. Staddon, and Y. L. Yin. Efficient methods for integrating traceability and broadcast encryption, Crypto, 1999, pp. 372-387.
    [6] S. Jukna. Extremal Combinatorics with Applications in Computer Science, Springer-Verlag, 2001.
    [7] R. Kumar, S. Rajagopalan, and A. Sahai. Coding constructions for blacklisting problems without computational assumptions, Crypto, 1999, pp. 609-623.
    [8] R. Kumar and A. Russell. A note on the set systems used for broadcast encryption, SODA, 2003, pp. 470-471.
    [9] J. Lotspiech, D. Naor, and M. Naor. Revocation and tracing schemes for stateless receivers, Crypto, 2001, pp. 41-62.
    [10] A. Lubotzky, R. Phillips, and P. Samak. Explicit expanders and the Ramanujan conjectures, STOC, pp. 240-246. See also: A. Lubotzky, R. Phillips, and P. Sarnak, Ramanujan graphs, Combinatorica 8, 1988, pp. 261-277.
    [11] M. Luby and J. Staddon. Combinatorial Bounds for Broadcast Encryption, Eurocrypt, 1998, pp. 512-526.
    [12] C. Lund and M. Yannakakis. On the hardness of approximating minimization problems, JACM, 1994, pp. 960-981.
    [13] S. Micali. Efficient Certificate Revocation. MIT/LCS/TM 542b, Massachusetts Institute of Technology, 1996.
    [14] S. Micali. Efficient Certificate Revocation. In Proceedings of the RSA Data Security Conference, 1997. Also U.S. Pat. No. 5,666,416.
    [15] S. Micali. NOVOMODO: scalable certificate validation and simplified PKI management. In Proceedings of the 1st Annual PKI Research Workshop, 2002.

## Claims

1. A computer-implemented method for generating data representing an exclusive set system over a set U of entities such that each element of the exclusive set system is associated with cryptographic data, the method comprising:
obtaining, by a computer system comprising circuitry, one or more coordinate systems for the set U, wherein each coordinate system associates each entity in U with a plurality of coordinates;
determining, by the computer system, functions ƒ(u) each of which is defined on the set U, each function being a polynomial in one or more of the coordinates of u in at least one of the coordinate systems;
determining by the computer system, for each said function ƒ, a corresponding subset Sƒ⊂U such that ƒ is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein said exclusive set system comprises the subsets Sƒ, and wherein each subset Sƒ is associated with first cryptographic data for use in a cryptographic operation which is for:
(a) receiving a first input associated with an entity;
(b) receiving a second input associated with a validity property of the entity and/or with an entitlement operable to be provided to the entity; and
(c) combining the first input and the second input to prove the validity property and/or provide the entitlement;

wherein at least one subset Sƒ has a plurality of entities, and the associated first cryptographic data are for providing the first input for each entity in the subset Sƒ;
wherein said one or more coordinate systems comprise a first coordinate system which comprises s coordinates where s is a predefined integer greater than one, each coordinate having values in a finite field having fewer elements than the number of entities in the set U;
wherein for the first coordinate system, for at least one pair (i,j) of the s coordinates in the first coordinate system, for at least one subset R of U, the following property (A) holds:
(A) said functions ƒ(u) comprise a first function ƒƒ(u) which is a polynomial in the ith and jth coordinates, wherein for each entity u in U the value of the jth coordinate of u is completely defined by the value of the ith coordinate of u and the value of the first function ƒƒ(u) on the entity u, wherein the first function ƒƒ(u) is equal to said predefined value on the subset R;

wherein the method further comprises outputting said first cryptographic data for use by devices as the first input in said cryptographic operation, wherein the devices are for obtaining second cryptographic data for use as the second input in the cryptographic operation to prove the validity property and/or provide the entitlement for each entity of one or more of the subsets Sƒ.

2. The method of claim 1 wherein:
(1) each entity represents a user operable to receive encrypted information over a network, and each said subset Sƒ is associated with said first cryptographic data which includes a decryption key DKƒ provided to the users that are members of the subset Sƒ, the key being provided for decrypting said information; or
(2) each entity represents a cryptographic digital certificate, and each said subset Sƒ is associated with said first cryptographic data which includes validity data VDƒ for verifying that the subset Sƒ contains only valid certificates or only invalid certificates.

3. A computer system which comprises one or more processors and which is adapted to perform the method of claim 1.

4. A non-transitory manufacture comprising a computer-readable computer program comprising one or more computer instructions operable to perform the method of claim 1 when executed by a computer system.

5. A network transmission method comprising transmitting, over a computer network, data carrier signals carrying a computer program operable to perform the method of claim 1 when executed by a computer system.

6. The method of claim 1 wherein in the first coordinate system, no two entities in R have identical ith coordinates, and no two entities in R have identical jth coordinates.

7. The method of claim 6 wherein (A) holds for each subset R of U for which:
R has no more than a predefined number r of entities wherein r is an integer greater than one but smaller than the number of entities in U, and
for any coordinate i in the first coordinate system, no two entities in R have identical values of the ith coordinate.

8. The method of claim 7 wherein for each subset R of U having at least one but not more than r entities, the one or more coordinate systems comprise a coordinate system corresponding to R such that:
for each coordinate, no two entities in R have identical values of the coordinate; and
(A) holds for R and at least a pair of the coordinates.

9. The method of claim 8 wherein for each subset R of U having at least one but not more than r entities, the coordinate system corresponding to R comprises a sequence of coordinates such that (A) holds for any two adjacent coordinates (ij) in said sequence if i immediately precedes j.

10. The method of claim 9 wherein, for each subset R of U having at least one but not more than r entities, for the coordinate i0 which is the first coordinate in said sequence, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

11. The method of claim 8 wherein for each subset R of U having at least one but not more than r entities, the coordinate system corresponding to R comprises a plurality of coordinates which form nodes of a tree in which at least one node has at least two immediate children, wherein (A) holds for any two adjacent coordinates (i,j) in said sequence if i is the immediate parent of j.

12. The method of claim 11 wherein, for each subset R of U having at least one but not more than r entities, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

13. The method of claim 8 wherein, for each subset R of U having at least one but not more than r entities, in the coordinate system corresponding to R, for at least one coordinate i0, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

14. The method of claim 1 wherein the coordinates of the first coordinate system comprise a plurality of coordinates forming nodes of a tree, wherein (A) holds for any two adjacent coordinates (i,j) in said sequence if i is the immediate parent of j.

15. The method of claim 14 wherein, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

16. A computer-implemented method for selecting a family of subsets of a set U such that each of said subsets is associated with cryptographic data, wherein the union of said subsets includes a predefined set of valid entities and excludes a predefined set R of invalid entities, the method comprising:
determining, by a computer system comprising circuitry, functions ƒ(u) each of which is defined on the set U, wherein each entity u εU is associated with a plurality of coordinates in each of one or more coordinate systems, and each function ƒ(u) is a polynomial in one or more of the coordinates of u in at least one of the coordinate systems, wherein all of said functions are equal to a predefined value on any entity u in R, and wherein for each valid entity u, at least one of said functions is not equal to the predefined value on the valid entity;
determining by the computer system, for each said function ƒ, a corresponding subset Sƒ of the valid entities on which the function is not equal to the predefined value, wherein said family of subsets comprises the subsets Sƒ, and wherein each subset Sƒ is associated with first cryptographic data for use in a cryptographic operation which is for:
(a) receiving a first input associated with an entity;
(b) receiving a second input associated with a validity property of the entity and/or with an entitlement operable to be provided to the entity; and
(c) combining the first input and the second input to prove the validity property and/or provide the entitlement;

wherein at least one subset Sƒ has a plurality of entities, and the associated first cryptographic data are for providing the first input for each entity in the subset Sƒ;
wherein said one or more coordinate systems comprise a first coordinate system which comprises s coordinates where s is a predefined integer greater than one, each coordinate having values in a finite field having fewer elements than the number of entities in the set U;
wherein for the first coordinate system, for at least one pair (i,j) of the s coordinates in the first coordinate system, the following property (A) holds:
(A) said functions ƒ(u) comprise a first function ƒƒ(u) which is a polynomial in the ith and jth coordinates, wherein for each entity u in U the value of the jth coordinate of u is completely defined by the value of the ith coordinate of u and the value of the first function ƒƒ(u) on the entity u, wherein the first function ƒƒ(u) is equal to said predefined value on the subset R;

wherein the method further comprises generating second cryptographic data for use as the second input in the cryptographic operation for each subset Sƒ and transmitting the second cryptographic data for use in the cryptographic operation.

17. The method of claim 16 wherein:
(1) each entity represents a user operable to receive encrypted information over a network, and the valid entities are entities entitled to receive the information, and the entities in the set R are not entitled to receive the information, and each said subset Sƒ is associated with said first cryptographic data which includes a decryption key DKƒ provided to the users in the subset Sƒ for decrypting said information, and the second cryptographic data includes the encrypted information; or
(2) each entity represents a cryptographic digital certificate, and wherein each said subset Sƒ is associated with said first cryptographic data which includes validity data VDƒ for verifying that the subset Sƒ contains only valid certificates or only invalid certificates, and the second cryptographic data includes a validation proof for each entity in each said subset Sƒ of the valid entities as determined by the computer system for each said function ƒ.

18. A computer system which comprises one or more processors and which is adapted to perform the method of claim 16.

19. A non-transitory manufacture comprising a computer-readable computer program comprising one or more computer instructions for a computer system to perform the method of claim 16.

20. A network transmission method comprising transmitting, over a computer network, a computer program for a computer system to perform the method of claim 16.

21. The method of claim 16 wherein in the first coordinate system, no two entities in R have identical ith coordinates, and no two entities in R have identical jth coordinates.

22. The method of claim 21 wherein the first coordinate system comprises a sequence of coordinates such that (A) holds for any two adjacent coordinates (i j) in said sequence if i immediately precedes j.

23. The method of claim 22 wherein, for the coordinate i0 which is the first coordinate in said sequence, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

24. The method of claim 21 wherein the first coordinate system comprises a plurality of coordinates which form nodes of a tree in which at least one node has at least two immediate children, wherein (A) holds for any two adjacent coordinates (if) in said sequence if i is the immediate parent of j.

25. The method of claim 24 wherein, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

26. The method of claim 16 wherein the coordinates of the first coordinate system comprise a plurality of coordinates forming nodes of a tree, wherein (A) holds for any two adjacent coordinates (i,j) in said sequence if i is the immediate parent of j.

27. The method of claim 26 wherein, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

28. A computer-implemented method for generating data representing an (n, k, r, t)-exclusive set system over a set U of entities such that each element of the exclusive set system is associated with cryptographic data, wherein n=|U|, and wherein k, r, and t are predefined positive integers, the method comprising:
obtaining, by a computer system comprising circuitry, one or more coordinate systems for the set U, wherein each coordinate system associates each entity in U with a plurality of coordinates; and
determining, by the computer system, one or more subsets S⊂U in the exclusive set system, each one of said subsets S is a subset Sƒ corresponding to a function ƒ(u) such that ƒ(u) is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein each function ƒ(u) is a polynomial in one or more of the coordinates of u in at least one of the coordinate systems, the degree of ƒ(u) being at most r, wherein each subset Sƒ is associated with first cryptographic data for use in a cryptographic operation which is for:
(a) receiving a first input associated with an entity;
(b) receiving a second input associated with a validity property of the entity and/or with an entitlement operable to be provided to the entity; and
(c) combining the first input and the second input to prove the validity property and/or provide the entitlement;

wherein at least one subset Sƒ has a plurality of entities, and the associated first cryptographic data are for providing the first input for each entity in the subset Sƒ;
wherein said one or more coordinate systems comprise a first coordinate system which comprises s coordinates where s is a predefined integer greater than one, each coordinate having values in a finite field having fewer elements than the number of entities in the set U;
wherein for the first coordinate system, for at least one pair (i,j) of the s coordinates in the first coordinate system, for at least one subset R of U, the following property (A) holds:
(A) said functions ƒ(u) comprise a first function ƒƒ(u) which is a polynomial in the ith and jth coordinates, wherein for each entity u in U the value of the jth coordinate of u is completely defined by the value of the ith coordinate of u and the value of the first function ƒƒ(u) on the entity u, wherein the first function ƒƒ(u) is equal to said predefined value on the subset R;

wherein the method further comprises outputting said first cryptographic data for use by devices as the first input in said cryptographic operation, wherein the devices are for obtaining second cryptographic data for use as the second input in the cryptographic operation to prove the validity property and/or provide the entitlement for each entity of one or more of the subsets Sƒ.

29. The method of claim 28 wherein:
(1) each entity represents a user operable to receive encrypted information over a network, and each said subset S is associated with said first cryptographic data which includes a decryption key DKs provided to the users that are elements of the subset S, the decryption key being provided for decrypting said information; or (2) each entity represents a cryptographic digital certificate, and wherein each said set S is associated with said first cryptographic data which includes validity data VDs for verifying that the set S contains only valid certificates or only invalid certificates.

30. The method of claim 29 wherein at least one of the functions ƒ is a polynomial of degree r.

31. A computer system which comprises one or more processors and which is adapted to perform the method of claim 28.

32. A non-transitory manufacture comprising a computer-readable computer program comprising one or more computer instructions for a computer system to perform the method of claim 28.

33. A network transmission method comprising transmitting, over a computer network, a computer program for a computer system to perform the method of claim 28.

34. The method of claim 28 wherein in the first coordinate system, no two entities in R have identical ith coordinates, and no two entities in R have identical jth coordinates.

35. The method of claim 34 wherein (A) holds for each subset R of U for which:
R has no more than a predefined number r of entities wherein r is an integer greater than one but smaller than the number of entities in U, and
for any coordinate i in the first coordinate system, no two entities in R have identical values of the ith coordinate.

36. The method of claim 35 wherein for each subset R of U having at least one but not more than r entities, the one or more coordinate systems comprise a coordinate system corresponding to R such that:
for each coordinate, no two entities in R have identical values of the coordinate; and
(A) holds for R and at least a pair of the coordinates.

37. The method of claim 35 wherein for each subset R of U having at least one but not more than r entities, the coordinate system corresponding to R comprises a plurality of coordinates which form nodes of a tree, wherein (A) holds for any two adjacent coordinates (i,j) in said sequence if i is the immediate parent of j.

38. The method of claim 37 wherein, for each subset R of U having at least one but not more than r entities, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

39. The method of claim 34 wherein the coordinates of the first coordinate system comprise a plurality of coordinates forming nodes of a tree, wherein (A) holds for any two adjacent coordinates (i,j) in said sequence if i is the immediate parent of j.

40. The method of claim 39 wherein, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

41. A computer-implemented method for selecting a cover from an (n,k,r,t)-exclusive set system, the system being defined over a set U of entities such that each element of the exclusive set system is associated with cryptographic data, wherein n=|U|, and wherein k, r, and t are predefined positive integers, the cover being for a set U\R where R⊂U and |R|<r, the cover comprising at most t elements, the method comprising:
selecting, for the cover, by a computer system comprising circuitry, one or more elements S from the exclusive set system, each one of said elements S is a subset Sƒ corresponding to a function ƒ(u) such that ƒ(u) is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein each function ƒ(u) is a polynomial in one or more of coordinates of u in at least one coordinate system, the degree of ƒ(u) being at most r, wherein each subset Sƒ is associated with first cryptographic data for use in a cryptographic operation which is for:
(a) receiving a first input associated with an entity;
(b) receiving a second input associated with a validity property of the entity and/or with an entitlement operable to be provided to the entity; and
(c) combining the first input and the second input to prove the validity property and/or provide the entitlement;

wherein at least one subset Sƒ has a plurality of entities, and the associated first cryptographic data are for providing the first input for each entity in the subset Sƒ;
wherein said one or more coordinate systems comprise a first coordinate system which comprises s coordinates where s is a predefined integer greater than one, each coordinate having values in a finite field having fewer elements than the number of entities in the set U;
wherein for the first coordinate system, for at least one pair (I,j) of the s coordinates in the first coordinate system, the following property (A) holds:
(A) said functions ƒ(u) comprise a first function ƒƒ(u) which is a polynomial in the ith and jth coordinates, wherein for each entity u in U the value of the jth coordinate of u is completely defined by the value of the ith coordinate of u and the value of the first function ƒƒ(u) on the entity u, wherein the first function ƒƒ(u) is equal to said predefined value on the subset R;

wherein the method further comprises generating second cryptographic data for use as the second input in the cryptographic operation for each subset Sƒ; and transmitting the second cryptographic data for use in the cryptographic operation.

42. The method of claim 41 wherein:
(1) each entity represents a user operable to receive encrypted information over a network, and the entities in U\R are entitled to receive the information, and the entities in the set R are not entitled to receive the information, and each said set S is associated with said first cryptographic data which includes a decryption key DKs provided to the users that are elements of the set S, the key being provided for decrypting said information, and the second cryptographic data includes the encrypted information; or
(2) each entity represents a cryptographic digital certificate, and wherein each said set S is associated with said cryptographic data which includes validity data VDs for verifying that the set S contains only valid certificates or only invalid certificates, and the second cryptographic data includes a validation proof for each entity in each said subset Sƒ selected for the cover by the computer system.

43. A computer system which comprises one or more processors and which is adapted to perform the method of claim 41.

44. A non-transitory manufacture comprising a computer-readable computer program comprising one or more computer instructions for a computer system to perform the method of claim 41.

45. A network transmission method comprising transmitting, over a computer network, a computer program for a computer system to perform the method of claim 41.

46. The method of claim 41 wherein in the first coordinate system, no two entities in R have identical ith coordinates, and no two entities in R have identical jth coordinates.

47. The method of claim 46 wherein the first coordinate system comprises a plurality of coordinates which form nodes of a tree, wherein (A) holds for any two adjacent coordinates (i,j) in said sequence if i is the immediate parent of j.

48. The method of claim 47 wherein, for the coordinate i0 which is the root of said tree, the one or more functions ƒ(u) comprise a polynomial which is equal to the predefined value if, and only if, the i0th coordinate of u is equal to the i0th coordinate of at least one entity in R.

49. A computer-implemented method for generating data representing an exclusive set system CC(U) over a set U of entities, the method comprising:
generating, by a computer system comprising circuitry, one or more exclusive set systems CC(UB) for each of a plurality of subsets {UB} of U, wherein at least one of the exclusive set systems CC(UB) is generated by the method of claim 1;
obtaining, by the computer system, the exclusive set system for U as a union of the systems CC(UB).

50. The method of claim 49 wherein:
(1) each entity represents a user operable to receive encrypted information over a network, and each element Sƒ of the exclusive set system is associated with said first cryptographic data which includes a decryption key DKs provided to the users that are members of the element Sƒ, the key being provided for decrypting said information; or
(2) each entity represents a cryptographic digital certificate, and each said element Sƒ is associated with said first cryptographic data which includes validity data VDs for verifying that the subset Sƒ contains only valid certificates or only invalid certificates.

51. A computer system which comprises one or more processors and which is adapted to perform the method of claim 49.

52. A non-transitory manufacture comprising a computer-readable computer program comprising one or more computer instructions for a computer system to perform the method of claim 49.

53. A network transmission method comprising transmitting, over a computer network, a computer program for a computer system to perform the method of claim 49.

54. A computer-implemented method for selecting a family of subsets of a set U such that each of said subsets is associated with cryptographic information, wherein the union of said subsets includes a predefined set of valid entities and excludes a predefined set R of invalid entities, the method comprising:
determining, by a computer system comprising circuitry, a plurality of disjoint subsets {Uj} of the set U such that the union of the subsets UB equals U, wherein each subset UB is associated with an exclusive set system CC(UB) with the maximum revoked set size rB≧|RB|, where RB=R∩UB;
for each subset UB, selecting, by the computer system, a cover for UB\RB from CC(UB), wherein the union of said covers provides said family of subsets, wherein for at least one subset UB , the cover is selected by the method of claim 41.

55. The method of claim 54 wherein:
(1) each entity represents a user operable to receive encrypted information over a network, and each element S of the exclusive set system is associated with said first cryptographic data which includes a decryption key DKs provided to the users that are members of the element S, the key being provided for decrypting said information; or
(2) each entity represents a cryptographic digital certificate, and each said element S is associated with said cryptographic data which includes validity data VDs for verifying that the subset S contains only valid certificates or only invalid certificates, and the second cryptographic data includes a validation proof for each entity in each said subset Sƒ selected for the cover by the computer system.

56. A computer system which comprises one or more processors and which is adapted to perform the method of claim 54.

57. A non-transitory manufacture comprising a computer-readable computer program comprising one or more computer instructions for a computer system to perform the method of claim 54.

58. A network transmission method comprising transmitting, over a computer network, a computer program for a computer system to perform the method of claim 54.

59. A non-transitory manufacture comprising computer-readable data for defining an (n,k,r,t)-exclusive set system over a set U, where n,k,r,t are predefined positive integers, the exclusive set system comprising one or more elements S each of which is a subset Sƒ corresponding to a function ƒ(u) such that ƒ(u) is not equal to a predefined value on Sƒ but is equal to the predefined value on U\Sƒ, wherein each function ƒ(u) is a polynomial in one or more of coordinates of u in at least one coordinate system, the degree of ƒ(u) being at most r, wherein each subset Sƒ is associated with cryptographic data for use in a cryptographic operation which is for:

(a) receiving a first input associated with an entity;
(b) receiving a second input associated with a validity property of the entity and/or with an entitlement operable to be provided to the entity; and
(c) combining the first input and the second input to prove the validity property and/or provide the entitlement.