Next Article in Journal
Study on the Microstructure, Mechanical Properties, and Corrosion Behavior of 900 °C-Annealed CoCrFeMnNiSix (X = 0, 0.3, 0.6, 0.9) High-Entropy Alloys
Next Article in Special Issue
Refraction of the Two-Photon Multimode Field via a Three-Level Atom
Previous Article in Journal
Global Traction Battery Cathode Material Industrial Chain Trade Analysis: A Multilayer Modeling Approach
Previous Article in Special Issue
New Quantum Private Comparison Using Four-Particle Cluster State
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Communication Complexity of Entanglement-Assisted Multi-Party Computation

by
Ruoyu Meng
* and
Aditya Ramamoorthy
Department of Electrical and Computer Engineering, Iowa State University, Ames, IA 50011, USA
*
Author to whom correspondence should be addressed.
Entropy 2024, 26(11), 896; https://doi.org/10.3390/e26110896
Submission received: 31 August 2024 / Revised: 17 October 2024 / Accepted: 19 October 2024 / Published: 23 October 2024
(This article belongs to the Special Issue Entropy, Quantum Information and Entanglement)

Abstract

:
We consider a quantum and a classical version of a multi-party function computation problem with n players, where players 2 , , n need to communicate appropriate information to player 1 so that a “generalized” inner product function with an appropriate promise can be calculated. In the quantum version of the protocol, the players have access to entangled qudits but the communication is still classical. The communication complexity of a given protocol is the total number of classical bits that need to be communicated. When n is prime, and for our chosen function, we exhibit a quantum protocol (with complexity ( n 1 ) ( log n ) bits) and a classical protocol (with complexity ( ( n 1 ) 2 ( log n 2 ) bits)). Furthermore, we present an integer linear programming formulation for determining a lower bound on the classical communication complexity. This demonstrates that our quantum protocol is strictly better than classical protocols.

1. Introduction

We consider a multi-party function computation scenario in this work. There are a total of n players in the system numbered 1 , 2 , , n . Each player observes her input and players 2 , , n (remote parties) communicate an appropriate number of bits that allows player 1 to finally compute the value of the function. Clearly, this can be accomplished if players 2 , , n communicate their actual values, but in many cases, the function value can be computed with much less information. Thus, a key question is to determine the minimum number of bits the remote parties need to send to player 1.
Such problems are broadly studied under the umbrella of communication complexity [1,2] in the literature. In this work, we consider the zero-error version of this problem. Our main goal is to understand the advantage that the availability of quantum entanglement confers on this problem and compare it with classical protocols. Such problems have a long history in the literature [3,4].
Background: There are three kinds of quantum protocols within quantum communication complexity (QCC) problems. In the first kind (introduced by Yao [2]), each player communicates via a quantum channel and the metric is the number of qubits transmitted. We call it the quantum transmission model. The second variation assumes that each player can use entanglement as a free resource, but the communication remains classical; the primary metric here is the number of classical bits transmitted. We refer to this as the entanglement model, which was introduced by Cleve and Buhrman [5]. The third kind is a combination of the first two. We call it the combined model. It allows free usage of entanglement and works with quantum communication. The work of de Wolf [6] shows that, in the two-party case, the entanglement model can be reduced to the quantum transmission model with a two-fold penalty, utilizing teleportation [7].
Buhrman, Cleve, Wigderson [8] and Cleve, van Dam, Nielsen, and Tapp [9] considered the case of the two-party function computation with quantum communication and used reduction techniques to connect problems in QCC to other known problems, and derived upper/lower bounds for QCC in this manner. In particular, the first work [8] showed examples, such as the set disjointness function, where quantum protocols are strictly better than classical ones in the bounded-error setting. Here, the set-disjointness problem is such that each player has a set and wants to decide if their intersection is empty. Buhrman and de Wolf [10] generalized the two-party "log-rank" lower bound of classical communication complexity to QCC where quantum protocols use both shared entanglement and quantum communication. For other two-party upper/lower bound techniques, see [11,12,13,14,15].
Related Work: We will now discuss works in multi-party quantum communication complexity. There are mainly two kinds of models. The number-in-hand (NIH) model assumes each player observes only one variable. The number-on-forehead (NOF) model assumes each player observes all but one variable. François and Shogo [16] considered the NIH model with quantum communication and provided a quantum protocol for a three-party triangle-finding problem; the formulation considers bounded error. This has a polynomial advantage with respect to any classical protocol. Here, the triangle-finding problem is such that the edge set of a graph is distributed over each user and the task is to find a triangle of the graph.
The results in the following two works apply to both NIH and NOF models. Lee, Schechtman, and Shraibman [17] proved a Grothendieck-type inequality and subsequently derived a general lower bound for the multi-party QCC for the Boolean function in Yao’s model. Following this work, Briet, Buhrman, Lee, and Vidick [18] showed a similar inequality for the multi-party XOR game and established that the discrepancy method provides lower bounds for QCC when the combined model is of the third type discussed earlier.
Buhrman, van Dam, Høyer, and Tapp [19] considered the NIH model with shared entanglement and proposed a three-party problem with a quantum protocol that is better than any classical protocol by a constant factor. Following this work, Xue, Li, Zhang, Guo [20], and Galv ao [21] showed similar results under the same function with more restrictions. The work most closely related to ours is by Cleve and Buhrman [5]. This study involved three players (Alice, Bob, and Carol) who each have m-bit strings, denoted as x , y , and z , respectively. The strings are such that x + y + z = 1 , meaning their binary sum (modulo-2) results in the all-ones vector. The goal is for Alice to compute the following:
g ( x , y , z ) = i = 1 m x i y i z i
using binary arithmetic. We note that the communication from Bob and Carol to Alice is purely classical; however, they can use entanglement in a judicious manner. For this particular function, ref. [5] shows that a classical protocol (without entanglement) requires three bits of communication, whereas if the parties share 3 m entangled qubits, then two bits of communication are sufficient.
Main Contributions: In this work, we consider a generalization of the original work of [5]. In particular, we consider a scenario with n players (for prime n) that observe values that lie in a higher-order finite field, with a more general promise that is satisfied by the observed values. As we consider more players and higher-order finite fields, the techniques used in the original work are not directly applicable in our setting. For instance, when n = 3 , our generalized inner product function is defined over F 3 arithmetic (modulo-3), whereas in the same setting, ref. [5] considers binary (modulo-2) arithmetic. Thus, even though we consider a similar problem, we highlight that the result of [5] cannot be recovered as a special case of our result.
Our work provides the following contributions:
  • We demonstrate a quantum protocol that allows for the function to be computed with ( n 1 ) log n bits. We use the quantum Fourier transform as a key ingredient in our method.
  • On the other hand, we demonstrate a classical protocol that requires the communication of ( n 1 ) 2 ( log n 2 ) bits.
  • To obtain a lower bound on the classical communication complexity, we define an appropriate integer linear programming problem that demonstrates that our quantum protocol is strictly better than any classical protocol.
This paper is organized as follows. Section 2 discusses the problem formulation and Section 3 discusses our quantum protocol. Section 4 and Section 5 discuss our classical protocol and the lower bound on any classical protocol, respectively.

2. Problem Formulation

2.1. Classical/Quantum Communication Scenarios

Let X i , i = 1 , , n and Y denote the sets in which the inputs and the output lie, and let f ( x 1 , , x n ) : X 1 × × X n Y be a multivariate function. There are n players, and the i-th player is given x i X i . The first player (henceforth, Alice) receives information from each of the players; this communication should allow her to compute f ( x 1 , , x n ) . The players are not allowed to communicate with each other.
In the classical protocol, players 2 to n communicate to Alice via classical channels. In the quantum protocol, we assume that the users have access to shared entanglement as a free resource; however, the communication remains classical. In both scenarios, the classical/quantum communication complexity is defined as the minimum number of classical bits transmitted such that Alice can compute the function among all classical/quantum protocols.

2.2. Generalized Inner Product Function with a Promise

In this work, we consider a specific multivariate function and the setting where n 3 (number of players) is prime. Let F n denote the finite field of order-n and [ m ] { 1 , , m } . The i-th player is given a vector x i = [ x 1 i x m i ] T F n m , i.e., each x j i F n . The vectors satisfy the following “promise”: j [ m ] , the j-th component of each player’s vector is such that we have the following:
[ x j 1 , , x j n ] T { a [ 1 , , 1 ] T + b [ 0 , , n 1 ] T | a , b F n } ,
i.e., [ x j 1 , , x j n ] T lies in a two-dimensional vector space spanned by the basis vectors [ 1 , , 1 ] T and [ 0 , 1 , , n 1 ] T . In this case, it can be observed that [ x j 1 , , x j n ] T is either a multiple of the all-ones vector (if b = 0 ) or a permutation of [ 0 , 1 , , n 1 ] (if b 0 ). The function to be computed is the generalized inner product function given by the following:
G I P ( x 1 , , x n ) = i = 1 m j = 1 n x i j ,
where the operations are over F n .
Remark 1.
In [5], the promise equivalently means that the j-th component of Alice, Bob, and Carol’s vector lies in a two-dimensional affine subspace over F 2 given by { a · v 1 + b · v 2 F 2 3 : a , b F 2 } + 1 . Thus, the promise introduced in our work can be considered as a natural higher-order generalization of their promise.

3. Proposed Quantum Protocol

We first discuss the entangled states and unitary transforms that will be used in the proposed quantum protocol in Section 3.1. In Section 3.2, we discuss the quantum protocol in detail, including a proof of its correctness. A word about notations: In the following, for complex vectors u , v , u , v = i u i v i denotes the usual inner product. On the other hand, if u , v F n m , then u , v = i = 1 m u i v i denotes the inner product over F n . Moreover, δ i j denotes the Kronecker delta function, which equals 1 if i = j and 0 otherwise. All logarithms in this paper are to base-2.

3.1. Entanglement Resource and Unitary Transforms Used

3.1.1. Shared Entangled States

Consider n isomorphic n-dimensional quantum systems, where each system has a computational basis denoted B = { | 0 , | 1 , , | n 1 } . There are m entangled states shared among n players. For i [ m ] , we prepare the entangled state as follows:
| Φ i : = 1 n k = 0 n 1 | k k .
The j-th subsystem of this entangled state is given to j-th player for j = 1 , , n .

3.1.2. Quantum Fourier Transform

Let ω : = e 2 π i n denote the n-th root of unity. The quantum Fourier transform (QFT) is defined by the following unitary map:
| j 1 n k = 0 n 1 ω j k | k , | j B .
Let Q F T l denote the QFT performed over l isomorphic systems.

3.1.3. Phase Shift Map

For j F n , we define the following:
P 0 | 0 ω n 1 2 | 0 | i | i , i 0 .
If j 0 , P j | i ω 1 n ( i j mod n ) | i .

3.2. The Quantum Protocol

Next, we introduce the quantum protocol that uses ( n 1 ) ( log n ) bits.
Theorem 1.
There exists a quantum protocol for computing G I P ( x 1 , , x n ) , which uses ( n 1 ) log n bits.
In our protocol (see Algorithm 1), for each i = 1 , , m , each player p examines x i p and applies the corresponding phase shift map to her subsystem of | Φ i . Following this, she applies the QFT on each of her symbols and then measures in the computational basis; this yields s i p F n for i = 1 , , m . Player p then transmits i = 1 m s i p . As the players 2 p n transmit a symbol from F n , it is clear that the total communication in the protocol is ( n 1 ) ( log n ) .
Algorithm 1: Proposed quantum protocol.
  • For i { 1 , , m } , prepare maximally entangled “shared state” | Φ i (cf. (2)) and distribute corresponding subsystems to all players.
  • for player p { 1 , n }  do
  •     for each i { 1 , , m }  do
  •         Assume x i p = j , then player p applies P j (cf. (4)) on her part of | Φ i .
  •         Player p performs Q F T on her part of the shared state.
  •         Player p measures her part of the shared state in the computational basis, yielding s i p F n
  •     end for
  •      s p i = 1 m s i p
  •     Player p sends s p to Alice if p 1
  • end for
  • G I P ( x 1 , , x n ) = p s p .
To show the proof of correctness of the protocol, we need the following auxiliary lemma. The proof appears in Appendix A:
Lemma 1.
Let α = [ 1 , , 1 ] T F n n . Then, for each x F n , we have the following:
Q F T n 1 n j = 0 n 1 ω j x | j · α = 1 n n 2 k { 0 , , n 1 } n a k | k .
Then the amplitude a k 0 iff j = 1 n k j = x where k = [ k 1 , , k n ] T .
The proof of correctness of the protocol hinges on the following lemma:
Lemma 2.
p = 1 n s i p = p = 1 n x i p , for i = 1 , , m .
Proof. 
The state jointly measured by each player is as follows:
Q F T n j = 0 n 1 p = 1 n P x i p 1 n | j · α ,
where α = [ 1 , , 1 ] T . If [ x i 1 , , x i n ] T = [ j , , j ] T , then we have the following (see Appendix B for derivation):
P j n 1 n k = 0 n 1 | k · α 1 n k = 0 n 1 ω k j | k · α .
Thus, Q F T n 1 n k = 0 n 1 ω k j | k · α has non-zero coefficients only for states | k such that l = 1 n k l = j by Lemma 1. Therefore, the measurement result [ s i 1 , , s i n ] T must be one of k = [ k 1 , , k n ] T s.t.
l = 1 n k l = j = ( a ) j n = p = 1 n x i p
where ( a ) follows from the fact that j F n .
Now, we assume the following: [ x j 1 , , x j n ] T = a [ 1 , , 1 ] T + b [ 0 , 1 , , n 1 ] T with b 0 . This implies that a + b · i F n is distinct for each i { 0 , , n } . It can be observed that a [ 1 , , 1 ] + b [ 0 , , n 1 ] is a permutation of [ 0 , , n 1 ] , so it suffices to discuss [ x i 1 , , x i p ] T = [ 0 , , n 1 ] T by symmetry. We have the following (see Appendix B for derivation):
P 0 P n 1 1 n k = 0 n 1 | k · α 1 n ω n 1 2 k = 0 n 1 | k · α
We have the following:
Q F T n 1 n ω n 1 2 k = 0 n 1 | k · α = ω n 1 2 Q F T n 1 n k = 0 n 1 | k · α = 1 n n 2 ω n 1 2 k F n n a k | k .
By Lemma 1, a k 0 iff l = 1 n k l = 0 . Therefore, the measurement result [ s i 1 , , s i n ] T must be k = [ k 1 , , k n ] T such that
l = 1 n k l = 0 = j = 0 n 1 j = p = 1 n x i p .
   □
Now, we show that our protocol computes G I P ( x 1 , , x n ) correctly. Since s p = i s i p , by applying (6), we have the following:
p s p = p i s i p = i p s i p = i p = 1 n x i p = G I P ( x 1 , , x n ) .

4. Proposed Classical Protocol

We now consider purely classical protocols for our problem, i.e., ones that do not consider entanglement. At the top level, our classical scheme operates by communicating the “number” of different symbols that exist within each player’s vector. We show that this suffices for Alice to recover the function value.
More precisely, let β k p be the number of “k” values in the vector of p-th player; recall that player p is assigned x p = x 1 p x m p . Note that k = 0 n 1 β k p = m .
Theorem 2.
There exists a classical protocol for computing G I P ( x 1 , , x n ) that uses ( n 1 ) 2 ( log n 2 ) bits.
In our protocol (see Algorithm 2), for each i = 1 , , n 1 , each player p transmits β k p ( mod n 2 ) . Alice computes each β 0 p ( mod n 2 ) by using the fact that k = 0 n 1 β k p = m . Finally, Alice computes the value of the function by using { β k p ( mod n 2 ) | k F n , p [ n ] } For each player p { 2 , , n } , p transmits { β 1 p ( mod n 2 ) , , β n 1 p ( mod n 2 ) } . The total number of bits transmitted is ( n 1 ) 2 ( log n 2 ) . The proof of the Theorem 2 appears in Appendix C.
Algorithm 2: Proposed Classical protocol.
  • for player p { 1 , n }  do
  •     for each k F n  do
  •          β k p number of “k” values in x 1 p x m p
  •         if p is not Alice and k 0  then
  •            p sends β k p ( mod n 2 ) to Alice
  •         end if
  •     end for
  • end for
  • for  p { 2 , n }  do
  •     Alice computes β 0 p ( mod n 2 ) by using
         k = 0 n 1 β k p = m .
  • end for
  • W p = 1 n k = 1 n 1 k · β k p + n 2 n 2 ( n 1 ) p = 1 n β 0 p ( mod n 2 )
  • G I P ( x 1 , , x n ) = W / n

5. Classical Communication Complexity Lower Bound

We now discuss a lower bound on the communication complexity of any classical protocol that demonstrates a strict separation between our proposed quantum protocol and any classical protocol. Analytically, this seems to be a rather hard problem, and we discuss it as an item for future work. We can show, however, the strict separation numerically using ILPs (see Section 5.1 below). In addition, we present an analytical argument below that demonstrates that for n = 3 , the communication complexity of any classical protocol is at least 2 log 2 3 .
We assume that Alice, Bob, and Carol are given vectors x 1 , x 2 , and x 3 , respectively, each of length m. The promise (cf. Section 2.2) is equivalent to the following:
x j 1 + x j 2 + x j 3 = 0 , for j = 1 , , m .
This implies that the GIP function in this case can be computed if we know any two out of x 1 , x 2 , and x 3 . We assume that Carol labels her sequences ( x 3 { 0 , 1 , 2 } m ) with one of—at most—three possible labels. We denote this label by a mapping β : { 0 , 1 , 2 } m { 0 , 1 , 2 } . Recall that Alice knows her sequence x 1 .
Definition 1.
We define Bob’s confusion graph G B = ( V B , E B ) as follows. The vertex set V B corresponds to the 3 m sequences x 2 { 0 , 1 , 2 } m . The i-th such sequence is denoted by x 2 [ i ] for i = 0 , , 3 m 1 , with similar notations applied to the sequences for Alice and Carol.
There exists an edge ( x 2 [ i ] , x 2 [ j ] ) E B , for i j if there exists an Alice sequence x 1 [ ] and Carol sequences x 3 [ a ] and x 3 [ b ] , such that (i) β ( x 3 [ a ] ) = β ( x 3 [ b ] ) (note that we allow a = b ), and (ii) G I P ( x 1 [ ] , x 2 [ i ] , x 3 [ a ] ) G I P ( x 1 [ ] , x 2 [ j ] , x 3 [ b ] ) .
Note that if ( x 2 [ i ] , x 2 [ j ] ) E B , Bob must assign different labels to x 2 [ i ] and x 2 [ j ] ; otherwise, Alice has no way to compute the function with zero error. The concept of the confusion graph dates back to the work of Shannon [22].
The main concept of the argument below is to show that there exists a triangle in G B . This implies that Bob needs to use at least three labels for Alice to decode with zero error.
Since Carol uses, at most, three labels, the pigeon-hole principle dictates that there must be at least 3 m 1 sequences that share the same Carol label. Let us denote this set by C .
Claim 1.
There is a subset of two coordinates where all nine patterns  { 0 , 1 , 2 } 2  appear within the sequences in  C .
Proof. 
Suppose that m is even. Then, we can partition the coordinates as { 1 , 2 } , { 3 , 4 } , , { m 1 , m } . Let us arrange the sequences in C as rows; the number of rows is | C | 3 m 1 . Now, suppose that the projection onto any pair of coordinates has, at most, 8 representatives, then, the size of C can be, at most, 8 m / 2 . Now, we have the following:
3 m 1 8 m / 2 = 1 3 × 9 8 m / 2 > 1 ,
for large enough m. □
Without loss of generality, we assume that all nine patterns occur within the first two coordinates of C . We pick nine of such representatives from C and denote them as z 00 , z 01 , z 02 , z 10 , , z 22 ; the subscripts correspond to the values on the first two coordinates.
Let us pick Alice’s sequence x 1 [ ] = [ 110 0 ] . Corresponding to this x 1 [ ] , for the Carol sequences z 00 , , z 22 , using the given promise, we can determine the corresponding Bob sequences y 00 , , y 22 . We note the following:
y 00 = [ 22 z 00 ( 3 : m ) ] , y 01 = [ 21 z 01 ( 3 : m ) ] , and y 11 = [ 11 z 11 ( 3 : m ) ] .
where z 00 ( 3 : m ) denotes the components of vector z 00 from index 3 onward (basically the MATLAB notation).
Claim 2.
In Bob’s confusion graph,  G B , the sequences  y 00 , y 01 ,  and  y 11  form a triangle.
Proof. 
We need to examine G I P ( x 1 [ ] , y i , z i ) for i = 00 , 01 , 11 . Since only the first two coordinates matter, given x 1 [ ] = [ 110 0 ] , the corresponding evaluations are 0 , 1 , 2 , which are pairwise different. □
This argument shows that Bob must use at least three labels for Alice to decode with zero error. By symmetry, Carol must also use three labels. To summarize, the communication complexity of any classical protocol is at least 2 log 3 bits.
Remark 2.
It may be possible to use a variant of the above combinatorial argument to establish that the chromatic number of G B is strictly larger than three. However, this does not seem to follow in a straightforward manner.

5.1. ILP Feasibility Problem for Classical Lower Bound

We now present a lower bound on the communication complexity of any deterministic classical protocol for our problem. To this end, we frame this as an integer linear programming problem (ILP) that can be solved numerically. The primary aim of the ILP is to establish a correspondence between each deterministic classical protocol and a feasible point within the ILP. Therefore, the feasibility of the ILP, which can be numerically verified, implies the existence of a deterministic classical protocol and vice versa (this correspondence between the ILP and classical protocols is valid only for the deterministic case. The ILP does not account for randomized protocols where players may have access to public and/or private randomness).
Suppose, for p { 2 , , n } , the p-th player sends symbols (labels) in [ l p ] : = { 1 , 2 , , l p } for some large enough positive integer l p . Let c [ l p ] and define I x p , c { 0 , 1 } to be the indicator that the p-th player sends c when it has the vector x p F n m . As this mapping is unique, we have c [ l p ] I x p , c = 1 . Furthermore, for a given set of vectors x p for p { 2 , , n } , if the p-th player sends label c p , we have p = 2 n I x p , c p = 1 .
Consider two sets of vectors { x p F n m | p { 1 , , n } } , { z p F n m | p { 1 , , n } } . We denote the following:
( x 1 , , x n ) G I P ( z 1 , , z n )
if the following conditions are satisfied.
  • Both ( x 1 , , x n ) and ( z 1 , , z n ) satisfy the promise (cf. Section 2.2).
  • x 1 = z 1 .
  • G I P ( x 1 , , x n ) G I P ( z 1 , , z n ) .
This definition applies to distinct inputs with the “same” Alice vector, but different function evaluations. It can be seen that—for two such distinct inputs—the symbols communicated by players 2 to n have to be distinct, otherwise, Alice has no way to decode in a zero-error fashion.
Our proposed ILP works with fixed l p ’s and a fixed value of m. Due to complexity reasons, m cannot be very large. However, if the ILP is infeasible for a given l p and a m ˜ , then our lower bound holds for arbitrary values m m ˜ . Our lower bound would continue to hold even if Alice was provided the values x m ˜ + 1 p , , x m p for all players p = 2 , , n .
Consider the following 0 1 integer programming feasibility problemL
min 0 s . t . p { 2 , , n } , c [ l p ] , x p F n m , I x p , c { 0 , 1 } , c [ l p ] I x p , c = 1 , x p , c 2 [ l 2 ] , , c n [ l n ] | p = 2 n I x p , c p p = 2 n I z p , c p | = 2 for all ( x 1 , , x n ) G I P ( z 1 , , z n ) .
The infeasibility of the above integer programming problem corresponds to a lower bound on the classical communication complexity. The proof of the following theorem appears in Appendix D.
Theorem 3.
There exists a deterministic classical protocol computing G I P ( · ) where each player sends—at most— l p different labels for p { 2 , , n } iff the above integer programming is feasible.
Remark 3.
The above integer program contains constraints that involve the product of variables and equality constraints with sums of absolute values. We show how these constraints can be linearized in Appendix E. The entire code for our ILP is available in this online repository [23].

5.2. Numerical Experiments

In our numerical experiments, we considered an instance of the ILP involving n = 3 players, namely Alice, Bob, and Carol. Let m represent the length of each vector, while [ l b ] , [ l c ] denote the sets of labels used by Bob and Carol, with l b , l c denoting the sizes of these sets.
We assume that Alice, Bob, and Carol are given vectors x 1 , x 2 , and x 3 , respectively, each of length m. In this case, the promise is given by the following: (9). It can be observed that swapping the vectors of Bob and Carol still satisfies the promise. Due to this inherent symmetry, a protocol with communication lengths l b = x and l c = y exhibits the same feasibility as one with l b = y and l c = x . Consequently, for the ILP we can assume that l b l c .
The experimental results under varying settings of l b , l c , m are displayed in Table 1. For instance, it shows that when l b = 1 and l c = 17 , the ILP is infeasible with m = 3 . This implies that for a feasible classical protocol, with l b = 1 , we need at least log ( 18 ) bits to be transmitted from Carol. Similarly, the triplets ( m , l b , l c ) = ( 2 , 2 , 4 ) and ( 3 , 3 , 3 ) are infeasible. This implies that when l b equals 2 or 3, the sum rate is min ( log 2 + log 5 , log 3 + log 4 ) .
Recalling that our proposed protocol employs 2 log ( 3 ) bits of communication, and by the fact that
2 log 3 < min ( log 18 , log 3 + log 4 , log 2 + log 5 )
we conclude that there is a strict separation between our quantum protocol and any classical protocol. We note here that we have expressed the communication complexity of both protocols in terms of bits by converting to base-2 logarithms. However, it is important to interpret the results, e.g., the quantum protocol is feasible if Bob and Carol use ternary communication (one of three possible symbols). Conversely, the classical protocol requires that at least one of Bob or Carol transmit one of four possible symbols. In this sense, the quantum protocol is strictly better.

6. Conclusions

We considered the communication complexity problem of the GIP function under a specific promise. We proposed a quantum protocol utilizing ( n 1 ) log ( n ) bits and a classical protocol employing ( n 1 ) 2 ( log n 2 ) bits. By establishing a connection between the integer linear programming feasibility problem and the existence of a classical protocol with a particular communication complexity, we were able to provide numerical evidence supporting the quantum advantage in our model’s communication complexity. The main limitation of our work is the absence of an analytical lower bound on the classical communication complexity of our problem.
It would be interesting to analytically investigate the quantum advantage in the asymptotic limit as n increases, and to consider promises where the quantum advantage can be analytically demonstrated, or other problems that also encompass the work in [5] as a special case.

Author Contributions

Conceptualization, R.M. and A.R.; Methodology, R.M. and A.R.; Writing—review & editing, R.M. and A.R. All authors have read and agreed to the published version of the manuscript.

Funding

The material in this work was supported in part by NSF grants CIF-1910840 and CIF-2115200.

Institutional Review Board Statement

Not applicable.

Data Availability Statement

There is no significant data associated with the study. The corresponding author can be contacted if needed.

Conflicts of Interest

The authors declare no conflict of interest.

Appendix A. Proof of Lemma 1

Recall that
α = [ 1 , , 1 ] T .
The action of QFT n on 1 n j = 0 n 1 ω x j | j · α is
1 n n 2 k F n n a k | k = Q F T n 1 n j = 0 n 1 ω x j | j · α = 1 n n 2 k F n n 1 n j = 0 n 1 ω x j · ω k , j · α | k .
Write k = [ k 1 , , k n ] T . Therefore,
a k = 1 n j = 0 n 1 ω x j · ω k , j · α = 1 n j = 0 n 1 ω x j + j l = 1 n k l .
When k satisfies l = 1 n k l = x , we have that a k = n 0 . Otherwise, since x + l = 1 n k l 0 and n are prime, 1 ω n ( x + l = 1 n k l ) = 0 and 1 ω x + l = 1 n k l 0 . We have the following:
1 n j = 0 n 1 ω x j + j l = 1 n k l = 1 n j = 0 n 1 ω ( x + l = 1 n k l ) j = 1 n 1 ω n ( x + l = 1 n k l ) 1 ω x + l = 1 n k l = 0 .

Appendix B. Derivation of Equations (7) and (8)

We derive Equation (7) by considering two cases. The first case occurs when [ x i 1 , , x i n ] T = [ 0 , , 0 ] T . Then, we have the following:
P 0 n 1 n k = 0 n 1 | k · α 1 n ω n ( n 1 ) 2 | 0 · α + 1 n k = 1 n 1 | k · α = 1 n k = 0 n 1 | k · α = 1 n k = 0 n 1 ω k · 0 | k · α .
The second case occurs when [ x i 1 , , x i n ] T = [ j , , j ] T with j 0 . Then, we have the following:
P j n 1 n k = 0 n 1 | k · α 1 n k = 0 n 1 ω n ( 1 n ( k j mod n ) ) | k · α = 1 n k = 0 n 1 ω k j | k · α
where the last equality holds since ω k j = ω ( k j mod n ) . Thus, in this case, collectively, we can express the joint state after phase-shifting as 1 n k = 0 n 1 ω k j | k · α .
Now, we derive Equation (8). We have the following:
P 0 P n 1 1 n k = 0 n 1 | k · α 1 n ω n 1 2 | 0 · α + 1 n k = 1 n 1 ω j = 0 n 1 1 n ( k j mod n ) | k · α = ( a ) 1 n ω n 1 2 | 0 · α + 1 n k = 1 n 1 ω 1 n ( j = 0 n 1 j ) | k · α = 1 n ω n 1 2 | 0 · α + 1 n k = 1 n 1 ω 1 n [ n ( n 1 ) 2 ] | k · α = 1 n ω n 1 2 k = 0 n 1 | k · α
where ( a ) follows from the fact that { k j mod n | j { 0 , , n 1 } } = { 0 , , n 1 } for k 0 (we emphasize that this statement only holds if n is prime). We have the following;
Q F T n 1 n ω n 1 2 k = 0 n 1 | k · α = 1 n ω n 1 2 Q F T n k = 0 n 1 | k · α = 1 n ω n 1 2 k F n n a k | k .

Appendix C. Proof of Theorem 2

For a , b F n , we define M a , b = { i [ m ] | [ x i 1 , , x i n ] T = a [ 1 , , 1 ] T + b [ 0 , 1 , , n 1 ] T } and m a , b = | M a , b | . Since the promise ensures that, for each i { 1 , , m } , there exists a , b F n s.t. [ x i 1 , , x i n ] T = a [ 1 , , 1 ] T + b [ 0 , 1 , , n 1 ] T F n n , we have that { M a , b | a , b F n } forms a partition of the set { 1 , , m } .
When i M a , 0 , i.e., [ x i 1 , , x i n ] T = a [ 1 , , 1 ] T , we have the following:
p = 1 n x i p = a n = a .
Otherwise, we have i M a , b for some b 0 , so [ x i 1 , , x i n ] T = a [ 1 , , 1 ] T + b [ 0 , , n 1 ] T . Then, we have the following:
p = 1 n x i p = i = 0 n 1 ( a + i · b ) = 0 .
By (A3) and (A4), if i M a , b , then p = 1 n x i p = δ 0 b · a . Define
1 ( ( x i 1 , , x i n ) , M a , b ) = 1 , i M a , b 0 , otherwise ,
i.e., it is the indicator of i M a , b . Since i M a , b for exactly one choice of ( a , b ) , we have the following:
p = 1 n x i p = δ 0 b · a = a , b = 0 n 1 δ 0 b · a · 1 ( ( x i 1 , , x i n ) , M a , b ) .
We have the following:
i = 1 m p = 1 n x i p = ( ) i = 1 m a , b = 0 n 1 a · δ 0 b · 1 ( ( x i 1 , , x i n ) , M a , b ) = a , b = 0 n 1 i = 1 m a · δ 0 b · 1 ( ( x i 1 , , x i n ) , M a , b ) = a , b = 0 n 1 a · δ 0 b · m a , b = a = 0 n 1 a · m a , 0 ( mod n ) .
Here, (*) follows from (A5). Our next step is to show a = 0 n 1 a m a , 0 = W / n ( mod n ) ; W is defined in Algorithm 2.
Suppose i M a , b , then ( x i 1 , , x i n ) = a ( 1 , , 1 ) + b ( 0 , , n 1 ) . For the p-th player, a + ( p 1 ) b is the value of the i-th coordinate of the vector x p . For a fixed k F n , the set of ( a , b ) s.t. a + ( p 1 ) b = k is { ( k , 0 ) , ( k + p 1 , 1 ) , ( k + 2 p 2 , 2 ) , , ( k + ( n 1 ) ( p 1 ) , ( n 1 ) } . We have the following: p { 1 , , n } , k F n ,
β k p = i = 0 n 1 m k + i ( p 1 ) , i .
Consider i = 0 n 1 p = 1 n m k + i ( p 1 ) , i . When i = 0 , m k + i ( p 1 ) , i is counted n times. Denote S = { ( 0 , 0 ) , , ( n 1 , 0 ) } . For arbitrary [ x , y ] T F n 2 S , the equation
k + i ( p 1 ) i = x y
has a unique solution given by the following:
i = y , and p = y x + k y .
Thus, we have the following:
F n 2 S = { ( k + i ( p 1 ) , i | p { 1 , , n } , i { 1 , , n 1 } } .
Therefore, when i 0 , m k + i ( p 1 ) , i is counted exactly once. We have the following:
p = 1 n i = 0 n 1 m k + i ( p 1 ) , i = p = 1 n i = 1 n 1 m k + i ( p 1 ) , i + p = 1 n m k + 0 ( p 1 ) , 0 = a , b F n 2 S m a , b + n · m k , 0 .
Now, we have the following:
p = 1 n k = 1 n 1 k · β k p = ( A 7 ) k = 1 n 1 k p = 1 n i = 0 n 1 m k + i · ( p 1 ) , i = ( A 8 ) k = 1 n 1 k a , b F n 2 S m a , b + n · m k , 0 = n 2 n 2 a , b F n 2 S m a , b + n k = 1 n 1 k · m k , 0 and p = 1 n β 0 p = ( A 7 ) p = 1 n i = 0 n 1 m i · ( p 1 ) , i = ( A 8 ) a , b F n 2 S m a , b + n · m 0 , 0 .
Note n > 2 is prime, so n 1 is divisible by 2. We have the following:
W = p = 1 n k = 1 n 1 k · β k p + n 2 n 2 · ( n 1 ) p = 1 n β 0 p = n 2 n 2 a , b F n 2 S m a , b + n k = 1 n 1 k · m k , 0 + n 2 n 2 · ( n 1 ) a , b F n 2 S m a , b + n · m 0 , 0 = n k = 1 n 1 k · m k , 0 + n 2 · ( n 1 ) 2 a , b F n 2 S m a , b + n 2 · ( n 1 ) 2 2 · m 0 , 0 = n k = 0 n 1 k · m k , 0 ( mod n 2 ) .
When we divide both sides by n, we obtain W / n = k = 1 n 1 k m k , 0 ( mod n ) . We are now done because of (A6).

Appendix D. Proof of Theorem 3

Suppose we have a protocol that computes the function with zero error. Our protocol is deterministic, so for each x p F n m , it associates exactly one label c ^ such that the p-th player sends c ^ if his vector is x p . We set I x p , c ^ = 1 and I x p , c = 0 for all c c ^ . Therefore, I x p , c { 0 , 1 } and c [ l ] I x p , c = 1 are satisfied for all choices of x p , c .
Next, suppose we have that ( x 1 , , x n ) G I P ( z 1 , , z n ) . Furthermore, assume that the p-th player sends s p / t p for x p / z p for p = 2 , , n . This implies that p = 2 n I x p , s p = 1 and that p = 2 n I z p , t p = 1 . In addition, note that p , such that s p t p for these sequences, the symbols transmitted from users 2 , , n have to be distinct.
Thus, we have the following:
1 = | p = 2 n I x p , s p p = 2 n I z p , s p | = | p = 2 n I x p , t p p = 2 n I z p , t p |
and, consequently, we have the following:
c 2 [ l 2 ] , , c n [ l n ] | p = 2 n I x p , c p p = 2 n I z p , c p | = | p = 2 n I x p , s ^ p p = 2 n I z p , s ^ p | + | p = 2 n I x p , t ^ p p = 2 n I z p , t ^ p | = 2 .
Therefore, the third constraint is satisfied.
Conversely, if { I x p , c | x p F n m , c [ l p ] } satisfies the constraints of the ILP, then we construct a classical protocol as follows. Suppose the p-th player has vector x p for p { 1 , , n } . Since there exists exactly one s p [ l p ] s.t. I x p , s p = 1 , then p sends s p to Alice for p { 2 , , n } . When Alice receives the symbols s p , p = 2 , , n from the other players, she picks arbitrary { y p F n m } i = 2 n s.t. ( x 1 , y 2 , , y n ) satisfies the promise and p { 2 , , n } , I y p , s p = 1 . Then, she outputs f ( x 1 , y 2 , , y n ) . In what follows, we show that
G I P ( x 1 , y 2 , , y n ) = G I P ( x 1 , x 2 , , x n ) .
To see this, assume otherwise. Then, we have the following: G I P ( x 1 , y 2 , , y n ) G I P ( x 1 , x 2 , , x n ) . We have the following:
( x 1 , x 2 , , x n ) G I P ( x 1 , y 2 , , y n ) .
Owing to the third constraint, we have the following:
c 2 , , c n [ l ] | p = 2 n I x p , c p p = 2 n I y p , c p | = 2 .
However, we have that I x i , s i = I y i , s i = 1 for all i { 2 , , n } . By the first and second constraints, we have that I x i , c i = I y i , c i = 0 for all i { 2 , , n } and c i s i . Therefore,
c 2 , , c n [ l ] | p = 2 n I x p , c p p = 2 n I y p , c p | = 0 .
This gives the desired direction.

Appendix E. Linearizing Constraints in the Integer Programming Problem

One issue with the optimization problem in (10) is that the third constraint has multiple absolute values and products of variables. Here, we transform the constraints and add extra variables in (10) to obtain the desired ILP.
Our first step is to introduce auxiliary 0–1 variables that correspond to the products of other 0–1 variables. For instance, it can be verified that we can handle i = 1 k x i = x as follows:
x x i , for i = 1 , , k
x i = 1 k x i ( k 1 ) .
As a first step, we introduce such auxiliary variables for all terms that involve products of our indicator function in (10).
Following this step, we are left with handling constraints that involve sums of absolute values of differences. For this step, we show how to replace each absolute value difference with another auxiliary variable. In particular, we can replace | x y | by z as follows:
| x y | = | x y | 2 = x 2 + y 2 2 x y = x + y 2 x y
where the last step follows from the fact that the variables are of type 0–1. The product term 2 x y can be linearized as described previously. Following these steps, all constraints in the integer programming problem are linear.

References

  1. Yao, A.C.C. Some Complexity Questions Related to Distributive Computing(Preliminary Report). In Proceedings of the Eleventh Annual ACM Symposium on Theory of Computing, STOC ’79, Atlanta, GA, USA, 30 April–2 May 1979; ACM: New York, NY, USA, 1979; pp. 209–213. [Google Scholar] [CrossRef]
  2. Chi-Chih Yao, A. Quantum circuit complexity. In Proceedings of the 1993 IEEE 34th Annual Foundations of Computer Science, Palo Alto, CA, USA, 3–5 November 1993; pp. 352–361. [Google Scholar] [CrossRef]
  3. Horodecki, R.; Horodecki, P.; Horodecki, M.; Horodecki, K. Quantum entanglement. Rev. Mod. Phys. 2009, 81, 865–942. [Google Scholar] [CrossRef]
  4. Buhrman, H.; Cleve, R.; Massar, S.; de Wolf, R. Nonlocality and communication complexity. Rev. Mod. Phys. 2010, 82, 665–698. [Google Scholar] [CrossRef]
  5. Cleve, R.; Buhrman, H. Substituting quantum entanglement for communication. Phys. Rev. A 1997, 56, 1201–1204. [Google Scholar] [CrossRef]
  6. de Wolf, R. Quantum communication and complexity. Theor. Comput. Sci. 2002, 287, 337–353. [Google Scholar] [CrossRef]
  7. Bennett, C.H.; Brassard, G.; Crépeau, C.; Jozsa, R.; Peres, A.; Wootters, W.K. Teleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels. Phys. Rev. Lett. 1993, 70, 1895–1899. [Google Scholar] [CrossRef] [PubMed]
  8. Buhrman, H.; Cleve, R.; Wigderson, A. Quantum vs. Classical Communication and Computation. In Proceedings of the Thirtieth Annual ACM Symposium on Theory of Computing, STOC ’98, Dallas, TX, USA, 24–26 May 1998; ACM: New York, NY, USA, 1998; pp. 63–68. [Google Scholar] [CrossRef]
  9. Cleve, R.; van Dam, W.; Nielsen, M.; Tapp, A. Quantum entanglement and the communication complexity of the inner product function. Theor. Comput. Sci. 2013, 486, 11–19. [Google Scholar] [CrossRef]
  10. Buhrman, H.; de Wolf, R. Communication Complexity Lower Bounds by Polynomials. In Proceedings of the Computational Complexity. Sixteenth Annual IEEE Conference, Los Alamitos, CA, USA, 18–21 June 2001; p. 0120. [Google Scholar] [CrossRef]
  11. Razborov, A.A. Quantum communication complexity of symmetric predicates. Izv. Math. 2003, 67, 145. [Google Scholar] [CrossRef]
  12. Klauck, H. Lower Bounds for Quantum Communication Complexity. SIAM J. Comput. 2007, 37, 20–46. [Google Scholar] [CrossRef]
  13. van Dam, W.; Hayden, P. Renyi-entropic bounds on quantum communication. arXiv 2002, arXiv:quant-ph/0204093. Available online: http://arxiv.org/abs/quant-ph/0204093 (accessed on 18 October 2024).
  14. Marwah, A.; Touchette, D. Optical quantum communication complexity in the simultaneous-message-passing model. Phys. Rev. A 2020, 102, 062608. [Google Scholar] [CrossRef]
  15. Le Gall, F.; Suruga, D. Bounds on Oblivious Multiparty Quantum Communication Complexity. In Proceedings of the LATIN 2022: Theoretical Informatics, Guanajuato, Mexico, 7–11 November 2022; Casta neda, A., Rodríguez-Henríquez, F., Eds.; Springer: Cham, Switzerland, 2022; pp. 641–657. [Google Scholar]
  16. Gall, F.L.; Nakajima, S. Multiparty Quantum Communication Complexity of Triangle Finding. In Proceedings of the 12th Conference on the Theory of Quantum Computation, Communication and Cryptography (TQC 2017), Paris, France, 14–16 June 2018; Wilde, M.M., Ed.; Leibniz International Proceedings in Informatics (LIPIcs). Schloss-Dagstuhl-Leibniz Zentrum für Informatik: Dagstuhl, Germany, 2018; Volume 73, pp. 6:1–6:11. [Google Scholar] [CrossRef]
  17. Lee, T.; Schechtman, G.; Shraibman, A. Lower Bounds on Quantum Multiparty Communication Complexity. In Proceedings of the 2009 24th Annual IEEE Conference on Computational Complexity, Paris, France, 15–18 July 2009; pp. 254–262. [Google Scholar] [CrossRef]
  18. Briet, J.; Buhrman, H.; Lee, T.; Vidick, T. Multiplayer XOR games and quantum communication complexity with clique-wise entanglement. arXiv 2009, arXiv:0911.4007. [Google Scholar] [CrossRef]
  19. Buhrman, H.; van Dam, W.; Høyer, P.; Tapp, A. Multiparty quantum communication complexity. Phys. Rev. A 1999, 60, 2737–2741. [Google Scholar] [CrossRef]
  20. Xue, P.; Li, C.F.; Zhang, Y.S.; Guo, G.C. Three-party quantum communication complexity via entangled tripartite pure states. J. Opt. B Quantum Semiclass. Opt. 2001, 3, 219. [Google Scholar] [CrossRef]
  21. Galv ao, E.F. Feasible quantum communication complexity protocol. Phys. Rev. A 2001, 65, 012318. [Google Scholar] [CrossRef]
  22. Shannon, C. The zero error capacity of a noisy channel. IRE Trans. Inf. Theory 1956, 2, 8–19. [Google Scholar] [CrossRef]
  23. Python Code for ILP in Sec. V. Available online: https://github.com/mengruoyu/ILP (accessed on 18 October 2024).
Table 1. Numerical results.
Table 1. Numerical results.
m l b l c Feasibility
113Feasible
3117Infeasible
224Infeasible
333Infeasible
234Feasible
355Feasible
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Meng, R.; Ramamoorthy, A. Communication Complexity of Entanglement-Assisted Multi-Party Computation. Entropy 2024, 26, 896. https://doi.org/10.3390/e26110896

AMA Style

Meng R, Ramamoorthy A. Communication Complexity of Entanglement-Assisted Multi-Party Computation. Entropy. 2024; 26(11):896. https://doi.org/10.3390/e26110896

Chicago/Turabian Style

Meng, Ruoyu, and Aditya Ramamoorthy. 2024. "Communication Complexity of Entanglement-Assisted Multi-Party Computation" Entropy 26, no. 11: 896. https://doi.org/10.3390/e26110896

APA Style

Meng, R., & Ramamoorthy, A. (2024). Communication Complexity of Entanglement-Assisted Multi-Party Computation. Entropy, 26(11), 896. https://doi.org/10.3390/e26110896

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop