Patent Publication Number: US-9419933-B2

Title: Maximizing circle of trust in online social networks

Description:
BACKGROUND 
     Recent rapid development of Online Social Networks (OSNs) has revolutionized the way of human interaction and drastically changed the landscape of communications and information sharing. One of the most important characteristics of OSNs is the “word-of-mouth” exchanges, in which information can be propagated from friends to friends of friends and eventually widely spread over the network. By leveraging this power, many organizations and companies have been using OSNs as an effective medium to increase their visibility and advertise their products. Likewise, millions of OSN users are sharing their personal status daily with a hope to keep many of their friends, near or far, updated. However, millions of users are tweeting and sharing their personal status daily without being aware of where that information eventually travels to. 
     Indeed, not only is it possible to quickly propagate information to friends, this information may be spread to many unwanted targets (those with whom we do not want to share the information). For example, suppose that Bob wants to share with his friends some of his personal pictures and stories in Facebook, yet he is reluctant to let Chuck know about them. Being careful, Bob just shares to the list of his friends in Facebook where Chuck is not in that group with a belief that Chuck cannot see those pictures. Unfortunately, Alice, who is a friend of both Bob and Chuck, replied to the post, and thus Chuck will be able to see the message from Alice and learn about Bob&#39;s sharing. 
     Current OSN settings can address part of this issue. For example, Google+ groups users into circles such that a user can select a specific circle to share information with when the user shares a message. In addition, Facebook includes a function enabling customized privacy for each user when the user shares a message (referred to as “Custom Privacy”). In the Custom Privacy function, a user can choose a range of friends to share with and also hide the message from some specific users (including friends, friends of friends, or the public). Superficially, the information leakage problem appears to be addressed in the OSNs by these user-selected privacy controls. In particular, the Custom Privacy function works by tracking the message-ID associated with a post and hiding any post or thread having that message-ID from unwanted targets. However, the current approaches neglect an important channel of information propagation, namely, mentioning the message. 
     In the example with Bob and Chuck, Bob may use the custom privacy function provided by Facebook to hide his sharing from Chuck, which can help avoid the situation where Chuck see&#39;s Alice&#39;s reply to the post (and thus the pictures or post shared by Bob). Unfortunately, the custom privacy function only tracks and hides Alice&#39;s message based on the message-ID of Bob&#39;s post, not on its propagation. Therefore, when Bob&#39;s friend Alice posts a new message mentioning Bob&#39;s pictures and stories, this new message cannot be hidden from Chuck anymore since its ID is no longer the same as the original message from Bob. Consequently, Chuck will still learn about Bob&#39;s pictures and stories. Thus it raises a practical question: Is there any mechanism for Bob to share his pictures and stories to as many friends as possible without these pictures and stories reaching Chuck? 
     BRIEF SUMMARY 
     Techniques and systems are disclosed for controlling information leakage in online social networks such that dissemination of information is maximized while the probability that the information will reach an unwanted target is minimized. 
     In an embodiment of the invention, a system is provided for on-the-fly construction of a circle of trust. The system is configured to construct a circle of trust from a user&#39;s friend (or follower) list and the name(s) of unwanted target(s) who may or may not be part of the user&#39;s friend (or follower) list. The construction of the circle of trust can be additive or subtractive. In one embodiment, potential leakage to an unwanted target is estimated by performing a sampling method. In another embodiment, a non-sampling method is used. In yet another embodiment, a hybrid method is used, where the hybrid method involves a first phase using a non-sampling method and a second phase using a sampling method. 
     According to certain embodiments, a user can control the propagation of a message by having a circle of trust constructed at the time of posting a message, where the circle of trust is a subset of the user&#39;s friends selected such that the probability of the message reaching an unwanted target is below a particular probability threshold. 
     This Brief Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Brief Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  shows a representation of a ISM Propagation Model in accordance with an embodiment of the invention. 
         FIG. 2  illustrates an example screen shot of a user interface when constructing a circle of trust in accordance with an embodiment of the invention. 
         FIG. 3  shows a block diagram of a method of constructing a circle of trust in accordance with an embodiment of the invention. 
         FIGS. 4A and 4B  show the visibility and time results, respectively, of the six embodiments implemented on the Foursquare dataset where δ=2. 
         FIGS. 4C and 4D  show the visibility and time results, respectively, of the six embodiments implemented on the Facebook dataset where δ=2. 
         FIGS. 4E and 4F  show the visibility and time results, respectively, of the six embodiments implemented on the Twitter dataset where δ=2. 
         FIGS. 5A and 5B  show the visibility and time results, respectively, of the six embodiments implemented on the Foursquare dataset where δ=3. 
         FIGS. 5C and 5D  show the visibility and time results, respectively, of the six embodiments implemented on the Facebook dataset where δ=3. 
         FIGS. 5E and 5F  show the visibility and time results, respectively, of the six embodiments implemented on the Twitter dataset where δ=3. 
         FIGS. 6A-6C  show CT size for sources at different “celebrity” level (degree) for the Foursquare dataset ( FIG. 6A ), the Facebook dataset ( FIG. 6B ) and the Twitter dataset ( FIG. 6C ). 
         FIG. 7  shows a plot indicating the “trust level” of a friend for a user according to the degree of the user (when the user becomes more popular). 
         FIGS. 8A-8C  show he impact of common friends between sources and targets for the Foursquare dataset ( FIG. 8A ), the Facebook dataset ( FIG. 8B ) and the Twitter dataset ( FIG. 8C ). 
         FIG. 9  illustrates a Single-2-MCT Reduction. 
         FIG. 10  illustrates 2-MCT Reduction G from EQUIPARTITION (All edges from s to nodes (N) have probability 1; an edge from N i  to t 1  and t 2  has probability 
       
         
           
             
               
                 
                   
                     p 
                     
                       i 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       1 
                     
                   
                   = 
                   
                     
                       1 
                       - 
                       
                         
                           ⅇ 
                           
                             - 
                             
                               
                                 ϖ 
                                 i 
                               
                               
                                 
                                   ∑ 
                                   i 
                                 
                                 ⁢ 
                                 
                                   ϖ 
                                   i 
                                 
                               
                             
                           
                         
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         and 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           p 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             2 
                           
                         
                       
                     
                     = 
                     
                       1 
                       - 
                       
                         ⅇ 
                         
                           - 
                           
                             
                               
                                 ϖ 
                                 max 
                               
                               - 
                               
                                 ϖ 
                                 i 
                               
                             
                             
                               
                                 n 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   ϖ 
                                   max 
                                 
                               
                               - 
                               
                                 
                                   ∑ 
                                   i 
                                 
                                 ⁢ 
                                 
                                   ϖ 
                                   i 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
                 ) 
               
               . 
             
           
         
       
         FIGS. 11A and 11B  illustrate a reduction example from an Maximum Independent Set instance ( FIG. 11A ) to a 2-MCT instance ( FIG. 11B ); (z=2 and 
                 τ   =     1   -     ⅇ     2   3           ;         
for the edges between N i  and t j , the probability
 
               p   =     1   -     ⅇ     1   3               
and 0 for all other edges without specifically marked probability.)
 
         FIG. 12  illustrates a δ-MCT reduction. 
         FIGS. 13A-13C  illustrate an example of a 3-Conn 2  Reduction from an instance G ( FIG. 13A ) to a probabilistic graph H ( FIG. 13B ) to a Reduced graph G′ ( FIG. 13C ). 
         FIGS. 14A-14G  show Algorithms 1-7 that may be used in embodiments of the invention. 
     
    
    
     DETAILED DISCLOSURE 
     In order to accomplish the construction of a circle of trust, techniques are disclosed so that OSN users can conveniently and safely share their information in OSNs knowing that these information will not be propagated to their unwanted targets. 
       FIG. 1  illustrates information propagation leakage in an OSN. This information propagation leakage follows an Independent Sharing-Mention (ISM) propagation model in the context of different diffusion channels. As shown in  FIG. 1 , in the ISM model, two types of information leakage propagations (e.g., diffusion channels) in OSNs are considered between two friends User u and User v. As previously mentioned, the ability for information to be propagated from friends to friends of friends and eventually widely spread over the network is desirable for OSNs. User u may acquire information from User s (who User u may not know) through the propagation of that information from friend to friend (via Friend 1 and/or Friend 2) until u learns of the information. 
     The first type of information leakage propagation channel is referred to as “sharing.” For sharing, u can share a message using functions provided by OSNs. For example, u can use “retweet” or “reply” to share on Twitter and “share,” “comment” or “like” to share on Facebook. When u shares a message, the message will appear on u&#39;s own wall and can then be seen by v. 
     The second type of information leakage propagation channel is referred to as a “mention.” For a mention, u can also propagate the information to v by mentioning the message with the same content (or retyping using his own words). 
     Correspondingly, between users u and v, the probability of a sharing propagation (Sharing Probability) is a uv  and the probability of a mention propagation (Mention Probability) is p uv . Therefore, each link (u,v) in an OSN has a two-tuple probability  a uv , p uv   . Although a uv  and p uv  are not necessarily independent, the ISM model is independent in terms of the following two aspects: the independence between different links; and the independence among the current propagation, the history propagation and the future propagation. 
     The leakage propagation process in a directed graph G (with edges E) is illustrated in  FIG. 1 . If a source User s shares a message m to a subset C={v 1 , v 2 , . . . , v l } of his friends, in a first round, a user v will learn about the message m with the sharing probability a sv , i.e., there is no propagation via mentioning in the first round. In a second round, if friend v learns about the message m in the first round, then each friend w of User s&#39;s friend v can learn about the message m from friend v via sharing with probability a vw  or via mentioning with probability p vw . The propagation continues up to δ rounds, where δ&gt;0 is a predefined integral constant in the model. 
     Based on the above described propagation process, a leakage path (s=v 0 , v 1 , . . . , v l =t) is defined as a path between the source s and an unwanted target t, in which (v i , v i+1 ) and v i+1  learns about the message m from v i  for all i=0, 1, . . . , l−1. If friend v i+1  learns about message m via sharing, then (v i , v i+1 ) is called a sharing edge, otherwise, (v i , v i+1 ) is a mentioning edge. For this model, the first edge on any leakage path is a sharing edge. In addition, at least one edge on the leakage path is a mentioning edge. 
     As can be seen, the ISM model can reflect the information propagation on a majority of existing OSNs by selecting the parameters. For example, for Facebook, the function in Custom Privacy to hide certain information from specific users can narrow down the sharing probability to 0 if the source user blocks all his unwanted targets. Thus, when Custom Privacy is in use, the information propagation on Facebook depends on mention probabilities (p uv ). As another example, for Twitter, information propagations are dependent on both sharing probability and mention probability. That is, p uv  can be defined as an alternative sharing-mention probability instead of mention probability for each link (u,v). Accordingly, the ISM model presents the different leaking features in distinct OSNs to enable an understanding as to how information can leak to specific targets. 
     While it is desirable to avoid sharing information with unwanted targets, the filtering out of friends should be minimized because one of the main purposes of posting a message on OSNs is to share the information with as many friends as possible (i.e. maximize the visibility of the message to friends). 
     Accordingly, various embodiments of the invention utilize a Maximum Circle of Trust (MCT) optimization to construct a circle of trust (CT) with the maximum number of visible friends for a user so that once the user posts a message visible to this CT, the probability of such friends in this CT spreading the message to unwanted targets is bounded under some input thresholds, where a friend of the user is said to be visible to a message if the message appears on his wall (or new feed or other mechanism used to propagate the information posted on an OSN). 
     Assuming that information can be spread at most δ hops, the problem can be referred to as a δ-Hop-Propagation Maximum Circle Of Trust (δ-MCT) problem. A “hop” refers to the degree of spread from a first user to another user that is not a direct friend or follower of the first user. For example, a hop of 2 refers to a case where a first user shares a message with his friends (including a second user) and the message is spread from the first user to a third user who is not a direct friend of the first user but who is a friend of the second user. In other words, because the third user is two degrees away from the first user, the message makes 2 hops to reach the third user the first hop being the propagation of the information from the first user to the second user and the second hop being the propagation of the information from the second user to the third user. 
     In accordance with embodiments of the invention, the δ-MCT problem is defined as follows: 
     Given a directed graph G=(V,E) with |V| users and |E| edges underlying an OSN, where each edge (u,v) is associated with a tuple of sharing probability and mention probability  a uv , p uv   . Let T{t 1 , . . . , t k } be the set of k=|T| unwanted targets and s be the source user with |N(s)\T|=S n  neighbors. The δ-MCT problem constructs a circle of trust (CT) with the maximum expected visible friends of s such that the probability of each unwanted target t j  can see the message posted by s after at most δ hops propagation is at most its leakage threshold τ j , which lies in [0,1). 
     It is assumed that the source user s is rational. That is, the source user will not directly provide the information to unwanted targets (either by telling the information to that unwanted target or by sharing the information with the unwanted target via an OSN). Accordingly, when source user s is rational, all unwanted targets T must be at least two hops from s. 
     Since most messages in OSNs are propagated within 2 to 5 hops, information propagation approximations are provided herein for 2-hop information propagation (2-MCT) as well as the case where information can be propagated more than two hops. When the number of unwanted targets is bounded, this variant can be referred to as Bounded-2-MCT. 
     For the case of a Bounded-2-MCT in which there is only one unwanted target, an FPTAS (full polynomial time approximation scheme) approximation algorithm is provided. For the case of a Bounded-2MCT in which there are multiple unwanted targets, a PTAS (polynomial time approximation scheme) is provided. For the 2-MCT cases where the number of unwanted targets is not bounded, a randomized algorithm is provided with a tight theoretical guarantee. This randomized algorithm can be further derandomized to obtain a deterministic solution. 
     Because the FPTAS, PTAS, and randomized algorithm are not as suitable for the general case where information can be propagated with more than two hops, further embodiments of the invention provide techniques including a greedy algorithm, in which the running time is tremendously improved (as compared to straight sampling methods) by using a cut-based estimation. 
     In many OSNs, a majority of messages are limited to being propagated within 2 hops. Part of the reason for leakage of information to be limited to a propagation of 2 hops is the various blocking and privacy functions being made available by the OSNs. In addition, self editing by the user with respect to what information is posted on an OSN results in the number of unwanted targets to be relatively small. 
     Based on these practical observations, the δ-MCT Problem can be reduced to a Bounded-2-MCT problem in which it is assumed that any message can be spread at most 2 hops and the number of unwanted targets is bounded by some constant κ. According to the Bounded-2-MCT problem, for any user u except the unwanted targets, its propagation can lead to the information leakage if and only if the user receives the message directly from s when δ=2. 
     FPTAS- and PTAS-based solutions are desirable solutions for a NP-hard problem by enabling a trade-off between accuracy and running time. That is, embodiments using FPTAS and PTAS-based solutions enable a selection of the error parameter based on the allowed time for running the process (e.g., how much time available to wait for a solution before a next action is to be taken). For example, it is possible provide a solution according to desired constraints by allowing more errors when the time is limited and less errors otherwise. FPTAS can be better than PTAS in this respect because FPTAS requires the algorithm to be polynomial in both the problem size and error parameter. 
     The Bounded-2-MCT problem can be referred to as a Single-2-MCT when there is only a single unwanted target. The NP-hardness of the Single-2-MCT problem is shown in the section entitled “Example: NP-hardness of Single-2-MCT,” and the proof showing that the algorithm solving the Single-2-MCT problem in accordance with an embodiment of the invention is actually a full polynomial time approximation scheme (FPTAS) is provided in the section entitled “Example: Proof: Algorithm 1 is FPTAS.” 
     According to an embodiment of the invention, a FPTAS approximation algorithm is provided to create a CT for a user. According to various embodiments of the invention, the FPTAS-based solution is used for solving the Single-2-MCT problem. In one embodiment, the FPTAS-based solution (e.g., Algorithm 1) is used when a source user indicates only one unwanted target. 
     Because, all unwanted targets T must be at least two hops from a rational source user, it is possible for the Single-2-MCT problem to focus only on the case that the unwanted user t is two hops away from s in G[E\{s,T}] since the unwanted user t cannot see the message if the unwanted user t is at least 3 hops away from s while δ= 2 . In this case, the probability that the message will be leaked to t is 1−Π i∈N(s)\{t} (1−a si p it ) x     i    because for any user u, except the unwanted targets, the propagation can lead to the information leakage if and only if the user receives the message directly from the source s. 
     The basic idea of the FPTAS algorithm with k=1 has two main phases: 
     (1) scaling the sharing probability; and 
     (2) using dynamic programming to find the minimum leakage probability with respect to the scaled sharing probabilities. 
     First, since all a si  are rational values, each can be rewritten with 
               an   si       ad   si           
where both an si  and ad si  are integers. Ad is defined to be the least common multiple of all denominators ad si . Thus,
 
                 a   si     =         an   si     ⁢   Ad   ⁢     /     ⁢     ad   si       Ad       ,         
where the numerator is clearly an integer. Then, in the first phase (scaling the sharing probability), in order to avoid the case that an si Ad/ad si  is exponentially larger than S n , the sharing probability a si  is scaled for each s&#39;s neighbor by the factor
 
             A   =       ɛ   ⁢           ⁢   max   ⁢     {           an   si     ⁢   Ad       ad   si       ❘         a   si     ⁢     p   it       ≤   τ       }         S   n             
and its corresponding scaled sharing probability is defined to be
 
     
       
         
           
             
               a 
               si 
               ′ 
             
             = 
             
               
                 ⌊ 
                 
                   
                     an 
                     si 
                   
                   A 
                 
                 ⌋ 
               
               . 
             
           
         
       
     
     In the second step (dynamic programming), dynamic programming is used to solve a complex problem by breaking the problem down into simpler subproblems in a recursive manner. That is, to solve the MCT problem with respect to the scaled sharing probabilities, the recursion function is defined as follows. 
     Let L i (a) be the minimum leakage probability of a subset of s&#39;s first i friends with the total circle of trust having size equal to a. Thus, the recursion can be written as 
                       L   i     ⁡     (   a   )       =     {               L     i   -   1       ⁡     (   a   )       ,             if   ⁢           ⁢   a     &lt;     a   i                   min   ⁢     {         L     i   -   1       ⁡     (   a   )       ,         L     i   -   1       ⁡     (     a   -     a   si   ′       )       +     w   i         }       ,             if   ⁢           ⁢   a     ≥     a   i                       (   1   )               
where w i =−log(1−a si p it ) corresponding to the neighbor i of s. The details of the FPTAS Algorithm of an embodiment of the invention are shown in Algorithm 1 (provided in  FIG. 14A ).
 
     For multiple unwanted targets k≧2, an FPTAS-based solution is not available. Instead, a PTAS-based solution is provided. A detailed explanation of there being no FPTAS-based solution when k≧2 is provided in the section entitled “Example: No FPTAS for k≧2.” 
     Because of the non-existence of FPTAS for the Bounded-2-MCT problem, a PTAS solution, which is the best expected approximation solution, is provided. The PTAS solution is based on an Integer Linear Programming (ILP) formulation that is then relaxed. 
     According to an embodiment of the invention, the ILP formulation is based on the following: First, an indicator variable x i  is defined for each friend i∈N(s) of s as x i =1 if i is visible to m, and 0 otherwise. Clearly, the objective is to maximize the circle of trust, i.e., the expected number of visible friends of s. Thus, the formulation can be written as the sum of sharing probabilities of s&#39;s friends except unwanted targets, that is, max Σ i∈N(s)\T a si x i . 
     As previously indicated for the 2-MCT problem, for any user u except the unwanted targets, the user&#39;s propagation can lead to the information leakage if and only if the user receives message directly from s when δ=2. Accordingly, the message will be leaked to t j  if and only if s&#39;s neighbor i is informed with probability a si  and i further leaks to t j  with probability p it     j   . 
     Therefore, the constraint with respect to each unwanted target t j  can be written as 1−Π i∈N(s)\T (1−a si p it     j   ) x     i   ≦τ j . After rearranging and choosing the logarithm of both sides in each constraint and relaxing x i ∈{0,1} to x i ≧0, the following LP is obtained: 
     
       
         
           
             
               
                 
                   
                     max 
                     ⁢ 
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           
                             
                               N 
                               ⁡ 
                               
                                 ( 
                                 s 
                                 ) 
                               
                             
                             ⁢ 
                             \ 
                             ⁢ 
                             T 
                           
                         
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           a 
                           si 
                         
                         ⁢ 
                         
                           x 
                           i 
                         
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       
                         s 
                         . 
                         t 
                         . 
                         
                           
                             ∑ 
                             
                               i 
                               ∈ 
                               
                                 
                                   N 
                                   ⁡ 
                                   
                                     ( 
                                     s 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 \ 
                                 ⁢ 
                                 T 
                               
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               w 
                               ij 
                             
                             ⁢ 
                             
                               x 
                               i 
                             
                           
                         
                       
                       ≤ 
                       
                         c 
                         j 
                       
                     
                     , 
                     
                       ∀ 
                       
                         j 
                         ∈ 
                         T 
                       
                     
                   
                   ⁢ 
                   
                     
 
                   
                   ⁢ 
                   
                     
                       x 
                       i 
                     
                     ≥ 
                     0 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
     where w ij =−log(1−a si p it     j   ) and c j =−log(1−τ j ). 
     This LP is referred to as LP(2). 
     The PTAS algorithm for the Bounded-2-MCT has two phases with respect to a threshold 
             β   =     min   ⁢     {         ⌈     k   ɛ     ⌉     -     (     k   -   1     )       ,            N   ⁡     (   s   )       ⁢     \     ⁢   T            }             
with k unwanted targets:
 
     (1) when the number of visible neighbors of s is less than β, the solution is enumerated and a feasible solution π is selected that induces a maximum visibility; and 
     (2) after initializing the current optimal solution as the one in the first phase, each combination of size β is checked. For each combination Ω, the LP rounding algorithm (as shown in Algorithm 3) is first used to obtain a bounded solution π Ω  of the subproblem of 2-MCT in terms of the neighbor set N(s)′={i|a si ≦min i∈Ω} and c j′ =c j −Σ i∈Ω w ij . Then, the new optimal solution is updated if Σ i∈Ω a si +π Ω ≦π. The detail of PTAS algorithm is shown as Algorithm 2 (provided in  FIG. 14B ). 
     The subroutine of LP rounding algorithm, as shown in Algorithm 3 (provided in  FIG. 14C ), starts with a basic solution of LP(2) consisting of k fractional x i   LP . Between the sum of a si  on integers x i   LP  and a sj  with the maximum fraction value x j   LP , the algorithm returns the larger value as its solution. 
     Let π k , π LP , π* be the solution of Algorithm 3, the optimal LP solution and the optimal solution of 2-MCT. The proof showing that Algorithm 3 is a 1/(k+1) approximation algorithm of Bounded-2-MCT is shown in the section entitled “Example: Proof: Algorithm 3 is a 1/(k+1) approximation algorithm of Bounded-2-MCT,” and the proof showing that the algorithm solving the Bounded-2-MCT problem in accordance with an embodiment of the invention is actually a polynomial time approximation scheme (PTAS) is provided in the section entitled “Example: Proof: Algorithm 2 is PTAS.” 
     In a further embodiment, a randomized algorithm is provided in which randomized rounding is included in LP(2) and then LP(2) is derandomized to obtain a deterministic solution. 
     For the 2-MCT problem using the randomized algorithm, in addition to LP(2), a definition is provided where 
               c   ^     =       min   j     ⁢         log   ⁡     (     1   -     τ   j       )           max   i     ⁢     log   ⁡     (     1   -       a   si     ⁢     p     it   j           )           .             
Without loss of generality, it is assumed that ĉ&gt;1 since a neighbor i of s cannot be selected in CT if a si p it     j    for some unwanted target t j , otherwise this user i will surely leak the information to t j .
 
     In accordance with an embodiment of the invention, after obtaining the solution x L  of the LP (2), each x I  is rounded to 1 with the probability μx L  with μ=α(π* LP /k) 1/(ĉ-1)  where α&lt;½ and π* LP  is the optimal fractional solution of LP(2). This process is illustrated by the scaled randomized rounding of LP(2) shown in Algorithm 4 (provided in  FIG. 14D ). 
     A detailed explanation regarding the existence of a solution (obtained by Algorithm 4), which is at least β of the optimal solution where β=μ/2 as well as an explanation regarding the existence of a polynomial-time deterministic algorithm with expected size of CT at least 
             Ω   (       (     OPT   k     )       1       c   ^     -   1         )         
are provided in the section entitled “Example: Algorithm 4 Feasibility of Solution.” In addition, a detailed explanation for the tightness of the theoretical bound for 2-MCT is provided in the section entitled “Example: Inapproximability Results.”
 
     The δ-MCT problem becomes much harder when δ≧3. In fact, as further explained in the section entitled “Example: Proof: δ-MCT problem is #P-hard when δ≧3,” the δ-MCT problem is #P-complete when δ≧3, denying the existence of efficient algorithms to solve the problem. Thus, various embodiments of the invention are provided to solve the problem in different settings. 
     According to one embodiment, an effective algorithm is provided to construct CT. This algorithm is referred to as Iterative Greedy Construction (IGC). IGC is a meta-algorithm, which can be combined with different leakage estimation methods in accordance with various embodiments of the invention. 
     The IGC algorithm of an embodiment of the invention, as shown in Algorithm 5 (provided in  FIG. 14E ), iteratively adds one of the source&#39;s neighbors into the circle of trust until no more nodes can be added without causing the leakage probabilities to exceed the thresholds. Specifically, in each iteration, the set of candidate neighbors L, those whose addition to CT still guarantees that the leakage levels at each unwanted targets t j  does not exceed the threshold τ j  is updated. Denote by l j (C) the probability that the message will be leaked to t j  with respect to CT C. Then, v is a candidate if l j (C+{v})≦τ j ∀j=1 . . . k. 
     A greedy function ƒ(v) is used to evaluate the fitness of user v. The function is defined as follows 
                     f   ⁡     (   v   )       =       a   sv         max       t   j     ∈   T       ⁢           ⁢         l   j     (   v   )       (         ∑     u   ∈   L       ⁢           ⁢     l   j   u       -     l   j     (   v   )         )       1   -     l   j     (   v   )                       (   6   )               
where l j   (v) =l j (C++{v})/τ j  is the normalized leakage level at t j  after adding v to the CT. The numerator of ƒ(v) is selected to be a sv  so that the algorithm will favor close friends of s, whose adding increase the visibility.
 
     In addition, the proposed greedy function takes into the account the following quantities item 1−l j   (v) : the remaining leakage tolerance at the unwanted target t j ; Σ u∈L l j   u −l j   (v)  reflects the future potential leakage to target t j  when adding user v to CT. item By maximizing ƒ(v) the algorithm will prefer user v with small denominator. Thus, the algorithm will select the users that have higher remaining leakage tolerances but lower future potential leakage. 
     Note that in IGC, it is assumed that there exists a procedure to estimate leakage τ j (C), which can be invoked up to O(S n   2 |T|), where S n =|N(s)\T|. Thus, various embodiments of the invention provide particular procedures to estimate the leakage in the IGC. 
     The estimate leakage component of the IGC decides both the solution quality and the running time of the meta-algorithm. Due to the #P-hardness of the estimating leakage, exact solutions require exponential time. Hence, for realistic time constraints, approximation methods are used to estimate l j (C). 
     In one embodiment, the procedure to estimate the leakage l j (C) in the IGC is Monte Carlo Sampling, in which the accuracy depends on the number of sampling times. For this embodiment, the method stimulates the random process following the ISM propagation model. The information is propagated via each edge (u,v) with sharing probability a(u,v) or mention probability p uv  on G until no newly informed users can be found or the message has been propagated δ hops. The estimation of (C) is calculated as the ratio between the number of time the message reaches t j  via a leakage path to the number of sampling times n S . In the experiments, the sampling times was selected as 20,000; of course embodiments are not limited to the sampling times selected for the experiments. 
     To speed up the estimation, it is possible to estimate the leakage at all targets at the same time using a single breadth-first search. Then the IGC algorithm, in the worst case, runs in time O(n S S n   2 (m+n)). 
     According to another embodiment, because sampling methods can be rather expensive for large-scale networks, alternative leakage estimation methods are used to handle the estimate the leakage l j (C). For example, in one embodiment, a fast method is provided to calculate a non-trivial upper-bounds on the leakage l j (C) at unwanted target t j . The upper bound is based on identifying minimal pseudo-cutset, as defined later, between the source and the unwanted target. For the explanations that follow, it is assumed that a trusted circle C is already given without further mention; and each edge (u,v) is associated with a combined sharing-mentioning propagation probability q(u,v). 
     Let t∈T be an arbitrary unwanted target that is to have its leakage level τ(t) estimated, the leakage level being defined as the probability of having a path between s and t. For each edge (u,v), define event X u,v =1 if the information can propagate through the edge (u,v) and X u,v =0 otherwise i.e., Pr[X u,v =1]=q(u,v). A cutset  S, T  is defined as  S, T ={(u,v)∈E|u∈S, v∈T}. For a subset of edges A ⊂ E, let A* be the event that all the edges of A do not let the information propagate through i.e., Pr[A*]=Π e∈A (1−q). Then, the exact leakage τ(t) can be computed as follow 
     
       
         
           
             
               1 
               - 
               
                 Pr 
                 [ 
                 
                   
                     ⋃ 
                     
                       
                         〈 
                         
                           S 
                           , 
                           T 
                         
                         〉 
                       
                       ∈ 
                       
                         C 
                         
                           s 
                           , 
                           t 
                         
                       
                     
                   
                   ⁢ 
                   
                     C 
                     * 
                   
                 
                 ] 
               
             
             , 
           
         
       
     
     where C s,t  is the set of all cutsets  S, T  satisfied s∈S and t∈T. However, computing this exact formulation is intractable. Accordingly, first, the formulation is relaxed by replacing C s,t  with a collection of cutsets B⊂C s,t . This yields the following upper-bound on the leakage τ(t) 
     
       
         
           
             
               1 
               - 
               
                 Pr 
                 [ 
                 
                   
                     ⋃ 
                     
                       
                         〈 
                         
                           S 
                           , 
                           T 
                         
                         〉 
                       
                       ∈ 
                       B 
                     
                   
                   ⁢ 
                   
                     C 
                     * 
                   
                 
                 ] 
               
             
             ≥ 
             
               τ 
               ⁡ 
               
                 ( 
                 t 
                 ) 
               
             
           
         
       
     
     Note that when B contains only disjoint cutsets, the upper bound can be efficiently computed in polynomial time. Thus, in the non-sampling estimation method of this embodiment of the invention, a maximal collection of disjoint cutsets is sought. The selection of good disjoint cutsets that gives close estimation is governed by two factors. First, small cutsets are preferred; at the same time, a collection of many cutsets is preferred. Note that the number of cutsets is bounded by the distance between the source and the unwanted target. Since if P is an s,t path of minimum length l, every cutset must contains at least one edge in P. Thus, the maximum number of disjoint cutsets that separate s and t cuts equals the minimum length of a path between s and t. 
     In accordance with an embodiment of the invention, instead of using cutsets, pseudo-cutsets are used. Pseudo-cutsets are the set of edges whose removal makes the distance from the source s to destination t at least δ+1 hops. The reason is that disrupting all paths of length at most δ is sufficient to prohibit the message to propagate to t. The algorithm to find the pseudo-cutsets and compute the upper-bound is given in Algorithm 6 (shown in  FIG. 14F ). 
     The algorithm first applies a Breadth-First Search algorithm to construct layers of vertices. Layer L i  consists of vertices at distance i from the source in term of hops. The cutset C is constructed by including all edges (u,v) with u∈L i  and v∈L i+1  but only if d s (u)+d t (v)≦δ−1 (i.e., there is a path of length at most δ going through the edge (u,v)). The upper-bound can be computed efficiently, since it only requires visiting nodes within 6-hop from the source instead of doing so n S  times as in the sampling method. 
     Although the Disjoint Cutset Upper-bound may not be as accurate as other presented methods, it is a scalable method to estimate the leakage. Moreover, it is also rather effective in comparing the neighbors to find out the ones causing the leaks to the unwanted targets. The use of the disjoint cutset upper-bound to estimate the leakage in the IGC algorithm can be referred to as the Non-sampling Method. 
     Since the Non-sampling method can overestimate the leakage at the unwanted targets, the Non-sampling Method often stops early even there are neighbors that can still be added to CT. Thus, in a further embodiment, the Non-sampling method for the IGC algorithm using the upper-bound via disjoint cutsets can be further fine tuned. 
     According to one such further embodiment, a hybrid method is provided that combines the (Monte-Carlo) Sampling method and the Non-sampling method. In a specific embodiment, the hybrid method involves two phases. In the first phase, the Non-sampling method is used to quickly construct a CT. In the second phase, a simple heuristics method is used together with the Monte-Carlo sampling algorithm to add more neighbors to the circle as follows: 
     1. Sort the neighbors that are not included in the circle in non-decreasing order of their visibilities; 
     2. In that order, include each neighbor into CT and check if the leakage below the thresholds using Sampling algorithm. If so, add the node to CT. 
     The hybrid method of this embodiment of the invention achieves both the speed of the Non-sampling method and the high solution quality of the Sampling method. Since, the hybrid method can involve at most S n  calls to the sampling estimation algorithm, the running time of the hybrid method is very competitive for large networks. As illustrated in the example experiments, often only one to three neighbors are added using the hybrid method&#39;s heuristic. Thus, the first phase using the Non-sampling method can be rather effective in terms of detecting trusted friends. 
     Returning to Bob&#39;s problem with respect to avoiding the stories and pictures from reaching Chuck, in one solution Bob is provided with an opportunity to construct on-the-fly a subset of his friends to share these stories with so that the probability of Chuck knowing them is very small. This subset of friends can be referred to as a “circle of trust” (CT).  FIG. 2  illustrates an example screen shot for the automatic construction of the circle of trust in accordance with an embodiment of the invention. In a further embodiment, the construct-on-the-fly subset can be created right before Bob is ready to share his stories. 
       FIG. 3  shows a block diagram of a method of constructing a circle of trust in accordance with an embodiment of the invention. First, the system can receive a message and at least one unwanted target for the message from a source user of the OSN  301 . Then, using the information regarding the current listing of friends (or followers) and the unwanted target(s), a maximum circle of trust (MCT) is constructed  302 . When the user makes the selection to post the message, the system can automatically select who of the user&#39;s friends or followers that the message will be made visible based on those that are in the MCT  303 . The method can be carried out in a computing environment using a computing system. The computer system can have hardware including one or more computer processing units (CPUs), memory, mass storage (e.g., hard drive), and I/O devices (e.g., network interface, user input devices). Elements of the computer system hardware can communicate with each other via a bus. 
     The construction of the MCT can be accomplished using any of the methods described herein. The mathematical relationships and equations provided herein can be carried out by a processor executing instructions stored on a computer-readable medium. In a further embodiment, the algorithm used for constructing the MCT can be selected on-the-fly according to the number of unwanted targets. For example, both the FPTAS algorithm, Algorithm 1, and one of the PTAS algorithms or the IGC (with selected leakage estimating procedure) can be used depending on the user&#39;s input regarding the unwanted targets. 
     Certain techniques set forth herein may be described in the general context of computer-executable instructions, such as program modules, executed by one or more computers or other devices. Certain embodiments of the invention contemplate the use of a computer system or virtual machine within which a set of instructions, when executed, can cause the system to perform any one or more of the methodologies discussed above. Generally, program modules include routines, programs, objects, components, and data structures that perform particular tasks or implement particular abstract data types. 
     It should be appreciated by those skilled in the art that computer-readable media include removable and non-removable structures/devices that can be used for storage of information, such as computer-readable instructions, data structures, program modules, and other data used by a computing system/environment. A computer-readable medium includes, but is not limited to, volatile memory such as random access memories (RAM, DRAM, SRAM); and non-volatile memory such as flash memory, various read-only-memories (ROM, PROM, EPROM, EEPROM), magnetic and ferromagnetic/ferroelectric memories (MRAM, FeRAM), and magnetic and optical storage devices (hard drives, magnetic tape, CDs, DVDs); or other media now known or later developed that is capable of storing computer-readable information/data. Computer-readable media should not be construed or interpreted to include any propagating signals. 
     A greater understanding of the present invention and of its many advantages may be had from the following experimental study and examples addressing the δ-MCT problem for constructing a maximum circle of trust, given by way of illustration. The following examples are illustrative of some of the methods, applications, embodiments and variants of the present invention. They are, of course, not to be considered in any way limitative of the invention. Numerous changes and modifications can be made with respect to the invention. 
     Example 1 
     Experimental Study 
     Experiments were performed on a collection of large OSNs to measure the efficiency of the various algorithms described herein in accordance with certain embodiments of the invention and apply those algorithms to provide better insights into the information leakage process in social networks. 
     Experiments were performed on three real-world OSNs, including Facebook, Twitter and Foursquare. The statistics of the used networks can be found in Table 1. The Facebook dataset is obtained from Viswanath et al. “On the Evolution of User Interaction in Facebook,” Proceedings of WOSN&#39;09, August 2009. The Twitter dataset is extracted from the Twitter network provided by Cha et al. “Measuring User Influence in Twitter: The million Follower Fallacy,” Proceedings of the 4 th  International AAAI Conference on Weblogs and Social Media (ICWSM), May 2010, by applying the unbiased sampling method in Gjoka et al. “Walking in Facebook: A case study of unbiased sampling of OSNs,” Proceedings of IEEE INFOCOM 2010, pages 1-9, IEEE, March 2010. Foursquare dataset was obtained by crawling, in which a set entrepreneurs and investors was selected as the seeding, and then the Foursquare API was used to get the users and their connections within two hop from the seeds. 
     
       
         
           
               
             
               
                 TABLE 1 
               
             
            
               
                   
               
               
                 Dataset 
               
            
           
           
               
               
               
               
               
            
               
                   
                 Dataset 
                 Nodes 
                 Edges 
                 Density 
               
               
                   
                   
               
            
           
           
               
               
               
               
               
            
               
                   
                 Facebook 
                 63,731 
                 905,565 
                 4.46% 
               
               
                   
                 Twitter 
                 88,484 
                 2,364,322 
                 3.02% 
               
               
                   
                 Foursquare 
                 44,832 
                 1,664,402 
                 8.28% 
               
               
                   
                   
               
               
                   
                 [*] Facebook are undirected networks; Twitter and Foursquare are directed networks. 
               
            
           
         
       
     
     Due to the lack of ground truth, uniform random numbers between 0 and 1 were independently assigned to sharing probability a uv  and mention probability p uv  of each edge. Unless otherwise mentioned, the source was randomly selected, and the unwanted targets were picked up randomly among the nodes that are within δ hops from the source. 
     The following algorithms in accordance with embodiments of the invention were implemented and compared: 
     1. Sampling: IGC algorithm using Monte-Carlo Sampling; 
     2. Non-Sampling: IGC algorithm using Disjoint Cut-sets (using Algorithm 6); 
     3. Hybrid: IGC-Hybrid algorithm; 
     4. Removal-Greedy, in which users are removed one by one to construct the CT. Here, the performance differences between adding a user one by one to the CT (such as in IGC Algorithm) and removing a user one by one from the list of s&#39;s friends in order to obtain the CT is compared. The Removal-Greedy algorithm is a simple approach in which a user v is removed if the greedy function ƒ(v) is maximized: 
     
       
         
           
             
               
                 
                   ∑ 
                   
                     
                       
                         t 
                         j 
                       
                       ∈ 
                       T 
                     
                     , 
                     
                       
                         
                           τ 
                           j 
                         
                         ⁡ 
                         
                           ( 
                           C 
                           ) 
                         
                       
                       &gt; 
                       
                         τ 
                         j 
                       
                     
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                    
                   
                     
                       
                         τ 
                         j 
                       
                       ⁡ 
                       
                         ( 
                         C 
                         ) 
                       
                     
                     - 
                     
                       τ 
                       j 
                     
                   
                    
                 
               
               
                 
                   a 
                   sv 
                 
                 + 
                 
                   
                     ∑ 
                     
                       i 
                       ∈ 
                       
                         C 
                         v 
                       
                     
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     a 
                     si 
                   
                 
               
             
             - 
             
               
                 
                   ∑ 
                   
                     
                       
                         t 
                         j 
                       
                       ∈ 
                       T 
                     
                     , 
                     
                       
                         
                           τ 
                           j 
                         
                         ⁡ 
                         
                           ( 
                           
                             C 
                             v 
                           
                           ) 
                         
                       
                       &gt; 
                       
                         τ 
                         j 
                       
                     
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                    
                   
                     
                       
                         τ 
                         j 
                       
                       ⁡ 
                       
                         ( 
                         
                           C 
                           v 
                         
                         ) 
                       
                     
                     - 
                     
                       τ 
                       j 
                     
                   
                    
                 
               
               
                 
                   ∑ 
                   
                     i 
                     ∈ 
                     
                       C 
                       v 
                     
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   a 
                   si 
                 
               
             
           
         
       
     
     where τ j (C) is the expected probability that unwanted target t j  knows the information when s only chooses the subset C to share, and C v =C\{v}. The Removal-Greedy can be summarized as shown in  FIG. 14G  (Algorithm 7: Removal Greedy Algorithm). 
     5. Randomized-Rounding: The approximation randomized algorithm, Algorithm 4, which is run 20 times to provide the average results; 
     6. Optimal: The optimal solution found by solving the Integer Programming of the LP (2) using the CPLEX method. 
     In the sampling subroutine for implementations 1 and 3, the random process was simulated 20,000 times. The optimal solutions and the fractional LP solutions in the randomized algorithm are obtained by using CPLEX optimization package. All algorithms are performed on a cluster of 20 PCs with CPU AMD Opteron 2.00 Ghz and 32 GB RAM. 
     The following quantities were measured: 
     (1) Visibility (%): The fraction of expected visible neighbors of the source s defined as 
     
       
         
           
             
               
                 
                   ∑ 
                   
                     j 
                     ∈ 
                     CT 
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   a 
                   sj 
                 
               
               
                 
                   ∑ 
                   
                     j 
                     ∈ 
                     
                       N 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           ( 
                           s 
                           ) 
                         
                         ⁢ 
                         \ 
                         ⁢ 
                         T 
                       
                     
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   a 
                   sj 
                 
               
             
             . 
           
         
       
     
     (2) CT Size (%): The fraction of visible friends in CT, defined as 
                    CT                 N   ⁡     (   s   )       ⁢   \   ⁢   T            .         
Often, the larger visibility, the bigger CT size, however, it is a more intuitive metric than visibility in many cases.
 
     (3) Running Time: The running time in seconds. item 
     The visibility (%) and running time were measured when the leakage threshold ranges from 0.05 to 0.4. For each leakage threshold, 100 sets of random sources and five unwanted targets were randomly choses and the results were averaged. 
     As shown in  FIGS. 4A, 4C, and 4E , the algorithms Removal-Greedy, Sampling, Hybrid, and Randomized Rounding produce optimal or close-to-optimal results in term of visibility. The hybrid algorithm performs slightly worse than the others, however, the gap is usually negligibly small. As expected, non-sampling method shows the worst results among all. The Visibility obtained with Non-sampling methods are 5% to 10% smaller than the others. The reason is that when the Non-sampling method examines if any nodes can be added to the CT, it is often pessimistic about the current leakage situation and stop early. Clearly, the non-sampling method is not optimal as a standalone method to construct CT, but rather as a method to construct an early version of CT. Similar observations for δ=3 can be seen in  FIGS. 5A, 5C, and 5E . 
     Moderately surprising, not too many friends need to be blocked to inhibit information leakage. Even when the leakage threshold is 5%, the visibility still ranges from 70% to 90%. In addition, the visibility increases quickly when the threshold increases. 
     As illustrated in  FIGS. 4A, 4C, 4E and 5A, 5C, and 5E , when comparing the cases δ=2 and δ=3, the visibility in Foursquare decreases, while those in Facebook and Twitter show the reverse trend. Moreover, in case δ=3 the visibility in Foursquare does not approach 100% when the leakage threshold increases. The main reason for smaller visibility in Foursquare is the closer distance between sources and targets in Foursquare. This is an artifact caused by the way we crawled the Foursquare network. As we only query the users within two-hops from the seeding in Foursquare, the randomly generated targets in Foursquare are often 2-hops away from the source, regardless of δ. In contrast, there is a high probability that the distance in hop from the source and the target in Facebook and Twitter equal exactly the value of δ. This observation, more or less, supports the hypothesis that the closer the source and the unwanted target, the smaller the CT. 
     The running time of the studied algorithms are shown in  FIGS. 4B, 4D, and 4F and 5B, 5D, and 5F . From the plots, it can be seen that all methods appear adequately fast when δ=2. When δ=3, the Non-sampling and Hybrid method are substantially faster than the other methods. Because the Hybrid avoids most of the calls to the sampling at the early selection steps; it can be up to a hundred times faster than the Removal-Greedy and the Sampling methods. 
     In comparison to the Sampling method, the running time of Removal-Greedy is excessively high for small leakage threshold, when the algorithm takes many rounds to remove nodes until obtaining the CT. In contrast, Sampling method (as well as Hybrid and Non-sampling method) has the running time slightly increased when the leakage threshold increases, which leads to larger CTs. Since it is often desirable to have a smaller leakage threshold, in practice, the algorithms that construct CT by adding nodes may have higher performance than those that find the CT in a removing nodes fashion. 
     Clearly, for δ=2 the optimal solution by solving LP(2) is the best selection. When δ≧3, the Hybrid is the method of choice due to both its outstanding solution quality and fast running time, less than 0.1 second. Note that the ability to construct CT quickly is critical, if one wishes to implement the algorithm on social network platforms. For larger networks and δ, the only applicable method is, however, the Non-sampling method. 
     Example 2 
     Case Study can Celebrities Keep their Secrets? 
     Several observations were obtained by solving LP(2) (δ=2) and using the Hybrid method (δ=3) that give the best performance in general. 
     The question as to whether or not “celebrities”, users with a large number of friends or followers, can only share their information with a small number of their friends to avoid information leakage was investigated. This was carried out by focusing on the relation between the degree of the source and their CT sizes. Intuitively, when a user has more friends, there is a high chance one or more of his friends will forward the information further. Thus, to avoid information leakage, it would be expected that the CT of “celebrities” would include only a small fraction of their friends. To verify the hypothesis, source users were selected with different degrees, increasing by 1% of the maximum degree in each step. For each source, ten random sets of five unwanted targets where selected and the average size of CT was computed by solving the LP(2). The results are shown in  FIGS. 6A-6C . From the plots, it can be seen that the expectation that the celebrity would have a smaller fraction of friends in their CT was wrong. 
     In contrast to the hypothesis, there is no sharp decrease in the CT size. Indeed, for the source with the highest degree, the CTs contain more than 95% of the neighbors. This suggests that by carefully constructing CT, smartly sharing information to avoid leakage is possible for “celebrities”. 
     Example 3 
     Case Study can we Trust Our Popular Friends? 
     There is an incentive not to share our sensitive information to a popular person (celebrity) who could easily leak the information further. In other words, the friends of a celebrity may be less likely to trust that person. To investigate the effect of the “celebrity level,” 10 users with different degree were selected in each network, incrementing by 10% of the maximum degree. For each “celebrity,” each of his neighbors were selected to be the source and the percentage that the “celebrity” was included in his friends&#39; CTs was computed. 
     As illustrated in the  FIG. 7 , the “trust level” of the friends for a user decreases quickly when the degree of the user increases, i.e. when the user becomes more popular. However, even for the user with the highest degree, half of his friends still can trust him as in the cases of Facebook and Foursquare. For Twitter, only 20% of the friends can trust the considered user. This can be explained by the fact that Twitter is a directed network with low reciprocity (A follows B, but B does not follow A). Thus, the celebrities are often not even considered to be friends to be included in the CTs. Roughly speaking, “celebrities” in social networks such as Facebook are relatively “trusted,” while the same conclusion does not hold for the “social media” network Twitter. 
     Example 4 
     Case Study Unwanted Friend of Friends 
     Another interesting question is the impact of the relation between source user and the unwanted targets to the CT and whether it is necessary to block all the common neighbors. It can be observed in the Foursquare network δ=3 that the closer the distance between sources and unwanted targets, the smaller the CT. The relation between the number of common friends and the CT size was studied. 
       FIGS. 8A-8C  show plots of the average Visibility and CT Size with respect to the number of common friends. As can be seen, the CT Size decreases sharply from 50% to 10% with the increase of the number of common friends. However, the visibility reduces at a much lower rate. Regardless of the number of common neighbors, the visibility is still nearly 60%. 
     Therefore, the case when the unwanted targets are close to the source, is not as bad as it appears. The growing gap between the Visibility and CT size reflects that it is still possible to effectively select high visibility neighbors into the CT despite the shrinking of the CT. 
     Example 
     NP-Hardness of Single-2-MCT 
     Theorem 1: Single-2-MCT is NP-complete. 
     Proof. 
     In the proof, it is easy to see that the decision version of Single-2-MCT∈NP. To prove that Single-2-MCT is NP-hard, the known NP-hard subset sum problem is reduced to the Single-2-MCT. The known NP-hard subset sum problem asks if there exists a non-empty subset whose sum is Z given a set of integers (z 1 , z 2 , . . . , z n ) and an integer Z. Let I be an arbitrary instance of subset sum problem, the construction is as illustrated in  FIG. 9 . As shown in  FIG. 9 , two terminal nodes s, t and n nodes N i , i=1 . . . n are constuced for each item in I. For each node N i , an edge from s to the node N i  is constructed with a sharing probability 
               a     s   ⁢           ⁢   i       =       z   i         ∑   i     ⁢     z   i               
and mention probability
 
               p     s   ⁢           ⁢   i       =     1   -     ⅇ       -       z   i         ∑   i     ⁢     z   i           ;               
and another edge from N i  to t is constructed with mention probability p it =1. The leakage threshold τ is set as
 
             τ   =     1   -     ⅇ     -     z       ∑   i     ⁢     z   i                     
for the target t. It is shown that there is a subset sum of I if and only if the reduced instance has a Single-2-MCT with the expected visible users at least
 
     
       
         
           
             
               Z 
               
                 
                   ∑ 
                   i 
                 
                 ⁢ 
                 
                   z 
                   i 
                 
               
             
             . 
           
         
       
     
     First, suppose that R is a yes instance of I. Now consider a set R′={N i |i∈R}. If s posts his message to R′, then the leakage probability to t is exactly 1−Π i∈R a si p it =τ and the size of CT is 
                   ∑     i   ∈   R       ⁢       z   i         ∑   i     ⁢     z   i           =     Z       ∑   i     ⁢     z   i           ,         
implying R′ is a yes instance of Single-2-MCT.
 
     Conversely, suppose that R′ is a Single-2-MCT instance in G with respect to s and t with the leakage probability τ=1−Π i∈R′ a si p it , that is, 
                 ∑     i   ∈     R   ′         ⁢       z   i         ∑   i     ⁢     z   i           ≤       Z       ∑   i     ⁢     z   i         .           
Then R={i|N i ∈R′} is a subset sum of I. This is because the expected visible friends of R′ is at least
 
                 ∑     i   ∈     R   ′         ⁢       z   i         ∑   i     ⁢     z   i           ≥       Z       ∑   i     ⁢     z   i         .           
Thus,
 
     
       
         
           
             
               
                 ∑ 
                 
                   i 
                   ∈ 
                   R 
                 
               
               ⁢ 
               
                 
                   z 
                   i 
                 
                 
                   
                     ∑ 
                     i 
                   
                   ⁢ 
                   
                     z 
                     i 
                   
                 
               
             
             = 
             
               
                 Z 
                 
                   
                     ∑ 
                     i 
                   
                   ⁢ 
                   
                     z 
                     i 
                   
                 
               
               . 
             
           
         
       
     
     Example 
     Proof: Algorithm 1 is FPTAS 
     To show that Algorithm 1 is FPTAS, first it is shown that the approximation ratio (1−ε) and the time complexity is polynomial in both the input size and error parameter for the Single-2-MCT. 
     Proof. 
     Let C* be the optimal set of CT, π i   ε  be the expected size of CT C obtained by Algorithm 1, and π* be the optimal solution of Single-2-MCT. Then, 
               π   1   ɛ     =           ∑     i   ∈   C       ⁢     a   si       ≥       1   Ad     ⁢       ∑     i   ∈   C       ⁢     A   ⁢     ⌊         a   si     ⁢   Ad     A     ⌋           ≥       1   Ad     ⁢       ∑     i   ∈     C   *         ⁢     A   ⁢     ⌊         a   si     ⁢   Ad     A     ⌋           ≥       1   Ad     ⁢       ∑     i   ∈     C   *         ⁢     A   ⁡     (           a   si     ⁢   Ad     A     -   1     )             =         ∑     i   ∈     C   *         ⁢     (       a   si     -     A   Ad       )       ≥       π   *     -     ɛ   ⁢              C   *          ⁢   max   ⁢     {       a   si     ❘         a   si     ⁢     p   it       ≤   τ       }         S   n           ≥       (     1   -   ɛ     )     ⁢     π   *                 
where the last step holds since max{a si |a si p it ≦τ}≦π* and |C*|≦S n .
 
     Next it is shown that Algorithm 1 has the running time of O(S n   3 /ε). 
     Proof. 
     The running time of Algorithm 1 is dependent on the second phase of dynamic programming, which has its running time O(S n A u ). That is, 
     
       
         
           
             
               
                 
                   S 
                   n 
                 
                 ⁢ 
                 
                   A 
                   u 
                 
               
               ≤ 
               
                 
                   
                     S 
                     n 
                   
                   · 
                   
                     S 
                     n 
                   
                 
                 ⁢ 
                 
                   
                     an 
                     si 
                   
                   A 
                 
               
               ≤ 
               
                 
                   S 
                   n 
                   2 
                 
                 ⁢ 
                 
                   
                     S 
                     n 
                   
                   ɛ 
                 
               
             
             = 
             
               
                 S 
                 n 
                 3 
               
               ɛ 
             
           
         
       
     
     Thus, Algorithm 1 is FPTAS. 
     Example 
     No FPTAS for k≧2 
     There is no FPTAS for 2-MCT problem with any k≧2 unless P=NP. 
     Proof. 
     The 2-MCT problem is reduced from EQUIPARTITION problem, which asks if there exists a subset of items R satisfying both |R|=n/2 and Σ j∈R   ω   j =Σ j∉R   ω   j , given n items with integer weight  ω   j  for j=1, . . . , n and even n. 
     The EQUIPARTITION problem has been proven to be NP-hard by M. Gjoka, M. Kurant, C. T. Butts, and A. Markopoulou, “Walking in Facebook: A case study of unbiased sampling of OSNs,” in Proceedings of IEEE INFOCOM 2010, pages 1-9, IEEE, March 2010. 
     Accordingly, let a set of even number of n items with each integer weight  ω   j  be an arbitrary instance I of EQUIPARTITION. An instance of 2-MCT must be constructed, in polynomial time, such that if there exists a FPTAS to solve the 2-MCT on this instance, this algorithm can be applied to solve the EQUIPARTITION problem on I in polynomial time. 
     The construction, also shown in  FIG. 10 , is as follows. Given n items, n+3 nodes are constructed for graph G: node u i  for each item; a source node s and 2 unwanted targets t 1  and t 2 . The mention probability from s to each u i  is 1. For each u i , the mention probability from him to t 1  and t 2  are 
                 p     i   ⁢           ⁢   1       =       1   -       ⅇ     -       ϖ   i         ∑   i     ⁢     ϖ   i             ⁢           ⁢   and   ⁢           ⁢     p     i   ⁢           ⁢   2           =     1   -     ⅇ     -         ϖ   max     -     ϖ   i           n   ⁢           ⁢     ϖ   max       -       ∑   i     ⁢     ϖ   i                     ⁢                 
respectively. Moreover, τ 1 , τ 2  are set to be 1−e −1/2  and all sharing probabilities are set as a sN(S) =1. It is first shown that there is an EQUIPARTITION of I if and only if the reduced instance has 2-MCT of size at least n/2.
 
     First, suppose that R is a yes instance of I. Clearly, |R|=n/2 and Σ j∈R   ω   j =Σ j∉R   ω   j . Now consider a set R′={N i |i∈R}. If s posts his message to R′, then the leakage probability to t 1  and t 2  are 
               1   -       ∏     i   ∈   R       ⁢           ⁢     (     1   -     p     i   ⁢           ⁢   1         )         =       1   -       ∏     i   ∈   R       ⁢     ⅇ     -       ϖ   i         ∑   i     ⁢     ϖ   i                 =       1   -       ⅇ       -   1     /   2       ⁢     
     ⁢   and   ⁢     
     ⁢   1     -       ∏     i   ∈   R       ⁢           ⁢     (     1   -     p     i   ⁢           ⁢   2         )         =       1   -       ∏     i   ∈   R       ⁢     e     -         ϖ   max     -     ϖ   i           n   ⁢           ⁢     ϖ   max       -       ∑   i     ⁢     ϖ   i                   =     1   -     ⅇ       -   1     /   2                     
which are no larger than τ 1  and τ r2 . And the circle of trust has its size n/2, implying R′ is a yes instance of 2-MCT.
 
     Conversely, suppose that R′ is a 2-MCT instance in G with respect to s and t. By satisfying 
               1   -       ∏     i   ∈     R   ′         ⁢     ⅇ     -       ϖ   i         ∑   i     ⁢     ϖ   i                 ≤     1   -       ⅇ       -   1     /   2       ⁢     
     ⁢   and   ⁢     
     ⁢   1     -       ∏     i   ∈     R   ′         ⁢     ⅇ     -         ϖ   max     -     ϖ   i           n   ⁢           ⁢     ϖ   max       -       ∑   i     ⁢     ϖ   i                   ≤     1   -     ⅇ       -   1     /   2               
it is immediately provided that Σ i∈R′   ω   i ≦½Σ i∈N(s)   ω   i  and Σ i∈R′ ( ω   max − ω   i )≦½(n ω   max −Σ i∈N(s)   ω   i ). After summing these two inequalities up, |R′|≦n/2 is obtained. Since the size of CT is at least n/2, i.e., |R′|≧n/2, |R′|=n/2 is obtained. Then, substituting |R′|=n/2 into the second above inequality, it is provided that Σ i∈R′   ω   i ≧½Σ i∈N(s) w     i . Combining with the first inequality, Σ i∈R′   ω   i =½Σ i∈N(s)   ω   i . Thus, R={i|N i ∈R′} is a EQUIPARTITION of I.
 
     Then, suppose that there is an FPTAS for 2-MCT, it is now attempted to be shown that this polynomial time algorithm can be applied to solve the NP-complete EQUIPARTITION problem, which leads to the contradiction. Let A be an FPTAS algorithm generating an (1−ε)-approximation algorithm for 2-MCT for any ε&gt;0 in polynomial time with respect to both n and 1/ε. When choosing 
               ɛ   =     1     n   +   1         ,         
the following relations between the solution of π A  and optimal solution π* are given as
 
π A ≧(1−ε)π*&gt;π*−π*/ n ≧π*−1
 
     where the last step follows from a trivial observation that π*≦n. Due to the equivalence between EQUIPARTITION and 2-MCT in the above reduction, a solution π A &gt;π*−1 for EQUIPARTITION can be obtained. However, the integrality of the solution to EQUIPARTITION implies that π*=┌π A ┐, which means that A can solve the EQUIPARTITION problem in polynomial time. This contradicts the fact that EQUIPARTITION is NP-hard. 
     Example 
     Proof: Algorithm 3 is a 1/(k+1) Approximation Algorithm of Bounded-2-MCT 
     Algorithm 3 is a 
             1     k   +   1           
approximation algorithm of Bounded-2-MCT.
 
     Proof. 
     According to D. G. Luenberger, “Linear and Nonlinear Programming, Second Edition, Springer, September 2003, each LP formulation with n variables and d constraints has a basic optimal solution with at most min{d, n} fractional values. It is possible to obtain such a basic optimal solution x* in the first step. Then 
               π   *     ≤     π   LP     ≤         ∑     i   ∈   I       ⁢           ⁢     a   i       +     kF   max       ≤       (     k   +   1     )     ⁢     π   k             
where the last step follows from Algorithm 3.
 
     Example 
     Proof: Algorithm 2 is PTAS 
     To show that Algorithm 2 is PTAS, first it is shown that the approximation ratio (1−ε) and the time complexity is polynomial in the input size. 
     Proof: 
     If π* has less than β items, it is possible to obtain the optimal solution in the first phase by enumerating all possible combinations. This certainly leads to the optimal solution. When π*&gt;β, let Q* be the β items having the maximum circle of trust in the optimal solution and consider two cases as follows: 
     
       
         
           
             
               Case 
               ⁢ 
               
                   
               
               ⁢ 
               1 
               ⁢ 
               
                 
                   : 
                 
               
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   ∑ 
                   
                     i 
                     ∈ 
                     Ω 
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   * 
                   
                     a 
                     i 
                   
                 
               
             
             ≥ 
             
               
                 β 
                 
                   β 
                   + 
                   k 
                   + 
                   1 
                 
               
               ⁢ 
               
                 π 
                 * 
               
             
           
         
       
     
     From the last step and the condition of this case: 
     
       
         
           
             
               
                 
                   
                     π 
                     ɛ 
                   
                   ≥ 
                     
                   ⁢ 
                   
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           
                             Ω 
                             * 
                           
                         
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         a 
                         i 
                       
                     
                     + 
                     
                       π 
                       Ω 
                       k 
                     
                   
                 
               
             
             
               
                 
                   ≥ 
                     
                   ⁢ 
                   
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           
                             Ω 
                             * 
                           
                         
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         a 
                         i 
                       
                     
                     + 
                     
                       
                         1 
                         
                           k 
                           + 
                           1 
                         
                       
                       ⁢ 
                       
                         
                           π 
                           Ω 
                           * 
                         
                         ⁡ 
                         
                           ( 
                           Lemma 
                           ) 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   ≥ 
                     
                   ⁢ 
                   
                     
                       
                         ∑ 
                         
                           i 
                           ∈ 
                           
                             Ω 
                             * 
                           
                         
                       
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         a 
                         i 
                       
                     
                     + 
                     
                       
                         1 
                         
                           k 
                           + 
                           1 
                         
                       
                       ⁢ 
                       
                         ( 
                         
                           
                             π 
                             * 
                           
                           - 
                           
                             
                               ∑ 
                               
                                 i 
                                 ∈ 
                                 
                                   Ω 
                                   * 
                                 
                               
                             
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               a 
                               i 
                             
                           
                         
                         ) 
                       
                       ⁢ 
                       
                         ( 
                         
                           Definition 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           of 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             Ω 
                             * 
                           
                         
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   
                     ≥ 
                       
                     ⁢ 
                     
                       
                         
                           1 
                           
                             k 
                             + 
                             1 
                           
                         
                         ⁢ 
                         
                           π 
                           * 
                         
                       
                       + 
                       
                         
                           k 
                           
                             k 
                             + 
                             1 
                           
                         
                         ⁢ 
                         
                           β 
                           
                             
                               β 
                               + 
                               k 
                               + 
                               1 
                             
                             ⁢ 
                             
                                 
                             
                           
                         
                         ⁢ 
                         
                           π 
                           * 
                         
                       
                     
                   
                   = 
                   
                     
                       
                         β 
                         + 
                         1 
                       
                       
                         β 
                         + 
                         k 
                         + 
                         1 
                       
                     
                     ⁢ 
                     
                       π 
                       * 
                     
                   
                 
               
             
           
         
       
       
         
           
             
               Case 
               ⁢ 
               
                   
               
               ⁢ 
               2 
               ⁢ 
               
                 : 
               
               ⁢ 
               
                   
               
               ⁢ 
               
                 
                   ∑ 
                   
                     i 
                     ∈ 
                     
                       Ω 
                       * 
                     
                   
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   a 
                   i 
                 
               
             
             &lt; 
             
               
                 β 
                 
                   β 
                   + 
                   k 
                   + 
                   1 
                 
               
               ⁢ 
               
                 π 
                 * 
               
             
           
         
       
     
     First, among all these β neighbors of s, there is at least one having sharing probability less than 
               1     β   +   k   +   1       ⁢       π   *     .           
According to the definition of Ω*, i.e., all neighbors in Ω* have higher sharing probability than others, all neighbors in π Ω   k  have
 
     
       
         
           
             
               a 
               i 
             
             ≤ 
             
               
                 1 
                 
                   β 
                   + 
                   k 
                   + 
                   1 
                 
               
               ⁢ 
               
                 
                   π 
                   * 
                 
                 . 
               
             
           
         
       
     
     
       
         
           
             
               π 
               Ω 
               * 
             
             ≤ 
             
               π 
               Ω 
               LP 
             
             ≤ 
             
               
                 π 
                 Ω 
                 k 
               
               + 
               
                 
                   k 
                   
                     β 
                     + 
                     k 
                     + 
                     1 
                   
                 
                 ⁢ 
                 
                   π 
                   Ω 
                   * 
                 
               
             
           
         
       
     
     where the last step follows from the upper bound of all k fractional values according to D. G. Luenberger, “Linear and Nonlinear Programming, Second Edition, Springer, September 2003. Therefore, 
     
       
         
           
             
               π 
               * 
             
             = 
             
               
                 
                   
                     ∑ 
                     
                       i 
                       ∈ 
                       
                         Ω 
                         * 
                       
                     
                   
                   ⁢ 
                   
                       
                   
                   ⁢ 
                   
                     a 
                     i 
                   
                 
                 + 
                 
                   π 
                   Ω 
                   * 
                 
               
               ≤ 
               
                 
                   π 
                   ɛ 
                 
                 + 
                 
                   
                     k 
                     
                       β 
                       + 
                       k 
                       + 
                       1 
                     
                   
                   ⁢ 
                   
                     π 
                     Ω 
                     * 
                   
                 
               
             
           
         
       
       
         
           
             Then 
             , 
             
               
 
             
             ⁢ 
             
               
                 
                   π 
                   ɛ 
                 
                 ≥ 
                 
                   
                     
                       β 
                       + 
                       1 
                     
                     
                       β 
                       + 
                       k 
                       + 
                       1 
                     
                   
                   ⁢ 
                   
                     π 
                     * 
                   
                 
                 ≥ 
                 
                   
                     
                       
                         ⌈ 
                         
                           k 
                           ɛ 
                         
                         ⌉ 
                       
                       - 
                       k 
                     
                     
                       ⌈ 
                       
                         k 
                         ɛ 
                       
                       ⌉ 
                     
                   
                   ⁢ 
                   
                     π 
                     * 
                   
                 
                 ≥ 
                 
                   
                     
                       
                         1 
                         ɛ 
                       
                       - 
                       1 
                     
                     
                       1 
                       ɛ 
                     
                   
                   ⁢ 
                   
                     π 
                     * 
                   
                 
               
               = 
               
                 
                   ( 
                   
                     1 
                     - 
                     ɛ 
                   
                   ) 
                 
                 ⁢ 
                 
                   π 
                   * 
                 
               
             
           
         
       
     
     where the second step follows from the fact that 
               β   +   1       β   +   k   +   1           
is monotonously increasing with respect to β.
 
     Next it is shown that Algorithm 2 has the running time of O(S n   3 /ε), where constant κ is the upper bound of the number of unwanted targets k. 
     Proof. 
     It is easy to see that the first phase has the running time at most 
               S   n       ⌈     k   ɛ     ⌉     -     (     k   +   1     )         .         
For the second phase, LP (2) is solved S n   β  times. According to N. Megiddo and A. Tamir, “Linear time algorithms for some separable quadratic programming problems,” Operations Research Letters, 13:203-211, 1993, LP (2) S n   β  can be solved in O(S n ) when k is upper bounded by some constant κ. Hence, the overall running time of Algorithm 3 is O(S n   ┌κ/ε┐ ).
 
     Thus, Algorithm 2 is PTAS. 
     Example 
     Algorithm 4 Feasibility of Solution 
     The probability that the rounded integral solution x I  in Algorithm 4 leads to Σ i∈N(s)\T a i x i ≧δπ* is larger than 0 where β=μ/2 is shown as follows. 
     Proof. 
     The probability of infeasibility is shown to be less than 1. In particular, the infeasibility is two-fold: (1) any constraint is violated; (2) the solution is less than βπ*. 
     First, the probability that a constraint is violated is 
     
       
         
           
             
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       [ 
                       
                         constraint 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         j 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         is 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         violated 
                       
                       ] 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     
                       Pr 
                       [ 
                       
                         
                           
                             ∑ 
                             
                               i 
                               ∈ 
                               
                                 
                                   N 
                                   ⁡ 
                                   
                                     ( 
                                     s 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 \ 
                                 ⁢ 
                                 T 
                               
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               w 
                               ij 
                             
                             ⁢ 
                             
                               x 
                               I 
                             
                           
                         
                         &gt; 
                         
                           c 
                           j 
                         
                       
                       ] 
                     
                     = 
                   
                 
               
             
             
               
                 
                     
                   ⁢ 
                   
                     Pr 
                     [ 
                     
                       
                         μ 
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               ∈ 
                               
                                 
                                   N 
                                   ⁡ 
                                   
                                     ( 
                                     s 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 \ 
                                 ⁢ 
                                 T 
                               
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               w 
                               ij 
                             
                             ⁢ 
                             
                               x 
                               i 
                               L 
                             
                           
                         
                       
                       &gt; 
                       
                         c 
                         j 
                       
                     
                     ] 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     Pr 
                     [ 
                     
                       
                         μ 
                         ⁢ 
                         
                           
                             ∑ 
                             
                               i 
                               ∈ 
                               
                                 
                                   N 
                                   ⁡ 
                                   
                                     ( 
                                     s 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 \ 
                                 ⁢ 
                                 T 
                               
                             
                           
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             
                               w 
                               ij 
                             
                             ⁢ 
                             
                               x 
                               i 
                               L 
                             
                           
                         
                       
                       &gt; 
                       
                         
                           ( 
                           
                             1 
                             + 
                             
                               
                                 1 
                                 - 
                                 μ 
                               
                               μ 
                             
                           
                           ) 
                         
                         ⁢ 
                         μ 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           c 
                           j 
                         
                       
                     
                     ] 
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     
                       Pr 
                       ⁡ 
                       
                         [ 
                         
                           
                             
                               
                                 
                                   
                                     μ 
                                     
                                       
                                         max 
                                         i 
                                       
                                       ⁢ 
                                       
                                         w 
                                         ij 
                                       
                                     
                                   
                                   ⁢ 
                                   
                                     
                                       ∑ 
                                       
                                         i 
                                         ∈ 
                                         
                                           
                                             N 
                                             ⁡ 
                                             
                                               ( 
                                               s 
                                               ) 
                                             
                                           
                                           ⁢ 
                                           \ 
                                           ⁢ 
                                           T 
                                         
                                       
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     
                                       
                                         w 
                                         ij 
                                       
                                       ⁢ 
                                       
                                         x 
                                         i 
                                         L 
                                       
                                     
                                   
                                 
                                 &gt; 
                               
                             
                           
                           
                             
                               
                                 
                                   ( 
                                   
                                     1 
                                     + 
                                     
                                       
                                         1 
                                         - 
                                         μ 
                                       
                                       μ 
                                     
                                   
                                   ) 
                                 
                                 ⁢ 
                                 μ 
                                 ⁢ 
                                 
                                     
                                 
                                 ⁢ 
                                 
                                   
                                     c 
                                     j 
                                   
                                   
                                     
                                       max 
                                       i 
                                     
                                     ⁢ 
                                     
                                       w 
                                       ij 
                                     
                                   
                                 
                               
                             
                           
                         
                         ] 
                       
                     
                     &lt; 
                     
                       
                         ( 
                         
                           μ 
                           ⁢ 
                           
                               
                           
                           ⁢ 
                           
                             ⅇ 
                             
                               1 
                               - 
                               μ 
                             
                           
                         
                         ) 
                       
                       
                         
                           c 
                           ^ 
                         
                         j 
                       
                     
                   
                 
               
             
           
         
       
     
     where the last step follows from equation (4) in the section entitled “Example: Algorithm 4 Feasibility of Solution” 
               since   ⁢           ⁢       w   ij         max   i     ⁢     w   ij           ∈       (     0   ,   1     ]     .           
Thus, the probability that any constraint is violated is upper bounded by
 
               1   -       ∏   j     ⁢           ⁢     [     1   -       (     μⅇ     1   -   μ       )         c   ^     j         ]         ≤     1   -       [     1   -       (     μⅇ     1   -   μ       )       c   ^         ]     k             
since (μe 1-μ ) ĉ     j    monotonously increases with respect to ĉ j .
 
     Second, the probability that the solution is less than βπ* is upper bounded as 
                     Pr   ⁡     [     π   &lt;     β   ⁢           ⁢     π   *         ]       =       ⁢     Pr   [         ∑     i   ∈       N   ⁡     (   s   )       ⁢   \   ⁢   T         ⁢           ⁢       a   i     ⁢     x   i   I         &lt;     β   ⁢           ⁢     π   *         ]                 =       ⁢       Pr   [       μ   ⁢       ∑     i   ∈       N   ⁡     (   s   )       ⁢   \   ⁢   T         ⁢           ⁢       a   i     ⁢     x   i   L           &lt;     β   ⁢           ⁢     π   *         ]     ≤     Pr   [       μ   ⁢       ∑     i   ∈       N   ⁡     (   s   )       ⁢   \   ⁢   T         ⁢           ⁢       a   i     ⁢     x   i   L           &lt;     βπ   LP   *       ]                   =       ⁢     Pr   [       μ   ⁢       ∑     i   ∈       N   ⁡     (   s   )       ⁢   \   ⁢   T         ⁢           ⁢       a   i     ⁢     x   i   L           &lt;       (     1   -       μ   -   β     μ       )     ⁢       μ   ⁢   π     LP   *         ]                 ≤       ⁢     ⅇ     -         μπ   LP   *     ⁡     (       μ   -   β     μ     )         2     /   2                         
where the third step holds since the optimal solution of LP π* LP  is surely no less than the optimal solution π*; the last step follows from equation (5) as well.
 
     Therefore, when μ=α(π* LP /k) 1/(ĉ-1)  and β=μ/2, the upper bound of infeasibility probability can be written as 
     
       
         
           
             
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       [ 
                       
                         
                           x 
                           I 
                         
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         is 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         infeasible 
                       
                       ] 
                     
                   
                   = 
                     
                   ⁢ 
                   
                     1 
                     - 
                     
                       
                         [ 
                         
                           1 
                           - 
                           
                             
                               ( 
                               
                                 μⅇ 
                                 
                                   1 
                                   - 
                                   μ 
                                 
                               
                               ) 
                             
                             
                               c 
                               ^ 
                             
                           
                         
                         ] 
                       
                       k 
                     
                     + 
                     
                       ⅇ 
                       
                         - 
                         
                           
                             
                               μπ 
                               LP 
                               * 
                             
                             ⁡ 
                             
                               ( 
                               
                                 
                                   μ 
                                   - 
                                   β 
                                 
                                 μ 
                               
                               ) 
                             
                           
                           
                             2 
                             
                               / 
                               2 
                             
                           
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     1 
                     - 
                     
                       
                         [ 
                         
                           1 
                           - 
                           
                             ⅇ 
                             
                               
                                 c 
                                 ^ 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   1 
                                   + 
                                   
                                     ln 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     μ 
                                   
                                   - 
                                   μ 
                                 
                                 ) 
                               
                             
                           
                         
                         ] 
                       
                       k 
                     
                     + 
                     
                       ⅇ 
                       
                         - 
                         
                           μπ 
                           
                             LP 
                             
                               / 
                               8 
                             
                           
                           * 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                   ⁢ 
                   
                     1 
                     - 
                     
                       
                         [ 
                         
                           1 
                           - 
                           
                             ⅇ 
                             
                               
                                 c 
                                 ^ 
                               
                               ⁡ 
                               
                                 ( 
                                 
                                   1 
                                   + 
                                   
                                     ln 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     μ 
                                   
                                 
                                 ) 
                               
                             
                           
                         
                         ] 
                       
                       k 
                     
                     + 
                     
                       ⅇ 
                       
                         - 
                         
                           μπ 
                           
                             LP 
                             
                               / 
                               8 
                             
                           
                           * 
                         
                       
                     
                   
                 
               
             
             
               
                 
                   ≤ 
                     
                   ⁢ 
                   
                     1 
                     - 
                     
                       ⅇ 
                       
                         
                           - 
                           η 
                         
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ke 
                           
                             
                               c 
                               ^ 
                             
                             ⁡ 
                             
                               ( 
                               
                                 1 
                                 + 
                                 
                                   ln 
                                   ⁢ 
                                   
                                       
                                   
                                   ⁢ 
                                   μ 
                                 
                               
                               ) 
                             
                           
                         
                       
                     
                     + 
                     
                       ⅇ 
                       
                         - 
                         
                           μπ 
                           
                             LP 
                             
                               / 
                               8 
                             
                           
                           * 
                         
                       
                     
                   
                   ≤ 
                   1 
                 
               
             
           
         
       
     
     where the fourth step holds since the constant α&lt;½ exists such that 1+ln μ&gt;1 and ĉ&gt;1. Thus the rounded integral solution x I  in Algorithm 4 leads to Σ i ∈N(s)\T a i x i ≧βπ* is larger than 0 where β=μ/2. 
     Next, to illustrate a Chernoff-type bound, let λ 1 , . . . , λ n  be the real numbers in (0,1] and X 1 , . . . , X n  be independent Bernoulli trials with E[X i ]=p i . Then, consider the random variable X=Σ i=1   n λ i X i , for any β≧0, 
     
       
         
           
             
               
                 
                   
                     Pr 
                     ⁡ 
                     
                       [ 
                       
                         x 
                         &gt; 
                         
                           
                             ( 
                             
                               1 
                               + 
                               δ 
                             
                             ) 
                           
                           ⁢ 
                           m 
                         
                       
                       ] 
                     
                   
                   &lt; 
                   
                     
                       [ 
                       
                         
                           ⅇ 
                           δ 
                         
                         
                           
                             ( 
                             
                               1 
                               + 
                               δ 
                             
                             ) 
                           
                           
                             ( 
                             
                               1 
                               + 
                               δ 
                             
                             ) 
                           
                         
                       
                       ] 
                     
                     m 
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
     and when 0≦δ&lt;1,
 
 Pr[x &lt;(1−δ) m]&lt;e   −mδ     2     /2   (5)
 
     where m=E[X]=Σ i=1   n λ i p i . 
     Then, by using the method of conditional probability as described by P. Raghavan, “Probabilistic construction of deterministic algorithms: approximating packing integer problems,” J. Comput. Syst. Sci., 37:130-143, October 1988, it is possible to derandomize the above randomized algorithm to obtain a deterministic solution and there exists a polynomial-time deterministic algorithm with expected size of CT at least 
     
       
         
           
             
               Ω 
               ( 
               
                 
                   ( 
                   
                     OPT 
                     k 
                   
                   ) 
                 
                 
                   1 
                   
                     
                       c 
                       ^ 
                     
                     - 
                     1 
                   
                 
               
               ) 
             
             . 
           
         
       
     
     Proof. Because there is a probability larger than 0 that the rounded integral solution x I  in Algorithm 4 leads to Σ i∈N(s)\T a i x i ≧δπ* where β=μ/2, there exists a solution with expected size of CT at least 
               Ω   (       (     OPT   k     )       1       c   ^     -   1         )     .         
Therefore, since π* LP ≧OPT, it is possible to derandomize the above randomized algorithm to obtain a deterministic solution.
 
     Example 
     Inapproximability Results 
     The inapproximability of the theoretical bound Σ i∈N(s)\T a i x i ≧δπ* is larger than 0 where β=μ/2, illustrates that the theoretical guarantee is tight most of the time. 
     
       
         
           
             Ω 
             ( 
             
               
                 ( 
                 
                   1 
                   k 
                 
                 ) 
               
               
                 1 
                 
                   
                     ⌊ 
                     
                       c 
                       ^ 
                     
                     ⌋ 
                   
                   + 
                   1 
                 
               
             
             ) 
           
         
       
     
     It can be shown that 2-MCT is hard to be approximated within a factor of unless NP=ZPP when ĉ&gt;1. 
     Proof. 
     In this proof, it is shown that the gap-preserving reduction from maximum independent set (MIS) problem to the 2-MCT, where MIS has been proven hard to be approximated into n 1-ε  on general graphs unless NP=ZPP. Given an arbitrary instance G=(V,E) of MIS with |V|=n nodes and |E|=m edges, an arbitrary positive constant z is used to construct the 2-MCT instance I(G) as follows: 
     (1) a source node s and n neighbor nodes N i  of s; 
     
       
         
           
             
               
                 ( 
                 2 
                 ) 
               
               ⁢ 
               
                   
               
               ⁢ 
               
                 ( 
                 
                   
                     
                       n 
                     
                   
                   
                     
                       
                         
                           ⌊ 
                           
                             c 
                             ^ 
                           
                           ⌋ 
                         
                         + 
                         1 
                       
                     
                   
                 
                 ) 
               
               ⁢ 
               
                   
               
               ⁢ 
               unwanted 
               ⁢ 
               
                   
               
               ⁢ 
               targets 
               ⁢ 
               
                   
               
               ⁢ 
               
                 t 
                 j 
               
             
             ; 
           
         
       
     
     (3) from s to each of its neighbors, both the mention probability p sN(s)  and sharing probability a sN(s)  are set to 1; 
     (4) for each unwanted target t j , edges are constructed from vεN(s) to it if v is in the i th  combination of └ĉ┘+1 elements from all n neighbors of s. Moreover, the probability of all these edges are set either to 
             1   -     ⅇ     1       ⌊     c   ^     ⌋     +   1               
if all these nodes induce a clique in G and 0 otherwise. The leakage threshold of all unwanted targets are set to
 
     
       
         
           
             1 
             - 
             
               
                 ⅇ 
                 
                   
                     ⌊ 
                     
                       c 
                       ^ 
                     
                     ⌋ 
                   
                   
                     
                       ⌊ 
                       
                         c 
                         ^ 
                       
                       ⌋ 
                     
                     + 
                     1 
                   
                 
               
               . 
             
           
         
       
     
       FIGS. 11A and 11B  illustrate an example of this construction. 
     Then, let φ and Φ be feasible solutions of MIS on G and 2-MCT on I(G). The completeness and soundness can be shown, respectively, given any positive number of edges m. 
     First, when OPT(φ)&gt;m, it si shown that OPT(Φ)&gt;m. Clearly, it is easy to see that all constraints are satisfied if the neighbors who belong to independent set of G are selected in I(G). This is because for any unwanted target connecting from any of these nodes, there are only two cases: 
     1. All probabilities are 0 if the neighbor nodes of s connecting this unwanted target do not induce a clique in G; 
     2. Otherwise, only one neighbor node of s belong to any independent set of G since these neighbor nodes consist of a clique in G. Therefore, the constraint trivially satisfies in both cases. 
     Secondly, when 
                 OPT   ⁡     (   ϕ   )       &lt;       1     n     1   -   ɛ         ⁢   m       ,         
it can be shown that
 
               OPT   ⁡     (   φ   )       &lt;       1     O   (     k       1       ⌊     c   ^     ⌋     +   1       -     ɛ   ′         )       ⁢     m   .             
Consider the feasible solution Φ on I(G), all constraints have to be satisfied. That is, the subgraph G(Φ) of G consisting of the nodes in Φ has its maximum clique at most └ĉ┘+1. Otherwise, at least one unwanted target will receive the message with probability 1 and therefore violate the constraint. Then, according to the following Lemma, the size of maximum independent set on G(Φ) is at least
 
     
       
         
           
             
               O 
               ( 
               
                 
                    
                   φ 
                    
                 
                 
                   1 
                   
                     ⌊ 
                     
                       c 
                       ^ 
                     
                     ⌋ 
                   
                 
               
               ) 
             
             . 
           
         
       
     
     Clearly, there is shown the size of maximum independent set on G being larger than 
               O   (          φ          1     ⌊     c   ^     ⌋         )     .         
Therefore,
 
     
       
         
           
             
               O 
               ( 
               
                 
                    
                   φ 
                    
                 
                 
                   1 
                   
                     ⌊ 
                     
                       c 
                       ^ 
                     
                     ⌋ 
                   
                 
               
               ) 
             
             &lt; 
             
               O 
               ( 
               
                 
                   OPT 
                   ⁡ 
                   
                     ( 
                     φ 
                     ) 
                   
                 
                 ⁢ 
                 
                   φ 
                   
                     1 
                     
                       ⌊ 
                       
                         c 
                         ^ 
                       
                       ⌋ 
                     
                   
                 
               
               ) 
             
             &lt; 
             
               
                 1 
                 
                   n 
                   
                     1 
                     - 
                     ɛ 
                   
                 
               
               ⁢ 
               m 
             
           
         
       
     
     That is, 
                 OPT   ⁡     (   φ   )       &lt;       [     O   ⁡     (       1     n     1   -   ɛ         ⁢   m     )       ]       ⌊     c   ^     ⌋         =           O   ⁡     (       [     O   ⁡     (       1     n     1   -   ɛ         ⁢     m     1   -     1     ⌊     c   ^     ⌋             )       ]       ⌊     c   ^     ⌋       )       ⁢   m     ≤       O   (       [     O   (     n     ɛ   -     1     ⌊     c   ^     ⌋           )     ]       ⌊     c   ^     ⌋       )     ⁢   m       =         O   ⁡     (     1     n     1   -     ɛ   ⁢     ⌊     c   ^     ⌋             )       ⁢   m     =         O   (     1     k       1   -     ɛ   ⁢     ⌊     c   ^     ⌋             ⌊     c   ^     ⌋     +   1           )     ⁢   m     =       O   (     1       k     1       ⌊     c   ^     ⌋     +   1         -     ɛ   ′         )     ⁢   m                 
where ε′=ε└ĉ┘ and the third inequality follows from the fact m≦n.
 
     Lemma: 
     Given a graph G with n nodes, if the size of maximum clique on G is less than any constant γ, the size of maximum independent set on G has to be at least 
     
       
         
           
             
               O 
               ( 
               
                 n 
                 
                   1 
                   
                     γ 
                     - 
                     1 
                   
                 
               
               ) 
             
             . 
           
         
       
     
     Proof. 
     Assume that both the size of maximum clique on G is less than γ and the size of maximum independent set on G is less than n 1/γ , the contradiction to the Ramsey&#39;s Theorem can be shown. Ramsey&#39;s Theorem states that for any s, t≧1, there is R(s,t)&lt;∞ such that any graph on R(s,t) vertices contains either an independent set of size s or a clique of size t. In particular, 
     
       
         
           
             
               R 
               ⁡ 
               
                 ( 
                 
                   s 
                   , 
                   t 
                 
                 ) 
               
             
             ≤ 
             
               
                 ( 
                 
                   
                     
                       
                         s 
                         + 
                         t 
                         - 
                         2 
                       
                     
                   
                   
                     
                       
                         s 
                         - 
                         1 
                       
                     
                   
                 
                 ) 
               
               . 
             
           
         
       
     
     According to the Ramsey&#39;s Theorem, under the assumption of the size of maximum clique and maximum independent set on G, the graph G has to contain less than R(γ,O(n 117-1 )) nodes. Therefore, G contains γ+O(n 1/γ-1 )−2 nodes. However, 
             γ   -   1                 γ   +     O   ⁡     (     n       1   /   γ     -   1       )       -     2   ⁢   γ     -   1     =         (       e   ⁡     (     γ   +       c   γ     ⁢     n       1   /   γ     -   1         -   2     )         γ   -   1       )       γ   -   1       =   n           
where the constant c γ  is certainly exists since the equation has order n and γ is a constant. Thus the size of maximum independent set on G is at least
 
     
       
         
           
             
               O 
               ( 
               
                 n 
                 
                   1 
                   
                     γ 
                     - 
                     1 
                   
                 
               
               ) 
             
             . 
           
         
       
     
     Example 
     Proof: δ-MCT Problem is #P-Hard when δ≧3 
     Proof. 
     The reduction from the 3-Conn 2  problem will be shown and proven to be #P-hard. 
     The 3-Conn 2  can be defined as follows. Given a directed graph G with |V|=n nodes and a probability p(u,v) for each pair of nodes denoting the probability of u being able to connect to v. Let s and t be two terminals in G. 3-Conn 2  asks for the probability that there is a path from source s to destination t in G and the path has its length no larger than 3 hops. 
     First, for the reduction, the 3-Conn 2  problem can be polynomially solved if it is possible to determine that 3-Conn 2 ≦r′/r in a graph G for any integer r′≦r. Since each p(u,v) in G is a rational number which can be represented by a numerator and a denominator which are integers, r can be defined to be the least common multiple of all the denominators such that a simple binary search from 1 to r can be finished within a polynomial time with respect to the input size. 
     Therefore, let G, s and t be an arbitrary instance of 3-Conn 2 , then a polynomial time a graph G′=(V′, E′), a source user s and a set of unwanted targets T along with their leakage thresholds τ j  is constructed for each of the unwanted targets such that if there is a polynomial-time algorithm to solve the δ-MCT problem on ther reduced instance, this algorithm can be applied to determine the upper bound of 3-Conn 2  problem on G. 
     As shown in  FIG. 12 , the construction is as follows. First, s′=s and T={t}. Then the sharing probability in each edge of G is set to be 1/|N(s)|+ε 1  where 
             0   &lt;     ɛ   1     &lt;     1            N   ⁡     (   s   )            ⁢     (            N   ⁡     (   s   )            -   1     )               
and |N(s)| is the number of neighbors of s. The mention probability is set to p(i,j) in G for each edge. Then, a two-hop disjoint path is added between and t onto the graph G with the intermediate node u. Both edges (s,u) and (u,t) have the sharing probability to be 1. And p su =1 and p ut =r′≦r+ε 2  for any integer r′≦r and ε 2 &lt;1/r. In addition, T={t} and its leakage threshold is set to r′/r+ε 2 .
 
     Assume that A is a polynomial algorithm solving δ-MCT problem in the reduced instance illustrated in  FIG. 12 . Let&#39;s consider two cases:
         If A returns the circle of trust with size larger than 1, it is known that all neighbors of s in G except u is visible to the message. That is, the 3-Conn 2  in G, s and t is less than or equal to r′/r;   If A returns the circle of trust with size equal to 1, that is, A selected only one neighbor u of s since the visibility       

                 (       1          N   ⁡     (   s   )              +     ɛ   1       )     ⁢     (            N   ⁡     (   s   )            -   1     )       &lt;   1         
when
 
               ɛ   1     &lt;     1            N   ⁡     (   s   )            ⁢     (            N   ⁡     (   s   )            -   1     )               
if only selecting N  1  neighbors of s in G. Clearly, 3-Conn 2  in G, s and t is larger than r′/r.
 
     Thus, A can be used to decide if 3-Conn 2  is less than r′/r, implying that the δ-MCT problem is at least as hard as 3-Conn 2 . 
     To prove the #P-hardness of 3-Conn 2 , 3-Conn 2  is reduced from Counting Bipartite Independent Set (CBIS) problem which is defined as follows. 
     Given a bipartite graph G=(U,V;E), the problem asks for the total number of independent sets, where a subset of nodes is an independent set if no two nodes in this set are adjacent. 
     Proof. 
     In this proof, the 3-Conn 2  problem is reduced from the CBIS problem, which has been proven to be #P-hard by Provan et al. “The Complexity of Counting Cuts and of Computing the Probability that a Graph is Connected,”  SIAM Journal on Computing,  12(4):777-788, 1983. Let a graph G=(U,V;E) be an arbitrary instance of CBIS. There must be constructed in polynomial time a probabilistic graph G′ and two terminals s, t such that if there exists a polynomial-time algorithm to solve the 3-Conn 2  problem on the reduced instance, this algorithm can be applied to solve CBIS problem on G. 
     The reduction is two phases: First, the probabilistic graph H is constructed by adding two terminals s and t onto G. Between s and each u∈U, there is added deg(u) number of edges where deg(u) is the degree of u in G. Similarly, between each v∈U and t, there is added deg(v) number of edges. And all edges in H have probability p with 0&lt;p&lt;1. Second, the probabilistic graph G′ is constructed on H by replacing the multi-edges between each pair of nodes (u,v) with an edge of probability 1−(1−p) γ  where γ is the number of multi-edges between u and v. Note that the paths between s and t in G′ are at most 3-hops. This reduction is depicted for an example in  FIGS. 13A-13C . 
     Then it can first be shown that CBIS in G is equivalent to counting the minimum cardinality s−t cutsets in H. It is easy to see that the construction ensures that the s−t cutsets contain at least |E| edges. Also, it is clear that if there are deg(u)&gt;1 edges between s and u, a minimum cutset includes either all or none of them. In addition, it is noted that (u,v) must not be an edge of G if both (s,u) and (v,t) are included in a minimum cut since it is possible to reduce the size of cutset by simply replacing the multi-edges in (s,u) and (v,t) with the edges incident to u and v in G, which contradicts that the cutset is minimum. 
     Therefore, suppose I u ∪I v  is an independent set in G where I u    ⊂ U and I v   ⊂ V, the cutset consists of (s,u) for all u∈I u , (v,t)∈I v  for all v∈I v  and all edges in E not incident to I u ∪I v . Conversely, suppose C is a minimum cutset in H, according to the above arguments, the endpoints (except s and t) incident to the edges in C\E forms an independent set in G. 
     Furthermore, it is easy to see that the probability that there is a path from s to t is the same in H and G′ since only multi-edges in H are replaced in G′ with simple edges with the same probability. If the 3-Conn 2  between s and t can be determined in G′ (also H), this is suffices to computer the s−t pathset numbers. Thus, the minimum s t cutsets can be further counted using the pathset, implying that 3-Conn 2  is at least as hard as CBIS. 
     Any reference in this specification to “one embodiment,” “an embodiment,” “example embodiment,” etc., means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the invention. The appearances of such phrases in various places in the specification are not necessarily all referring to the same embodiment. In addition, any elements or limitations of any invention or embodiment thereof disclosed herein can be combined with any and/or all other elements or limitations (individually or in any combination) or any other invention or embodiment thereof disclosed herein, and all such combinations are contemplated with the scope of the invention without limitation thereto. 
     It should be understood that the examples and embodiments described herein are for illustrative purposes only and that various modifications or changes in light thereof will be suggested to persons skilled in the art and are to be included within the spirit and purview of this application.