System architecture and method of processing data therein

Abstract

A method of performing ordered statistics between at least two parties is disclosed which includes identifying a first dataset (x.sub.A) by a first node (A), identifying a second dataset (x.sub.B) by a second node (B), wherein x.sub.B is unknown to A and x.sub.A is unknown to B, and wherein A is in communication with B, and wherein A and B are in communication with a server (S), A and B each additively splitting each member of their respective datasets into corresponding shares, sharing the corresponding shares with one another, arranging the corresponding shares according to a mutually agreed predetermined order into corresponding ordered shares, shuffling the ordered shares into shuffled shares, re-splitting the shuffled shares into re-split shuffled shares, and performing an ordered statistical operation on the re-split shuffled shares, wherein the steps of shuffle and re-split is based on additions, subtractions but not multiplication and division.

Claims

1. A computing system architecture, comprising: a first node (A) having a first dataset (x.sub.A); a second node (B) having a second dataset (x.sub.B), wherein x.sub.B is unknown to A and x.sub.A is unknown to B, and wherein A is in communication with B; a server (S) in communication with A and B; A including a first processor and B including a second processor, the first and the second processors each having software encoded on a non-transitory computer readable medium configured to: additively split each member of their respective datasets into corresponding shares; share the corresponding shares with one another; arrange the corresponding shares according to a mutually agreed predetermined order into corresponding ordered shares; shuffle the ordered shares into shuffled shares; re-split the shuffled shares into re-split shuffled shares; and perform an ordered statistical operation on the re-split shuffled shares, wherein the steps of shuffle and re-split is based on additions, subtractions but not multiplication and division.

2. The computing system architecture of claim 1, wherein additive split of each member of the corresponding dataset includes: generate a random number associated therewith, and split each member of the corresponding dataset as an algebraic sum of the associated random number and an associated remainder.

3. The computing system architecture of claim 1, wherein the step of sharing the corresponding shares with one another includes: the first processor communicating the random number associated with each member of the corresponding dataset generated to the second processor, and the second processor communicating the remainder associated with each member of the corresponding dataset to the first processor.

4. The computing system architecture of claim 1, wherein the step of arranging the corresponding shares is according to a mutually agreed predetermined order includes concatenation.

5. The computing system architecture of claim 4, wherein the concatenation includes: the first processor concatenating remainders of the first dataset with the remainders communicated by the second processor, thereby generating a first ordered sequence of shares, and the second processor concatenating the remainders communicated by the first processor with the remainders of the second dataset, thereby generating a second ordered sequence of shares.

6. The computing system architecture of claim 1, wherein the step of shuffling the ordered shares includes: the first processor generates a random first permutation π.sub.1 and a random vector r.sub.1; the second processor generates a random second permutation π.sub.2 and a random vector r.sub.2; the second processor communicates π.sub.2 and r.sub.2 to S; the second processor communicates to the first processor an algebraic sum of the random number associated with y=x and −r.sub.2; and the first processor communicates to S π1 and the algebraic sum of z=y−r.sub.1, thereby generating shuffled share.

7. The computing system architecture of claim 1, wherein the step of re-splitting shuffled shares includes: the first processor and the second processor generate a common random third permutation π.sub.3; S generates a random vector r and calculates an algebraic sum of p=z−r; S communicates to A the second permutation of first permutation of p (π2(π1(p)); S calculates an algebraic sum of t=r.sub.2+r; S communicates to B the first permutation of π.sub.1(t); the first processor calculates an algebraic sum s=x′+r.sub.1; the first processor communicates to B the first permutation of π.sub.1(t); the second processor calculates an algebraic sum of q=π.sub.1(t)+π.sub.1(s)=π.sub.1(t+s)); the second processor applies the second permutation π.sub.2(q); the first processor applies the third permutation to the second permutation of p and outputs π.sub.3(π.sub.2(p)); and the second processor applies the third permutation to the second permutation of q and outputs π.sub.3(π.sub.2(q)).

8. The computing system architecture of claim 1, the ordered statistical operation is a sorting operation.

9. The computing system architecture of claim 8, the sorting is an oblivious sorting operation.

10. The computing system architecture of claim 1, where each of A and B can share mutually agreed results of the ordered statistical operation with one-another.

11. A method of performing ordered statistics between at least two parties while maintaining confidentiality of information of each of the at least two parties, comprising: identifying a first dataset (x.sub.A) by a first node (A); identifying a second dataset (x.sub.B) by a second node (B), wherein x.sub.B is unknown to A and x.sub.A is unknown to B, and wherein A is in communication with B, and wherein A and B are in communication with a server (S); A and B each: additively splitting each member of their respective datasets into corresponding shares; sharing the corresponding shares with one another; arranging the corresponding shares according to a mutually agreed predetermined order into corresponding ordered shares; shuffling the ordered shares into shuffled shares; re-splitting the shuffled shares into re-split shuffled shares; and performing an ordered statistical operation on the re-split shuffled shares, wherein the steps of shuffle and re-split is based on additions, subtractions but not multiplication and division.

12. The method of claim 11, wherein additive split of each member of the corresponding dataset includes: generating a random number associated therewith, and splitting each member of the corresponding dataset as an algebraic sum of the associated random number and an associated remainder.

13. The method of claim 11, wherein the step of sharing the corresponding shares with one another includes: A communicating the random number associated with each member of the corresponding dataset generated to B, and B communicating the remainder associated with each member of the corresponding dataset to A.

14. The method of claim 11, wherein the step of arranging the corresponding shares is according to a mutually agreed predetermined order includes concatenation.

15. The method of claim 14, wherein the concatenation includes: A concatenating remainders of the first dataset with the remainders communicated by B, thereby generating a first ordered sequence of shares, and the B concatenating the remainders communicated by A with the remainders of the second dataset, thereby generating a second ordered sequence of shares.

16. The method of claim 11, wherein the step of shuffling the ordered shares includes: A generating a random first permutation π.sub.1 and a random vector r.sub.1; B generating a random second permutation π.sub.2 and a random vector r.sub.2; B communicating π.sub.2 and r.sub.2 to S; B communicating to A an algebraic sum of the random number associated with y=x and −r.sub.2; and A communicating to S π1 and the algebraic sum of z=y−r.sub.1, thereby generating shuffled share.

17. The method of claim 11, wherein the step of re-splitting shuffled shares includes: A and B generating a common random third permutation as; S generating a random vector r and calculating an algebraic sum of p=z−r; S communicating to A the second permutation of first permutation of p (π2(π1(p)); S calculating an algebraic sum of t=r.sub.2+r; S communicating to B the first permutation of π.sub.1(t); A calculating an algebraic sum s=x′+r.sub.1; A communicating to B the first permutation of π.sub.1(t); B calculating an algebraic sum of q=π.sub.1(t)+π.sub.1(s)=π.sub.1(t+s)); B applying the second permutation π.sub.2(q); A applying the third permutation to the second permutation of p and outputting π.sub.3(π.sub.2(p)); and B applying the third permutation to the second permutation of q and outputting π.sub.3(π.sub.2(q)).

18. The method of claim 11, the ordered statistical operation is a sorting operation.

19. The method of claim 18, the sorting is an oblivious sorting operation.

20. The method of claim 11, where each of A and B can share mutually agreed results of the ordered statistical operation with one-another.

Description

BRIEF DESCRIPTION OF DRAWINGS

(1) FIG. 1 is a schematic of a connectivity of the system architecture between at least two parties and a server and the data exchanged therebetween.

(2) FIG. 2 is a schematic of a connectivity of the system architecture between the at least two parties and the server of FIG. 1, and the data exchanged therebetween

DETAILED DESCRIPTION

(3) For the purposes of promoting an understanding of the principles of the present disclosure, reference will now be made to the embodiments illustrated in the drawings, and specific language will be used to describe the same. It will nevertheless be understood that no limitation of the scope of this disclosure is thereby intended.

(4) In the present disclosure, the term “about” can allow for a degree of variability in a value or range, for example, within 10%, within 5%, or within 1% of a stated value or of a stated limit of a range.

(5) In the present disclosure, the term “substantially” can allow for a degree of variability in a value or range, for example, within 90%, within 95%, or within 99% of a stated value or of a stated limit of a range.

(6) A novel approach to allow secure multi-party data exchange and encryption is presented where partial data can be exchanged by different users in order to perform mathematical operations without any user or 3.sup.rd party knowing other user's data. The novel approach of the present disclosure utilizes an additive splits technique along with a data shuffle technique which enables two or more collaborators to shuffle a list of additively split items and simultaneously re-split the items. This novel approach of the present disclosure uses a single server (henceforth denoted by S) to help perform the aforementioned steps. The S learns nothing about the list of items held in additively split form by the two or more collaborators. This approach allows performing computations such as order statistics while preventing one collaborator from learning the inputs of the other collaborator or for S to learn to the data.

(7) For simplicity, while imposing no such limitation, assume there are two collaborators Alice (whose computing device is denoted by A) and Bob (whose computing device is denoted by B), who have confidential data x.sub.A and x.sub.B, respectively. The format of confidential data is a set of integers. That is x.sub.A represents one set of integers owned by Alice and x.sub.B represents another set of integers owned by Bob. Alice knows of her own data, and known nothing of Bob's data; and similarly Bob knows of his own data, and known nothing of Alice's data. Computing devices of Alice and Bob, Devices A and B, respectively, additively split their respective confidential data using the protocol described in Table 1 and share the result with their counterpart using the protocol described in Table 2. Thereafter, Alice and Bob arrange their inputs using the protocol described in Table 3. The protocols described in Tables 1, 2 and 3 are prerequisites for the shuffle and re-split protocol which is presented next.

(8) The protocol requires random vectors to be generated by Alice and Bob, and the helper server S discussed later. Distribution functions F(⋅) generate vectors of random integers of required length for the given computation.

(9) TABLE-US-00001 TABLE 1 Additively split the inputs Input: Alice's input is data x.sub.A and distribution function F.sub.A.sup.1(•) and Bob's input is data x.sub.B and distribution function F.sub.B.sup.1(•). Output: Alice's output is (x′.sub.A, x″.sub.A) and Bob's output is (x′.sub.B, x″.sub.B). 1.1 A generates a random number r.sub.A from F.sub.A.sup.1(•). [rep- resents a distribution function] 1.2 A splits x.sub.A into x′.sub.A and x″.sub.A such that x.sub.A = x′.sub.A + x″.sub.A. For example, x′.sub.A = x.sub.A − r.sub.A and x″.sub.A = r.sub.A. 1.3 B generates a random number r.sub.B from F.sub.B.sup.1(•). 1.4 B splits x.sub.B into x′.sub.B and x″.sub.B such that x.sub.B = x′.sub.B + x″.sub.B. For example, x′.sub.B = x.sub.B − r.sub.B and x″.sub.B = r.sub.B.

(10) TABLE-US-00002 TABLE 2 Exchange additive shares with the counterpart Input: A's input is x″.sub.Aand B's input is x′.sub.B. Output: A's output is x′.sub.B and B's output is x″.sub.A. 2.1 A .fwdarw. B: x″.sub.A. [this notation means: A sends, to B, x″.sub.A] 2.2 B .fwdarw. A: x′.sub.B

(11) TABLE-US-00003 TABLE 3 Arrangement of the additive shares Input: A's input is x′.sub.A, x′.sub.B and B's input is x″.sub.A, x″.sub.B. Output: A's output is (x′) and B's output is (x″). 3.1 A arranges the shares received (x′.sub.A, x′.sub.B) in a mutu- ally agreed order (x′). For instance, x′ = x′.sub.A∥x′.sub.B where ∥ denotes concatenation 3.2 Similarly, B obtains (x″) using the same mutually agreed order. x′.sub.A is the algebraic difference between x.sub.A and the random number, and x″.sub.A is the random number generated.

(12) Similarly, suppose Bob's set of number is x.sub.B={13,17,5}. For each number of the set, a random number generator with a distribution function F.sub.B.sup.1(⋅) is used to generate a random number. Suppose the random numbers generated are r.sub.B={9 ,4 ,8}. Next Bob splits each number in the original set based on the random numbers into shares, x.sub.B={4+9, 13+4, −3+8}. The split is based on algebraic relationship x.sub.B=x′.sub.B+x″.sub.B, where x.sub.B is the original number, x′.sub.B is the algebraic difference between x.sub.A and the random number, and x″.sub.B is the random number generated.

(13) In both cases, x′.sub.A, x″.sub.A, x′.sub.B, and x″.sub.B are additive shares for the original number x.sub.A and x.sub.B, respectively.

(14) Next, according to Table 2 Alice and Bob share their additive shares with each other. According to one embodiment, while Alice shares x″.sub.A, Bob shares x′.sub.B. As a result, based on the example provided, Alice's output (A.sub.o) and Bob's input (B.sub.i) is {12,1,2} for the original set of x.sub.A={17,8,6} and Bob's output (B.sub.o) and Alice's input (A.sub.i) is {4,13,−3} based on the original set of x.sub.B={13,17,5}.

(15) Next Alice and Bob arrange the shares each received. In case of Alice, x′=(4,13,−3) and in case of Bob, x″=(12,1,2). Both Alice and Bob rearrange their inputs according to a pre-agreed order (x′). It should be appreciated for this purpose x′.sub.A is considered an input for Alice as well as x′.sub.B. For instance, x′=x′.sub.A∥x′.sub.B, where ∥ denotes concatenation. In this case, x′.sub.A=(5,7,4) and x′.sub.B=(4,13,−3). Thus the rearranged inputs for A is x′=(5,7,4,4,13,−3). Similarly, for Bob's input, the inputs are x″.sub.A={12,1,2} and x″.sub.B={9,4,8}.Thus the rearranged input for B is x″=(12,1,2,9,4,8).

(16) Next the values obtained from Table 3 are shuffled. By the end of protocol described in Table 3, A and B have a list of items x′ and x″ respectively. The sum of these vectors equals x (=x′+x″); Alice only knows x′ (which looks random to her), and Bob only knows x″ (which looks random to him), and the set of values in x is the union of the set of values in x.sub.A and those in x.sub.B.

(17) If c is a vector and π is a permutation, the notation π(c) can be used to denote the vector obtained by shuffling the order of the entries of y according to permutation π. For simplicity of notation, π operates on n items where n is the length of the vector γ. Also, any random vector generated has same length as x, which is the length of x.sub.A plus the length of x.sub.B (in the running example we are using, that length is 6, the sum of 3 and 3).

(18) The description of a protocol that enables A and B to securely shuffle and re-split (SRS) x is described in Table 4. This protocol is based on two rounds. In round 1, the helper server S receives the pre-processed data from A and B. At the end of round 2, A and B have the shuffled and re-split of the original list of shares (x=x′+x″). Parts of this SRS protocol are depicted in FIGS. 1 and 2 for better clarity.

(19) The notion of shuffling is based on permutation π. Suppose A's share at the end of Table 3 is being shuffled by π. The shuffle function it has the same length as the share of A out of Table 3 (which is the same length as x, in the above example length is 6). A's share out of Table 3 is (5,7,4,4,13,−3). Suppose π is (4,2,1,5,3,6). Applying π to A's output of Table 3 results in a reshuffle of A's share as: (4,7,13,5,4,−3), i.e., the position of the members of the vector is changed based on the values of π. Table 4 provides for reshuffling based on π.sub.1, π.sub.2, and π.sub.3.

(20) The SRS process shown in Table 4 is now discussed. Table 4 is divided into two parts: Round 1 and Round 2. In Round 1, the list of input shares (x′,x″) is pre-processed. In Round 1, Alice (A) generates a random permutation π.sub.1 from a distribution function F.sub.A.sup.2(⋅) and a random vector r.sub.1 from a distribution function F.sub.A.sup.3(⋅). Similarly, Bob (B) generates a random permutation π.sub.2 from a distribution function F.sub.B.sup.2(⋅) and a random vector r.sub.2 from a distribution function F.sub.B.sup.3(⋅). Therefore, there are now two permutation functions π.sub.1 (owned by A) and π.sub.2 (owned by B), and two random vectors r.sub.1 (owned by A) and r.sub.2 (owned by B). Next B sends to the server S its π.sub.2 and r.sub.2. In addition, B sends to A vector y, where y=x″−r.sub.2. In addition, A sends to the server S π.sub.1 and z, where z=y−r.sub.1, which is x″r.sub.2−r.sub.1.

(21) Next Round 2 is discussed. A and B generate a permutation function π.sub.3 from a distribution function F.sub.AB(⋅). The server S generates a random number r from a distribution function F.sub.s (⋅). At this point, the server S has knowledge of π.sub.2, π.sub.1, r.sub.2, and z and the newly generated r. S then generates p, where p=z−r. S then applies the permutation function π.sub.1 to p and then applies the permutation function π.sub.2 to the resultant (i.e., π.sub.2(π.sub.1(z-r))). The latter is sent to A.

(22) Additionally, S generates t, where t=r.sub.2+r. S then applies the permutation function π.sub.1 to t (i.e., π.sub.1(t), where t=r.sub.2+r). S then sends the later to B. In turn A sends to B π.sub.1(s), where s'x′+r.sub.1. At this point, B possesses π.sub.1(t) and π.sub.1(s). B then generates q, where q=π.sub.1(t+s). B then applies π.sub.2 to q, obtaining π.sub.2(q).

(23) Now A applies permutation function π.sub.3 and π.sub.2 to her share generating a, where a=π.sub.3(π.sub.2(p)). In other words, a=π.sub.3(π.sub.2(π.sub.1)(x″−r.sub.1−r.sub.2−r))). Similarly, B applies permutation function π.sub.3 and π.sub.2 to his share generating b, where b=π.sub.3(π.sub.2(q)). In other words, b=π.sub.3(π.sub.2(π.sub.1(x′+r.sub.1+R.sub.2+r))).

(24) One concern about this multi-party data exchange is correctness of the data being exchanged in the SRS approach. The vector to be shuffled and re-split is x′+x″. At the end of stage 2, A's share is π.sub.3(π.sub.2(π.sub.1(x″−r.sub.1−r.sub.2−r))), B's share is π.sub.3(π.sub.2(π.sub.1(x′+r.sub.1+r.sub.2+r))). In other words, A and B have additive shares of π.sub.3(π.sub.2(π.sub.1(x′+x″))). The shuffling was therefore done according to permutation π such that π(x)=π.sub.3(π.sub.2(π.sub.1(x))). Note that none of the participants learns anything about π or about the re-splitting.

(25) Another concern is security of the data being exchanged. S knows the following information during the protocol: π.sub.1, π.sub.2, r, r.sub.2, and x″−r.sub.2−r.sub.1. However, it cannot learn anything about the permutation it or the secret x without knowledge of π.sub.3, r.sub.1, and x′. A knows the following information: π.sub.1x′, r1, x″−r.sub.2, π.sub.2(π.sub.1(x″−r.sub.2−r.sub.1−r)), and π.sub.3. She cannot learn anything about the permutation (π) or the secret x without knowledge of r.sub.2, r, and π.sub.2. Similarly, B cannot learn anything about the permutation π or the secret x without knowledge of r, r.sub.1, and π.sub.1.

(26) TABLE-US-00004 TABLE 4 Shuffle and Re-Split (SRS) protocol Input: A's input is data x′ and distribution functions F.sub.A.sup.2(•), F.sub.A.sup.3(•); B's input is data x″ and distribution functions F.sub.B.sup.2(•), F.sub.B.sup.3(•). A and B have a mutu- ally agreed random distribution function F.sub.A, B(•). Server S's input is distribution function F.sub.S(•) Output: A's output is a and B's output is b. Round 1: Pre-processing of the input shares (x′, x″) 4.1.1 A generates a random permutation π.sub.1 from F.sub.A.sup.2(•) and a random vector r.sub.1 from F.sub.A.sup.3(•) 4.1.2 B generates a random permutation π.sub.2 from F.sub.B.sup.2(•) and a random vector r.sub.2 from F.sub.B.sup.3(•) 4.1.3 B .fwdarw. S : π.sub.2, r.sub.2. 4.1.4 B .fwdarw. A : y. Where y = x″ − r.sub.2 4.1.5 A .fwdarw. S : π.sub.1, z. Where z = x″ − r.sub.2 − r.sub.1 Round 2: Determine the shuffled and re-split ver- sion of the input shares (x′, x″) 4.2.1 A and B generate a permutation π.sub.3 from F.sub.AB(•) 4.2.2 S generates r from F.sub.S(•) and adds −r to z to obtain p = z − r. 4.2.3 S .fwdarw. A : π.sub.2(π.sub.1(z − r)). 4.2.4 S .fwdarw. B : π.sub.1(t), where t = r.sub.2 + r. 4.2.5 A .fwdarw. B : π.sub.1(s), where s = x′ + r.sub.1. 4.2.6 B adds π.sub.1(t) to π.sub.1(s), obtaining q = π.sub.1(t + s). 4.2.7 B applies π.sub.2 to q, obtaining π.sub.2(q). 4.2.8 A permutes her share received in step (4.2.3), a = π.sub.3(π.sub.2(q)) = π.sub.3(π.sub.2(π.sub.1(x″ − r.sub.1− r.sub.2 − r))). 4.2.9 B also permutes his share computed in step (4.2.7), b = π.sub.3(π.sub.2(π.sub.1(x′ + r.sub.1 + r.sub.2 + r))).

(27) The SRS protocol of the present disclosure is composable and can be integrated with existing shared computing environments such as Sharemind and SAPAS protocols, known to a person having ordinary skill in the art. Such integration can help users efficiently perform sorting and other statistical operations securely.

(28) The existing methods of the prior art use encryption to prevent the leakage of confidential information, and the computations over such confidential information are performed over the encrypted data. In the approach of the present disclosure, these computations are performed using an entirely different method. In these protocols, a single server is utilized to perform the required computations without informing the server of the data owned by A or B. With the present approach, A and B are both able to calculate order statistics such as maximum and minimum, average, and a host of other statistical parameters without either of them knowing the other's data.

(29) The quicksort algorithm, known to a person having ordinary skill in the art, is one of the commonly used algorithms for sorting an array of elements. This algorithm initiates with the selection of a pivot element to sort the array. Oblivious sorting using quicksort requires hiding the pivot element (value and its index) from Alice, Bob and Server. Such hiding makes this algorithm computationally expensive. Application of the SRS protocol overcomes the need to hide the index and thereby reduces the computational load of oblivious sorting using quicksort. In Table 5, the SRS protocol is compared with other protocols known in the prior art. Protocol in Table 6 shows how SRS protocol can be used in Quicksortbased oblivious sorting.

(30) TABLE-US-00005 TABLE 5 Complexity of secure shuffle protocols for a 3-party system Protocol Comm. Complexity Rounds Blind and Permute [10] O(n.sup.3)  1 Oblivious Protocol 1 [11]  .sup. O(nlogn) 8 Oblivious Protocol 2 [11] O(3n.sup.2) 3 Oblivious Protocol 3 [11] O(3n.sup.3) O(log(3)) SRS Protocol 6n 2

(31) TABLE-US-00006 TABLE 6 Oblivious Sorting Input: A's input is x.sub.A and B's input is x.sub.B. Output: A's output is (x′) and B's output is (x″). 5.1 A's input is x.sub.A and B's input is x.sub.B. A and B run the protocol in Table 1 to obtain (x′.sub.A, x″.sub.A) and (x′.sub.B, x″.sub.B) respectively 5.2 A's input is x″.sub.A and B's input is x′.sub.B. A and B run the protocol in Table 2 to obtain (x′.sub.B) and (x″.sub.A) re- spectively 5.3 A uses x′.sub.A, x′.sub.B and B uses x″.sub.A, x″.sub.B to run the protocol in Table 3 to obtain (x′) and (x″) respectively 5.4 A uses x′ and B uses x″ to run the protocol in Ta- ble 4 and obtain (a) and (b) respectively 5.5 A's input is a and B's input is b and they jointly run the steps in Quicksort algorithm [12] securely

(32) Oblivious sorting enables Alice and Bob to search elements including maximum, minimum, mode, and median without needing to reveal their individual confidential data to anyone. In addition, oblivious sorting in multi-dimensions allows Alice and Bob to determine dominant solutions. In matrix factorization, oblivious sorting helps Alice and Bob to find the order of singular values, eigen values. Such computations in an oblivious manner allows Alice and Bob to reduce from high dimensional data to low dimensions.

(33) To continue from the previous examples provided above, suppose prior to using quicksort, Alice's share of the input to the quicksort (i.e., out of Table 4) could possibly be the vector (8,3,−2,7,9,−4) and Bob's the vector (9,2,15,−1,8,12); note that the sum of these vectors is the vector (17,5,13,6,17,8) whose set of contents is, as required, the union of {17,8,6} and {13,17,5}, i.e., Alice's set of numbers was {17,8,6} and Bob's was {13,17,5}. To Alice and Bob their respective vectors look random, therefore during the quicksort it is harmless if they both know the index of the pivot elements, and also know the outcomes of individual comparisons. In other words, that knowledge tells Alice (respectively, Bob) nothing if she (he) learns that the third element, for which her (his) share is −2 (15), is greater than the fourth element, for which her (his) share is 7 (−1). This is the benefit of doing the shuffle and resplit before the quicksort: It makes it unnecessary for quicksort to hide from Alice and Bob the pivot elements and the outcomes of pairwise comparisons (if quicksort had to hide these, it would be impractical). To continue with the running example we are using: If Alice's share of the input to the quicksort was (8,3,−2,7,9,−4) and Bob's was (9,2,15,−1,8,12), then the output of the quicksort would result in Alice's share being (3,7,−4,−2,8,9) and Bob's share being (2,−1,12,15,9,8) because the sum of these vectors is sorted: (3,7,−4,−2,8,9)+(2,−1,12,15,9,8)=(5,6,8,13,17,17).

(34) After the quicksort gives Alice and Bob their respective shares of (3,7,−4,−2,8,9) and (2,−1,12,15,9,8) of the sorted result, they can trivially compute any ordered statistic for the union of their sets of numbers: If for example Bob is supposed to learn the median (i.e., the third smallest element) then Alice would send Bob her share of the third element of the sorted result, which is −4, and Bob would add that −4 to its own share of 12 and learn that the third smallest element is 8.

(35) Those having ordinary skill in the art will recognize that numerous modifications can be made to the specific implementations described above. The implementations should not be limited to the particular limitations described. Other implementations may be possible.