Skip to main content
Entropy logoLink to Entropy
. 2022 Apr 1;24(4):497. doi: 10.3390/e24040497

New Bounds and a Generalization for Share Conversion for 3-Server PIR

Anat Paskin-Cherniavsky 1,*, Olga Nissenbaum 1
Editor: Boris Ryabko1
PMCID: PMC9029113  PMID: 35455160

Abstract

Private Information Retrieval (PIR) protocols, which allow the client to obtain data from servers without revealing its request, have many applications such as anonymous communication, media streaming, blockchain security, advertisement, etc. Multi-server PIR protocols, where the database is replicated among the non-colluding servers, provide high efficiency in the information-theoretic setting. Beimel et al. in CCC 12’ (further referred to as BIKO) put forward a paradigm for constructing multi-server PIR, capturing several previous constructions for k3 servers, as well as improving the best-known share complexity for 3-server PIR. A key component there is a share conversion scheme from corresponding linear three-party secret sharing schemes with respect to a certain type of “modified universal” relation. In a useful particular instantiation of the paradigm, they used a share conversion from (2,3)-CNF over Zm to three-additive sharing over Zpβ for primes p1,p2,p where p1p2 and m=p1·p2, and the relation is modified universal relation CSm. They reduced the question of the existence of the share conversion for a triple (p1,p2,p) to the (in)solvability of a certain linear system over Zp, and provided an efficient (in m,logp) construction of such a sharing scheme. Unfortunately, the size of the system is Θ(m2) which entails the infeasibility of a direct solution for big m’s in practice. Paskin-Cherniavsky and Schmerler in 2019 proved the existence of the conversion for the case of odd p1, p2 when p=p1, obtaining in this way infinitely many parameters for which the conversion exists, but also for infinitely many of them it remained open. In this work, using some algebraic techniques from the work of Paskin-Cherniavsky and Schmerler, we prove the existence of the conversion for even m’s in case p=2 (we computed β in this case) and the absence of the conversion for even m’s in case p>2. This does not improve the concrete efficiency of 3-server PIR; however, our result is promising in a broader context of constructing PIR through composition techniques with k3 servers, using the relation CSm where m has more than two prime divisors. Another our suggestion about 3-server PIR is that it’s possible to achieve a shorter server’s response using the relation CSm for extended SmSm. By computer search, in BIKO framework we found several such sets for small m’s which result in share conversion from (2,3)-CNF over Zm to 3-additive secret sharing over Zpβ, where β>0 is several times less than β, which implies several times shorter server’s response. We also suggest that such extended sets Sm can result in better PIR due to the potential existence of matching vector families with the higher Vapnik-Chervonenkis dimension.

Keywords: PIR, share conversion, CNF secret sharing, communication complexity

1. Introduction

1.1. Private Information Retrieval

Private Information Retrieval (PIR) protocols allow the client to fetch items from the server’s database without disclosing to the server which item was requested. A main challenge in constructing PIR protocols is minimizing the communication complexity. The idea of PIR was introduced by Chor et al. [1], together with the 2-server PIR protocol having the communication complexity O(n1/3) for the dataset size n. PIR has a wide variety of applications such as anonymous communication [2,3], privacy-preserving media streaming [4], blockchain security [5,6], personalized advertisement [7], location and contact discovery [8,9,10], etc.

The naive approach to PIR is just to make the server send all the items in the database to the client: we stress that PIR cares only about the privacy of the client’s request but not about the privacy of the server. However, it entails a huge communication complexity equal to the size of the database. To shorten the communication complexity and still keep the privacy of the request, there are two main approaches to construct PIR:

  • Historically, the first type of PIR was a Multi-Server PIR [1], where the database is replicated for k2 non-colluding servers. The client secret-shares its request, and servers locally compute the secret-shared response and send it back to the client. The client recovers the item from the shares of response. Multi-Server PIR protocols, such as [11,12,13,14] are relatively efficient in information-theoretic settings. The requirement of the replicated database kept by the non-colluding parties is restrictive; however, there is a space for such a PIR, preferably in blockchain databases, cloud services, multi-server enterprise ecosystems where a small number of servers (but not all) are likely to be compromised.

  • Single-Server PIR protocols work in a computational setting and are built on the basis of homomorphic encryption (FHE, AHE, or SHE). The starting point in single-server PIR is the AHE-based protocol of Kushilevitz and Ostrovski [15]. The early single-server PIR constructions were both computationally and communicationally low efficient, although recently significant progress was made which allow speaking about the practically suitable one-server PIR solutions [16,17,18,19]. For instance, the OnionPIR protocol from SHE [16] achieves a 64 KB request and 128 KB response in the online phase of the protocol (and the same in the offline phase) for all the realistic database sizes.

On the high level, for both approaches, the database is represented as a function (usually, a polynomial) f such that for any key x and the correspondent value (a record) y holds y=f(x). Then, the client has to send the request x to the server (servers) in a way that preserves its privacy. For the Single-Server PIR, it means that x is sent encrypted, in the Multi-Server paradigm, x is secret-shared. Encryption or secret sharing has to be homomorphic so that the server (servers) could compute the function f(x) under the encryption/secret-sharing and send the encrypted or secret-shared response y back to the client.

In a 2-server computationally-secure PIR of Gilboa and Ishai [20], the request is shared as a DPF (Distributed Point Function) and has a polylog length. In this case, to compute the shares of the response, only additive operations are needed (DPF sharing is homomorphic in respect of them). However, in the information-theoretic setting, which is the focus of this work, it is still unclear how to construct efficient in terms of communication and computation PIR with the secret sharing which is homomorphic in respect of any number of additions and multiplications.

Currently, 3 generations of information-theoretic PIR protocols exist: the first generation originated from the work of Chor et al [1] is based on Reed-Muller codes and have communication complexity n1/Θ(k), in the second from Beimel et al. [21] they restated some of the previous results in a more arithmetic language, in terms of polynomials, and also considered a certain encoding of the inputs and element-wise secret sharing the encoding, which resulted in nO(k) communication complexity. The third generation from works of Efremenko [11] followed by [22,23,24,25,26], Yekhanin [12], Beimel et al. [13], Dvir and Gopi [14] is based on matching vectors and is the most computationally efficient line of protocols with the complexity no(1) for database size n. In all the 3rd generation schemes, but [14], as was demonstrated by Beimel et al. [13], in fact, the combination of two secret-sharing schemes is utilized, both linear in different groups, and a share conversion with respect to some relation, allowing to locally perform some non-linear operation over the shares (apart from the case of the identity relation).

1.2. Share Conversion

Suppose that there is some number of parties, each holding a share of a secret s which was created by a secret-sharing scheme Sh1. The share conversion is defined as a process of a local computation performed by those parties based only on their shares and outputting the new shares of the secret s in a different scheme Sh2 so that there is some predefined relation between s and s. A systematic study of share conversion was started by Cramer et al. [27] by considering the case s=s for two arbitrary linear secret sharing systems over different fields.

Let us consider an easy illustrative example: for the function f(x)=x1·x2 over the ring R, and for the conversion’s relation s=s2, for the input x=(x1,x2) shared in a linear scheme over the ring R, it is possible to compute f(x) in the following circuit: first, according to the linear property of the first scheme, servers locally compute shares of x3=x1+x2, then convert shares of x1, x2 and x3 to shares of x12, x22 and x32 over R, and finally obtain shares of the response y=21(x32x12x22).

This approach, however, leaves room for improvement, as such a conversion usually increases the size of the request and response in PIR, because the conversion is a local operation and therefore it is not a trivial issue: to evaluate the circuit which computes some succinct function f(x) which represents the database, the client forms its request as a proper input to this circuit. In addition, not any circuit is possible to compute within the existing secret sharing and conversion schemes, which means that we are bound to only certain kinds of the circuit families and, depending on the VC-dimension of these families of those certain function families, the proper representation of request might be much larger than the size of the database. Recall that the notion of the VC-dimension was introduced by V. Vapnik and A. Chervonenkis in [28]. Informally, for the boolean function family F, where each fF:D{0,1}, VC-dimension VC(F) is the size of the largest ID such that the set f|I|fF of restrictions of functions from F contains all the possible boolean functions over I. The higher VC(F) relative to |D|, the more efficient PIR can be built. For a precise definition, see [13].

Using homomorphic properties of secret sharing schemes to perform MPC on shared values is a widely used technique in information-theoretic MPC, initiated by the seminal work of [29]. Indeed, in order to (semi honestly) securely evaluate an algebraic circuit, the parties share their input with Shamir secret sharing. Then, linear combinations can be homomorphically evaluated ‘for free’ via local computation on the shares so that additions can be performed repeatedly any number of times. Multiplications can also be performed, however, multiplying two shared values results in a value shared according to Shamir with the doubled degree. This limits the depth of a circuit computable with (even) 1-privacy if we require that the only communication round will be sending shares for the final reconstruction. This idea transfers to PIR, where inputs come from a single party, so they may also be conveniently preprocessed by it via arbitrarily complex functions (which is not always possible for inputs distributed among multiple parties). For instance, for 3-server PIR, degree-2 polynomials can be locally evaluated if Shamir secret sharing was used. As degree-2 polynomials (over a field) in n variables have non-trivially high VC dimension (n2), this allows for encoding each input via a vector of O(2n/2) entries and using the appropriate share conversion. For k-server PIR, different kinds of share conversion may enable us to evaluate a family of shallow circuits that both have high VC dimension and suitable secret sharing with share conversion, allowing us to locally evaluate them. In particular, note that a share conversion for a suitable relation, rather than a function suffice to evaluate circuits of that type.

1.3. BIKO Framework

In [13], Beimel, Ishai, Kushilevitz, and Orlov (BIKO) interpret the state of the art 3-server PIR schemes as using share conversion from a (variant) of Shamir secret sharing over a certain ring Rm for small composite m, applied to circuits stemming from MV codes [30] {u1,,uh},{v1,,uh} with a bounded set S{0} of <ui,uj> values, for some SZm\{0}. It has the property that <ui,vi>=0, while <uj,vi> for ji is in S. We refer to such codes as S-bounded MV codes. They manage to get improved complexity of the resulting PIR, by using conversions from CNF secret sharing rather than from Shamir over certain small Rm, for which a conversion from Shamir for that relation does not exist (the (t,k)-CNF is a threshold secret sharing scheme introduced in [31]; see Section 2.2 for a detailed description). Specifically, they obtained conversions from (2,3)-CNF over Zm to the additive secret sharing scheme over Zpβ for the following relation CS=(0,s)|sZpβ\{0}(s,0)|sS\{0}Zm\S{0}×Zpβ. They work with the so-called canonical set S=Sm=xZm|ixiseither0or1modpiei\0, where m=i=1kpiei is the decomposition of m into prime factors. This is a useful choice, due to the existence of good Sm-bounded MV codes over composite moduli m. Their approach is motivated by the existence of conversions for CNF to additive (roughly, that CNF can be converted to “any” scheme, and any scheme can be converted to additive), they use Sh1 as CNF over a certain ring, and Sh2 as additive over another ring. This relation (although not a function) suffices to evaluate the required type of circuits, arising from the MV family. There is a potential tradeoff here between the best MV codes that exist over a certain ring R, and the size (more generally, the identity) of the set S that can be achieved. On a high level:

  1. The smaller S is, the easier it is to find a suitable share conversion (required to evaluate functions in the circuit family induced by the MV code).

  2. The larger S is, the easier it is to find an MV code resulting in a family of circuits with high VC dimension. The communication complexity of the resulting PIR decreases with the VC dimension of the set (and eventually, the size of the shallow circuit to evaluate).

The concrete parameters of both constructions used so far for 3-server PIR (in their most efficient variants) follow from the following Theorem 7, and instantiations of it via known constructions of MV codes and share conversion schemes.

On a very high level, these PIR protocols consist of three steps and is shown in Construction 1.

Construction 1: BIKO Framework [13]
  • 1 

    Let f:{0,1}log(n){0,1} denote the server’s database. The client preprocesses its input x{0,1}log(n) into a vector vxRh for a (constant) ring R, where {vx}x is a set of vectors of an S-bounded MV code. It shares the vector coordinate-wise among the k servers via some (2,k)-private secret sharing scheme Sh1 (so no single server learns anything about the secret).

  • 2 
    The servers use linear homomorphism properties of Sh1,Sh2, which are homomorphic over certain finite groups, to locally evaluate (an encoding of) f on the shared v. More concretely,
    f(v)={i|f(i)=1}fi(v)
    where fi(v)=<ui,v>. In some more detail, each <ui,v> uses linear homomorphism of Sh1, then a share conversion from Sh1 to Sh2 relatively to CS, applied to each share of fi(v), and finally linear homomorphism of Sh2 is applied to evaluate ifi(v) on the resulting shares. The share conversion is required to transform <vi,v> for vi=v into a non-zero value, and <uj,v> for vjv into 0’s, making the sum non-zero iff. f(v)=1. Then each server sends its share to the client.
  • 3 

    The client recovers the output using linear homomorphism of Sh2, and post-processing the value.

The correctness of the scheme is easy to verify.

For a 3-server PIR, Ref. [13] provides the technique for the constructing the conversion (it such a conversion exists) from (2,3)-CNF to the additive secret sharing and obtains results for some special cases. Utilizing the results of Beimel et al., Paskin-Cherniavsky and Schmerler in [32] proved that there is a share conversion from (2,3)-CNF over Zm to 3-additive secret sharing over Zp, if m=p1p2, for distinct odd primes p1 and p2, one of which is equal to p. Thereby they found infinitely many cases when conversion falling into the BIKO framework exists.

Theorem 1

([13,32]). Let m=p1·p2, where p1,p2 are distinct primes, and p is a prime. Then, there exists a share conversion from (2,3)-CNF to additive over Zpβ for the relation CSm for some β in the following cases:

  • 1 

    p1,p22, and p{p1,p2}

  • 2. 

    p1=2,p2{3,5,7} and p=2.

For other cases of m=p1·p2 and p, however, the existence of the conversion was neither confirmed nor disproved. The constant β in Theorem 1 seems to grow with m, but due to the techniques used, it has not been proven for any infinite family of parameters.

Remark 1.

However, not all the 3rd generation information-theoretic PIR protocols fall into the BIKO framework. For instance, the work of [14] could be viewed as a certain generalization of it. This beautiful work surprisingly manages to carry over "3rd generation" PIR communication complexity previously achieved for 3 or more servers, to the 2-server setting, resolving a long standing open problem, thereby illustrating the limitations of the BIKO framework, providing evidence that generalizing it in certain directions can be instrumental in the context of PIR. In some more detail, [14]’s PIR has a bilinear, rather than linear reconstruction in Sh2, and the step corresponding to share conversion can not be cleanly viewed as a share conversion from Sh1 to Sh2 according to CS (or in fact any) relation. In particular, the client essentially uses a 2-out-of-3 sharing scheme to make the share conversion work, with himself holding one of the shares.

1.4. Our Contribution

  • Obtaining another infinite class of conversions from (2,3)-CNF.

Following the BIKO framework [13] and utilizing some results of [32], we prove that:

Theorem 2

(Main result, informal).

  • There exists a share conversion from (2,3)-CNF over Z2q to 3-additive secret-sharing scheme over Z2(q1)(q2) for any odd prime q.

  • There is no conversion from (2,3)-CNF over Z2q to Zpβ for any odd primes q and p (including the case q=p) and any β>0.

In this way, we prove the existence of the conversion for infinitely many cases, and also for infinitely many cases we prove a conversion does not exist. Together with [32] for m’s which are products of two primes, it leaves open only the question of the conversion in the case when m=p1p2, where p1 and p2 are both odd and not equal to p.

Note also that for considered cases, we managed to compute the parameter β which determines the server’s response size. We prove that β in Theorem 7 is indeed the best for m=6 among m=p1p2 where p1=2. More concretely, one of our contributions is the precise value of β for share conversion with respect to relation CS2q. Previous techniques did not allow to compute β, as they traded generality that could allow computing β for some additional simplicity—using a single row in M to understand the rank difference β=rank(M,)rank(M).

  • Computing and improving server reply size.

Another somewhat surprising observation we made is that we may sometimes increase S beyond Sm so that a conversion from (2,3)-CNF over Zm to Zqβ (for the same m,q as before) still exists. This may have two possible implications. A direct implication that we observed experimentally for several values of m, is that the rank difference β sometimes goes down, but not all the way to 0. Thus, if the share conversion still exists, as follows from the BIKO technique, β may decrease, leading to the reduced size of the server’s response. We checked this fact for some small m’s by computer search and obtained positive results, which is presented in Section 4. Indeed, we obtained smaller β supplementing Sm up to Sm by additional values. We informally sum the result of the computer search in the following theorem.

Theorem 3.

There exists a share conversion from (2,3)-CNF over Zm to 3-additive secret-sharing scheme over Zpβ with respect to the relation CSm, refining β, where:

  • m=14, p=2, Sm=Sm{3}andSm=Sm{5}, β=30, β=6;

  • m=15, p=3, Sm=Sm{11}β=24, β=12;

  • m=21, p=3, Sm=Sm{8}, β=60, β=30;

  • m=33, p=3, Sm=Sm{23}, β=180, β=90;

  • m=15, p=5, Sm=Sm(anynon-emptysubsetof{4,7,13}), β=8, β=2;

  • m=35, p=5, Sm=Sm(anynon-emptysubsetof{8,22,29}), β=120, β=30;

  • m=21, p=7, Sm=Sm(anynon-emptysubsetof{4,10,13,16,19}), β=12, β=2;

  • m=35, p=7, Sm=Sm(anynon-emptysubsetof{6,11,16,26,31}), β=72, β=12.

This result may also be viewed as evidence that canonical sets Sm for m with a larger number r of prime factors may potentially have share conversions for CSm for (significantly) smaller than 2r1 number of servers (as we have conversions for 2r1 servers but S larger than Sm, where the resulting linear system has much more rows than columns). This direction is interesting to explore, initiating a systematic search for share conversions with server sets as small as possible, resulting in PIR with share complexity polynomial in MV codeword length for m which is a factor of r primes.

In addition to our two main contributions, we identify a few minor errors in [13,32]. Nevertheless, these errors do not affect the correctness of any of their main contributions.

  • We recalculated some computer search results of [13] (BIKO) as they come in contradiction with the theoretical result of Paskin-Cherniavsky and Schmerler. In particular, [13] showed the absence of the conversion for m=35, p=7, while [32] proved that the conversion for this case exists. In addition, we obtained numerical results for cases m=22, 26, 33 which were not considered in BIKO. Our numerical results given in Section 4 confirm both our theoretical result for p1=2 and the conclusion of [32].

  • We corrected some calculation mistakes made in previous work [32]. The corrigenda are shown in Appendix A.

1.5. Instantiations of BIKO and Future Directions of Our Work

Almost all third-generation PIR protocols falling in a BIKO framework, utilize the conversion from Shamir secret sharing instead of CNF. The existence of the conversion from Shamir secret sharing scheme implies the existence of conversion from CNF, but not vice versa [13].

The following theorem by V. Grolmusz generalizes a similar instance of the theorem for 3-servers in [13], to put our work in a broader context. It states the size of the MV families depending on the constant m which has an impact on the complexity of the PIR protocols based on them.

Theorem 4

([30]). Let m=i=1rpi where the pi’s are distinct constant primes, and r>1 is constant. Then there exists an MV code family CZmh of size |C|=expclogr(h)loglog(h)(r1) which is Sm-bounded. Here cprr, where pr is the largest prime.

In fact, the construction in Theorem 4 generalizes to any m with r distinct prime divisors.

Next, we outline some parameters for which suitable share conversions leading to (3rd generation) PIR via the BIKO framework and MV codes from Theorem 4 exist. Note that Theorems 5 and 6 were initially stated in terms of conversion from Shamir secret sharing, but a corresponding conversion from CNF is implied.

Theorem 5

([11,26]). For each r2, there exists a number m with r distinct prime divisors p1pr, with pr73, for which there exists a share conversion from (2,3/4·2r)-CNF over Zm to 3/4·2r-additive over Z2β for some β<m, and relation CSm. Furthermore, such a conversion exists for every m of the form 2t1 with r distinct prime divisors, if the number of parties, 3/4·2r, is replaced by 2r.

In a nutshell, the above result is obtained by [26] via a composition technique applied to [11]’s result for 3-server and 2r-server PIR. The reduction in the number of parties from 2r to 3/4·2r for m with r prime distinct divisors follows from the (somewhat surprising) 3-party conversion for r=2 and m=73·7.

In [23], the authors found 50 additional such 3-party conversions for m=p1·p2 (which need to satisfy a certain condition), leading to further improvements in the number of parties as a function of r. Note, that for all m found in [23], pr73 are large, so the constant in Theorem 1 grows fast with r.

Theorem 6

([23]). For each r104, there exists a share conversion from (2,(3/4)51·2r)-CNF over Zm to (3/4)51·2r-additive over Z2β for some β<m, and relation CSm. For each r<104, there exists a share conversion from (2,3r/2)-CNF over Zm to 3r/2-additive over Z2β for some β<m, and relation CSm.

Note that for the above instantiations, “descending” from [11], m must be odd.

Theorem 7

(Implicit in [13]). Let mN, {0}SZm, and C an S-bounded MV code family {Ch} of vectors in Zmh. Assume also there exists share conversion from (2,k)-CNF over Zm to Zpβ for some constant β, for the relation CS. Then there exists a k-server PIR family for databases of size n=|Ch| with client’s message of size hlog(m) and server’s message of size βlogp.

From Theorems 6 and 7 follows

Corollary 7.

Let r3. Then there exists some m=i=1rpiei where p1<<pr are primes where m|(2β1) for some β. Then a 3/4·2r-server PIR with client communication complexity of O(22pr·log1/r(n)loglog11/r(n)) and (each) server’s communication complexity βlog(p), for some βm exists. For r104, this improves to (3/4)512r servers, and 3r/2 servers for r<104.

We note that among the known m’s in the Corollary above for r=2, pr73 and grows particularly fast with r for r104 if (3/4)512r servers (instead of 3/4·2r) exist.

Instantiating Theorem 7 with Theorem 4 for MV-code construction, and either Theorem 1, we obtain the best known concrete efficiency of 3-server PIR, with 26log(n)loglog(n) communication complexity. On the other hand, for more than polynomially improved communication complexity and a larger number of servers, the best result is obtained by instantiating the share conversion via Theorem 5.

Our concrete result does not improve communication complexity for 3-server PIR, which is essentially optimal for conversion from Z6 by [13] as stated in Theorem 1. However, the technical tools developed may help understand the existence of share conversions for even m with a larger number of prime factors, with better the communication complexity of PIR and the larger number of servers. Due to the generality of BIKO’s framework, converting from CNF, one could hopefully get improved efficiency of communication complexity relatively to the number of servers. In particular, as noted above, the instantiation of BIKO as in [11] does not yield PIR protocols with even m, and the known values of m have large maximal factors and lead to PIR with high constants in the exponent. By a direct corollary from Theorems 4 and 5 similar to Corollary 7, we get a 6-server PIR with communication complexity O2146·log1/3(n)loglog2/3(n). Using the BIKO framework instantiated Theorem 5—the ‘furthermore’ part, for 8-server PIR we obtain a complexity of O234·log1/3(n)loglog2/3(n), by using m=255=3·5·17=281, and instantiating Theorem 4 with m=255. Thus, as far as we know, no PIR with complexity better than O2146·log1/3(n)loglog2/3(n) (best known 6-server PIR) exists for 7 servers. We conjecture that a 7-server PIR with much improved constants exists, by using share conversion from (2,7)-CNF with parameters generalizing the conversions we obtained for m=2·p2.

Conjecture 1.

A share conversion from (2,7)-CNF over Z30 to Z2β for some constant β exists, implying a 7-server PIR forO210·log1/3(n)loglog2/3(n).

We hope to be able to verify the conjecture more easily by generalizing the insights we have for the existence of a share conversion for m=2·p2 to a share conversion to m=2·15 (more generally, for 2·c for some composite c), and the fact that in this case of p1, the analysis turned out to be rather simple. Another reason to hope we can manage with 7 servers is that M is in that case, has a form similar to the 3-server case considered in present work (unless, for example, 6-server case). See Section 1.6 for more details.

A broader goal is improving the number of servers one can tolerate for PIR with CC corresponding to MV codes over Zm with r prime factors. While [26] show how to achieve (3/4)512r servers for an infinite number of r’s and corresponding m’s, and 3r/2-server PIR for finitely many r’s, it would be interesting to improve Theorem 6 to get share conversion for 3r/2-server PIR for all r. Our hope is to devise a composition theorem along the lines of [26], composing ‘gadgets’ of conversions from (2,3)-CNF over Zm for coprime composite m’s. As we already have such conversions for infinitely many pairwise coprime m’s via Theorem 1, we only need a suitable composition theorem. In fact, it is not hard to show, that if we had conversions for coprime m1,m2 respectively, both to Zpβ for the same p, say Z2β, we would obtain the result. In particular, it is strictly easier to prove the existence of conversion from Zp1p2 to Z2β for some β depending on p1,p2 for infinitely many coprime p2i+1·p2i+2’s (as the 51 known cases based on Mersenne-style primes in [26] are a special case). To summarize, to complete this direction, we only need to find a conversion from (2,3)-CNF over Zmi to Z2βi for infinitely many coprimes mi’s of the form mi=p1·p2 where p1,p2 are distinct primes. This seems to require only moderate extension on the (linear algebraic) toolbox conversions from (2,3)-CNF that has been laid out in the seminal work of [13] and subsequently in [32].

A more ambitious still direction (which we expect to be more technically involved) is expected to lead to dramatic improvements in the number of servers, bringing it down from exponential to linear in r. It relies on the following composition lemma, which is not hard to prove (see full version for details).

Lemma 1.

Let m1=2m1,m2=2m2, where m1,m2>1 are odd coprime integers. Assume there exists a share conversion from (2,k)-CNF over Zm1 to (t1,k)-CNF over Z2β1 for the relation Sm1 (and an analogous conversion exists for m2). Then there exists a share conversion from (2,k)-CNF over Z2m1m2 to (t1+t2+1,k)-CNF over Z2max(β1,β2) for CS2m1m2.

Remark 2.

More generally, slightly optimizing parameters, relatively to iteratively applying Lemma 1 for two mi’s, for any r2, and m1,,mr as above, we obtain a share conversion from (2,k)-CNF over Z2i=1rmi to (1+i=1rti,k)-CNF over Z2max(β1,,βr) for the relations CS2i=1rmi.

Assume a conversion generalizing our result from Theorem A1 for 3 servers to more servers, while keeping the conversion to a scheme (t,k)-CNF for sufficiently small t. Such a scheme has enough redundancy to support multiplications over the resulting field F2β unlike (k,k)-additive, which has none (if needed, the field characteristic 2 may be replaced with some other prime, generalizing Theorem 1 instead). Then we can obtain PIR with linear server complexity k=O(r), using Theorem 4, and applying Lemma 1 r1 times. More precisely, we have:

Corollary 7.

Assume there exists a (global) constant t, such that for all sufficiently large k, the following holds. For infinitely many mi’s of the form mi=2pi where all pi are odd distinct primes, there exists a share conversion from (2,k)-CNF to (t,k)-CNF over Z2βi for the relation Cmi. Then, for all sufficiently large r, there exists a k=t(r1)+1-server PIR with communication complexity 2O(log1/r(n)loglog11/r(n)).

1.6. Our Techniques

As described above, one of the main contributions of [13] was an instantiation of the framework for designing PIR protocols, which reduces the question of the existence of a three-server PIR protocol to the existence of a share conversion for certain parameters p1,p2,p, and certain linear sharing schemes over Abelian rings R, R determined by the parameters.

BIKO provides the criteria of the share conversion existence in the case when m=p1p2 for distinct primes p1 and p2 and the set Sm={s1,s2,1}, where s1modp1=0, s1modp2=1, s2modp1=1, s2modp2=0. Namely, they prove that for such m and Sm, the share conversion from (2,3)-CNF over Zm to 3-additive scheme over Zpβ exists if and only if rank(M,)rank(M)=β>0, where the rank is computed over Fp. The matrices M and M, are matrices over Zp with 3m2 columns and 3m2 and 4m2 rows respectively which are constructed from some specific system of equations and inequalities. Beimel et al. in [13] did not provide the general solution for this system; however, they proved existence and nonexistence of the conversion for some special cases.

While the solvability of a system can be verified efficiently for a concrete instance, it does not provide a simple condition for characterizing triples (p1,p2,p) for which solutions exist. Moreover, the size of the matrix M, in this system is 4m2×3m2 which makes the numerical solution for big m’s heavy in practice (though asymptotically efficient). Before [32], where the solvability of the system for the case odd primes p1 and p2, if one of them equals to p was proven, even the question of whether an infinite set of such triples exists remained open.

Our concrete goal in this work is to better understand the case of m=p1p2, motivated by understanding the technical foundations of the broader problem for m which is a product of r>2 distinct primes (see Section 1.5 for details). We proceed using the BIKO characterization above. Concretely, for parameters m=p1p2 and p, this reduces to calculating the quantity rank(M,)rank(M)=β, where the rank is computed over Zp.

In [32], the case p1=p for odd p1 and p2 was explored. To simplify the technical task, the authors of [32] rely on the observation from [13] that β>0 iff M does not span v for any row v of M. Thus, they replace M with some v as above, and work with that (forgoing the goal of understanding the particular value of β). Then, they proceed by bringing the matrix M, to a more convenient form by performing a sequence of carefully tailored elimination steps on the rows of the matrix M,. The sequence of eliminations is based on a observing a 3-leveled structure of the matrix of the matrix M,, and working on blocks of decreasing coarseness as the elimination process progresses. It also involves a change of basis at some point, to make the matrix’s structure nicer for understanding. That is, rewriting the matrix so that the set of columns corresponds to a new basis—here we even manage to get fewer vectors in, as it suffices to include a set of vectors which is guaranteed to span M,. However, the resulting matrix after that process remains too complex to check whether β>0 for all parameters. The analysis up to that point (resulting in some matrix Ainter=(Ainter,v) to analyze) is oblivious to the particular parameters except for not looking at even m (not because it was particularly hard, but rather out of a decision to limit the scope of the paper at what was already achieved). To obtain their partial result for some of the parameters, the authors then reduce the matrix’s rows modulo a certain vector subspace (formally, multiplied it from the right by a certain square matrix L with non-trivial left kernel). Clearly, it holds that if rank(AinterL)rank(AL)>0, then rank(Ainter)rank(A)>0 as well (implying the existence of a share conversion), but not necessarily the other way around. The matrix AinterL turns out to be sufficiently simple to analyze, and for p which is either p1 or p2, the resulting rank difference is non-zero. However, we do not yet understand other parameters, for which rank(Ainter)rank(A)=0, or the case of even m. Also, due to the first simplification, the concrete value of β is not found, and thus the concrete answer complexity of the resulting PIR as implied by Theorem 8 remains unknown.

Our current paper considers the case where p1=2. We proceed by a quite straightforward generalization of [32]’s elimination process up until producing the matrix Ainter, except that we do not make the simplification of keeping a single row out of M, but rather keep the entire matrix. The main divergence from [32] is that we do not perform the reduction modulo a subspace, but are able to directly check whether rank(Ainter)rank(A)>0, and furthermore to compute the exact value of β. This is made possible, as the case where p1=2 turns out to be particularly simple, and we managed to successfully analyze it directly (for all p2,p). The other cases (when m is odd, and p is not equal to p1 or p2) remain open.

2. Preliminaries

2.1. Some Notation

Parameters of the secret sharing schemes. Throughout this paper, we fix the notation for p1, p2 and p being prime numbers such that p1p2, and m=p1·p2 are the parameters of the secret sharing schemes and conversion. Later, considering the corner case p1=2 in Section 3.4, we introduce the odd prime number q to set p2=q.

Matrices and block-matrices. In this paper, we will consider matrices and block-matrices over a finite field F=Zp. Those matrices are defined for 3 levels. The level-2 (“big”) block-matrices we denote by letter A with correspondent indexes. The elements of level-2 matrices are level-1 block-matrices which we denote by the letter R with a lower index equal to the upper index of its “host” A. The level-0 “small” matrices are square matrices, initially having the size m×m. For them, we use distinct letters.

For entry i,j of some matrix X, we use the standard notation of X[i,j]. Addressing the elements of level-2 and level-1 matrices, we address their blocks. Such, A1[i,j] denotes the block in the ith row and jth column of A1. For level-0 matrices, we address the particular elements of this matrix. More generally, for a matrix XFu×v, for the subsets R[v] of rows and C[u] of columns, X[R,C] denotes the sub-matrix with rows (or block-rows) restricted to R and columns (or block-columns) restricted to C. Those rows and columns are ordered in the original order in X. As special cases, using a single index i instead of R (C) refers to a single row (column). A “·” instead of R (C) stands for [u] ([v]). Most of the time, index arithmetic will be done modulo the matrices’ number of (block-)rows and columns (we will however state this explicitly).

When we consider the case p1=2 in Section 3.4, the level-1 matrices Rji’s are quite small and have only 2 level-0 blocks. Therefore, we omit the level-1 and address to level-0 blocks as to the entries of level-2 matrices A(k),.

Some concrete matrices and vectors. By the letter I, we denote the m×m identity matrix. If the identity matrix has a different size, we write this size down in the lower index. For instance, Iq is a q×q identity matrix. By ab×c we denote a b×c matrix with all elements equal to a. In case when a=0 and the size of this zero-block is clear from the context, we omit b×c and write 0 instead of 0b×c. By ab we denote the row of a’s of the length b. For example, 1m means the m-long string of 1’s.

By ei we denote the unity vector. The length of this vector is, as a rule, clear from the context, or it is specified in the accompanying text. The lower index specifies the position of 1 in this vector. In Section 2.5 and subsequently in Section 3.2, when we construct matrices in the basis B=B1B2, the unity vectors have double indexes eb,c. As explained in Section 2.5, there is the telescopic indexing system, and this double index points to the single position in the vector.

Concatenation and circular shifts over matrices. For matrices X,Y with the same number of columns, (X;Y) denotes the matrix comprised by concatenating Y below X. For matrices X,Y with the same number of rows, we denote by (X|Y) the matrix obtained by concatenating Y to the right of X.

In Section 3.4, we obtain the set of circularly shifted matrices. By X<<k we denote the matrix X with the circular left shift by k positions.

2.2. Secret Sharing Schemes

A secret sharing scheme is defined by pair of algorithms Sh=(Share,Dec). The randomized algorithm Share randomly splits a secret message sS into an n-tuple of shares, (s1,,sn). The deterministic algorithm Dec reconstructs s from some allowed (qualified) subset of the shares. The set of all the qualified sets is called an access structure of the secret-sharing scheme. We say that Sh is t-private, and has a threshold access structure if any t shares jointly reveal no information about the secret s.

We say that Sh is linear over some finite Abelian ring G if SG and each share si is obtained by applying a linear function over G to the vector (s,r1,,r)G+1, where r1,…, r are random and independent elements of G. A useful property of such schemes is that they allow evaluating locally linear functions of the shares such that additions and multiplications by the constant from G. In this work, we consider two types of linear secret sharing schemes:

  • Additive secret sharing: the algorithm Share splits sG into n random ring elements that add up to s; the algorithm Dec reconstructs s by adding up all the shares. This scheme is (n1)-private. Within the limits of this work, we consider a 3-additive scheme, where n=3.

  • CNF secret sharing: the algorithm Share first splits sG into nt additive shares sT, each labeled by a distinct set T[n]t, and then lets each share si be the subset of sT apart from iT. For (2,3)-CNF we consider in this work, each of 3 parties obtains 2 additive shares out of 3, such that if additive shares of s are (a,b,c), then s1=(b,c), s2=(a,c), and s3=(a,b). This scheme is 1-private, as any two parties can sum their shares up to calculate the secret s.

See [33] for a survey on secret sharing.

2.3. Share Conversion

We recall the definition of (generalized) share conversion schemes as considered in our paper. Our definition is exactly the definition in [13], in turn, adopted from previous work.

Definition 1

([13]). Let Sh1 and Sh2 be two n-party secret-sharing schemes over the domains of secrets S1 and S2, respectively, and let CS1×S2 be a relation such that, for every aS1, there exists at least one bS2 such that (a,b)C. A share conversion scheme convert(s1,,sn) from Sh1 to Sh2 with respect to relation C is specified by (deterministic) local conversion functions g1,,gn such that: If (s1,sn) is a valid sharing for some secret s in Sh1, then g1(s1),gn(sn) is a valid sharing for some secret s in Sh2 such that (s,s)C.

For a pair of Abelian groups G1, G2 (When G1,G2 are rings, we consider G1,G2 as groups with respect to the + operation of the rings), we define the relation CS as in [13].

Definition 2

(The relation CS [13]). Let G1 and G2 be finite Abelian groups, and let SG1\{0}. The relation CS converts s=0G1 to any nonzero sG2 and every sS to s=0. There is no requirement when sS0. Formally,

CS=(s,0)|sS(0,s):sG2\{0}(s,s)|sS{0},sG2

Given m=p1·p2, where p1p2 are primes and p is a prime, we consider pairs of rings G1=Zm,G2=Zpβ. We denote the set a relation CSm in this work is built with as Sm=xG1|i[2],xmodpi{0,1}\{0}. I.e., Sm={(0,1)Zm,(1,0)Zm,(1,1)Zm}, where (a,b)Zm means the element of Zm which has the remainder a modulo p1, and b modulo p2. For S=Sm, we refer to Sm as the canonical relation for Zm.

2.4. The Characterization of BIKO

In Beimel et al. [13], Sh1 is a 3-additive secret sharing scheme over Zm, and Sh2 is (2,3)-CNF sharing over Zpβ. The conversion with respect to relation CSm from Sh1 to Sh2 is considered. In [13], is proven that such a conversion exists iff a certain condition is satisfied by the matrix M, over Zp.

In matrix M,, the rows are indexed by triples (a,b,c)Zm3, corresponding to (2,3)-CNF sharings of some sSm{0}. The rows corresponding to s0 (i.e., to sSm) form the upper part of the matrix, denoted by M, and the rows corresponding to s=0 form the lower part, denoted by M. In this way, M,=(M;M). The columns of M, are indexed by values in [3]×Zm×Zm. Intuitively, an index (i,x,y) of a column corresponds to share si (of ith server) of the (2,3)-CNF scheme being equal to (x,y). Rows are indexes by triples (a,b,c)=(sbc,b,c). There are m possible values for a, b and c, and 4 possible values for s. For a given b and c, and for a given s there is only one possible value of sbc, hence we replace the first index by simply s, and the matrix has 4m2 rows. The row indexed by (s,b,c) has 1 in the column (i,x,y), if the 3-additive shares (sbc,b,c) are agree with CNF-shares, and 0 otherwise. Thus, there are 1’s in cells [(s,b,c);(1,b,c)], [(s,b,c);(2,sbc,c)] and [(s,b,c);(3,sbc,b)], and 0’s elsewhere in this row.

The work in [13] provided a quantitative lower bound on β, depending on the degree difference between M and M.

Theorem 8

(Theorem 4.5 [13]). Let β=rankFp(M,)rankFp(M). Then, we have:

  • If β=0, then there is no conversion from (2,3)-CNF sharing over Zm to additive sharing over Zpκ with respect to CSm, for every κ>0.

  • If β>0, then there is a conversion from (2,3)-CNF sharing over Zm to additive sharing over Zpβ with respect to CSm. Furthermore, in this case, every row v of M is not spanned by the rows of M.

Theorem 8 provides a full characterization via a condition that given (p1,p2,p) can be verified in polynomial time in (p1,p2,log(p)). More precisely, the size of our matrix M, is 4m2×3m2, so verifying the condition amounts to solving a set of linear equations, which naïvely takes about O(m6) time, or slightly better using improved algorithms for matrix multiplication, and the running time cannot be better than Ω˜(m4) using generic matrix multiplication algorithms. Thus, the complexity of verification grows very fast with m, becoming essentially infeasible for p1,p2 circa 50.

2.5. Our Starting Point—The Result of Paskin-Cherniavsky and Schmerler

The work [32] is made within BIKO’s setting. Starting with the matrix M, they performed the sequence of elimination steps, according to the following lemma.

Lemma 2.

Let A denote a matrix in Zpv×u, and let b=A[v,[u]]. Let I1[v1],I2[u] denote non-empty sets of rows and columns, respectively. A is obtained from A by a sequence of row operations on A, so that A[I1,I2] is a basis of A[[v],I2], and the rest of the rows in A[I1,I2] are zero. Let b=A[v,[u]]. Then, Rows(A[[v]\I1,[u]\I2]) span b[[u]\I2] iff Rows(A[[v1],[u]]) span b.

In fact, the result of [32] is the proof of the existence of the conversion for finite rings G1=Zp1p2 to G2=Zp1β with distinct odd p1 and p2, for which it was enough to prove that the first row of M is not spanned by M. Therefore, the matrix considered in [32] contained the full matrix M and the single row from M. (As in our work we solve the problem for 2 sets of parameters proving both positive and negative results, we consider the full M, matrix). After two elimination steps which cut the matrix M to m+m2 rows, and the permutation of columns, they introduced a new basis B=B1B2, where

B1=eb,i+eb,i+1bZm,i{0,...,p22},B2=eb,i+j·(1,0)Zmeb,i+(j+1)·(1,0)ZmbZm,iZp2,jZp1\{p11}, (1)

where ex,y is a vector of length m2 having 1 in the position indexed by (x,y) and 0’s elsewhere. Indexes x and y are taken modulo m.

In this new basis, the matrix M, has the block structure and is separated into 3 “types” (layers): Type-1 and Type-2 layers compose M, and Type-3 is M after several elimination steps and basis change. For the Type-1 matrix, the basic block is the m-component vector (1,,1) and p1×(p11) block matrices R12 and R13 made from m-long vectors:

graphic file with name entropy-24-00497-i001.jpg (2)
graphic file with name entropy-24-00497-i002.jpg (3)

Basic m×m blocks of Type-2 are identity matrix I, and

graphic file with name entropy-24-00497-i003.jpg (4)

Bigger blocks composed from them have the size p1×(p11) “small” m×m blocks:

graphic file with name entropy-24-00497-i004.jpg (5)
graphic file with name entropy-24-00497-i005.jpg (6)
graphic file with name entropy-24-00497-i006.jpg (7)
graphic file with name entropy-24-00497-i007.jpg (8)

The matrix M is brought to the form (A1;A2), where each of matrices A1 and A2 are block matrices having the left and right parts (In [32], the matrices we are talking about have the additional upper index (6), which is omitted here. Thus, Ai=A(6),i=(A(6),L,i|A(6),R,i) for i1,2):

(A1;A2),A1=(AL,1|AR,1),A2=(AL,2|AR,2), (9)

where

graphic file with name entropy-24-00497-i008.jpg
graphic file with name entropy-24-00497-i009.jpg (10)
graphic file with name entropy-24-00497-i010.jpg
graphic file with name entropy-24-00497-i011.jpg (11)

We remark that the appearance of AR,1 and AR,2 are slightly different from those in the work of Paskin-Cherniavsky and Schmerler. The difference is in p21’st block-row and comes from the computational mistake made in [32] while changing the basis to B. We correct this mistake and bring the corrigendum in Appendix A.

In [32], only the first row from the Type-3 layer was constructed. For our purposes of obtaining β, we need the full Type-3 matrix. Therefore, we write here down the general formula for Type-3 rows taken from [32], and we use it in our next work to construct the entire Type-3 matrix in the basis B:

e(B,C)e(B,C+(0,1)Zm)k=0(1,0)ZmeB+k,CeB+k,C+1,whereB,CZm. (12)

3. Our Result

3.1. Starting Point and Main Technical Tool

Our goal is to compute the difference between ranks of matrices M and M,. We start from the matrix M brought to the form (9) and we also construct the result of initial elimination steps over the matrix M from (12), obtained in [32]. We continue the process of elimination using Lemma 2 considering the case m=2q, where q is an odd prime number.

3.2. Construction of Type-3 matrix

First, as we need to compute the rank of the matrix M,, it is not enough to consider only a single row from the Type-3 matrix (which is the result of the sequence of elimination steps over M. Therefore, our first step is to reconstruct this matrix from (12) and to perform initial elimination steps similar to those were made over matrix A2 in [32] to bring it to the form (11).

To be consistent, we denote the initial Type-3 matrix as A(1),3, the intermediate result of the inner elimination steps over this matrix as A(0),3, and the final result (on the same stage as (9)) as A3. Next we describe the process of obtaining Type-3 matrix from (12). Recall that each of matrices A is separated in the left and right parts, where the left part contains indexes of vectors from basis B1, and right—from B2. Each row of A(1),3 is indexed by i,j,b such that the largest blocks are indexed by iZp2, and contains blocks indexes by jZp1. The smallest blocks indexed by bZm are, in turn, parts of middle-size blocks.

First, rewrite (12) as

e(B,C)e(B,C+(0,1)Zm)e(B,C)+e(B,C+1)k=1(1,0)ZmeB+k,CeB+k,C+1==e(B,C+1)e(B,C+1(1,0)Zm)k=1(1,0)ZmeB+k,CeB+k,C+1. (13)
  • Consider the case when ip21, j0. Each row indexed by (i,j,b) is determined by (13), where B=b, C=i+j(1,0)Zm. Then the first two terms in (13) are
    eB,C+1eB,C+1(1,0)Zm=eb,(i+1)+j(1,0)ZmeB,(i+1)+(j1)(1,0)Zm=B2[(i+1),(j1),b]. (14)
    The term in the sum in (13) is
    eB+k,CeB+k,C+1=eb+k,ieb+k,i+eb+k,i+(1,0)Zm...+eb+k,i+j(1,0)Zmeb+k,i+1+eb+k,i+1eb+k,i+1+(1,0)Zm...eb+k,i+1+j(1,0)Zm==B1[i,(b+k)]+=0j1B2[i,,b+k]B2[(i+1),,b+k]. (15)
  • When j=0, ip21 the sum in (15) turns to 0. As for (14), the first two terms in (13) are:
    eB,C+1eB,C+1(1,0)Zm=eb,i+1eB,i(1,0)Zm==0p12B2[(i+1),,b]. (16)
  • When j0, i=p21, the first two terms of (13) are the same as in (14). The only difference is the sum of terms:
    eB+k,CeB+k,C+1=eb+k,(p21)+j(1,0)Zmeb+k,p2+j(1,0)Zm==eb+k,0+eb+k,p21=0p21+j(eb+k,(1,0)Zmeb+k,(+1)(1,0)Zm)++=0j1(eb+k,(p21)+(1,0)Zmeb+k,(p21)+(+1)(1,0)Zm)===0p22B1[,b+k]=0p21+jB2[0,,b+k]+=0j1B2[(p21),,b+k]. (17)
  • Finally, for i=p21, j=0, the first two terms in (13) are according (16), and the terms in sum are as in (17), except from the term =0j1B2[(p21),,b+k], i.e.,
    =0p22B1[,b+k]=0p21+jB2[0,,b+k]. (18)

Substituting expressions (14)–(18) to (13) for appropriate i,j,b, we obtain the matrix which has the structure similar to A2:

A(1),3=A(1),L,3|A(1),R,3, (19)

where

graphic file with name entropy-24-00497-i012.jpg
graphic file with name entropy-24-00497-i013.jpg

Here block matrices R32 and R33 are of the same form as R22 (6) and R23 (7) respectively, where the blocks T2 are replaced with the blocks T3:

graphic file with name entropy-24-00497-i014.jpg (20)

The matrix R31 is similar to R21, but with the opposite sign, and permuted rows:

graphic file with name entropy-24-00497-i015.jpg (21)

The matrix R34 can be obtained from R31 with the circular permutation of rows:

graphic file with name entropy-24-00497-i016.jpg (22)

3.3. Elimination Steps in Type-3 Matrix

Following the way in [32] for elimination steps in A2, we first sum the block-rows in (19) with ordinal numbers from 0 to p12 to the last block-row. The resulting matrix A(0),3 equals A(1),3 except the last row, where A(0),L,3[p21,·] is 0-block, and

A(0),R,3[p21,·]=R32+R34R33|R31|...|R31.

The second elimination step is an inner step in every block-row except from the last one (as those block-rows are the same in A(1),3 and A(0),3, we can say that this step is performed over (19)). Namely, in any level-2 block-row A(0),3[i,·] where i{0,...,p12}, we subtract the level-1 block-row with the ordinal number 0 from all other sub-rows in this block-row. As a result, A3=AL,3|AR,3, where the left-side matrix takes the form

graphic file with name entropy-24-00497-i017.jpg (23)

and the right-side matrix is

graphic file with name entropy-24-00497-i018.jpg (24)

where

graphic file with name entropy-24-00497-i019.jpg (25)

3.4. The Case of the Even m (p1=2, p2=q)

In this section, we consider the case p1=2, p2>2 for both p=2 and p>2 (including the case p2=p). We obtain the feasibility results and, moreover, in the case of p=2 when the conversion from (2,3)-CNF over Z2p2 to three-additive secret sharing over Z2β (as we prove) exists, we also compute β. We adopt the following notation in this section: p2=q>2, and p are prime numbers, and m=2q (later we split this case into subcases p=2 and p>2). Our starting point is the block matrix A=A2;A1;A3 over Zp, where A1 and A2 are described in (9), and A3 in (23) and (24).

We next consider the matrices in the case when m=2q, where q is an odd prime number. Below we write down the block matrices completing the matrix A. Each of the following matrices contains two square m×m blocks:

R21=R31=R34=II;R24=R35=I2I;R22=0T2;R23=T20;R32=0T3;R33=T30. (26)

We would like to remind that 1m=(1,...,1) is an m-element vector of 1’s, also 1q is the q-element vector of 1’s. I is a m×m identity matrix, and Iq is a q×q identity matrix.

Taking into account (26), the block matrix A=A2;A1;A3 according to (9), (23) and (24) is the following:

graphic file with name entropy-24-00497-i020.jpg (27)
graphic file with name entropy-24-00497-i021.jpg (28)
graphic file with name entropy-24-00497-i022.jpg (29)

The left-side and the right-side matrices are divided by the double vertical line. All the subsequent matrices which we will obtain from A will have the additional upper indexes: A(i)=A(i),2;A(i),1;A(i),3, where i is the ordinal number of the matrix in the sequence of transformation steps. Within the limits of this section, we consider matrices A(·), as if they have level-0 blocks as the entries, and we, therefore, address to level-0 blocks as to the entries of level-2 matrices A(·),.

First of all, we subtract A2 from A3 and rewrite all the matrices such that first go all the block-rows for i<p21, j=0, and then the block-rows for i<p21, j=1 and two last block-rows remain where they were before.

Matrices T2 and T3 depend on values (0,1)Zm=q+1 and (1,0)Zm=q. We introduce the new block T=T3T2 and note that with respect to (26),

graphic file with name entropy-24-00497-i023.jpg (30)
graphic file with name entropy-24-00497-i024.jpg (31)
graphic file with name entropy-24-00497-i025.jpg (32)
graphic file with name entropy-24-00497-i026.jpg (33)

We note that the last block-row in A(1),2 is the same as the previous one up to sign. The same observation we can make about A(1),3.

3.4.1. Internal Transformations in Matrices on the Level-2

We made some quite obvious steps inside each of the matrices A(1),· to reach a more comfortable form. In A(1),2 we eliminate the last block-row. In addition, we add all the block-rows from A(1),2[i] for i{q1,...,2q3} to block-row A(1),2[2q2] and change the sign of this row. The resulting matrix is

graphic file with name entropy-24-00497-i027.jpg (34)

In A(1),1, we change the sign of the pre-last row, move it to the position p21=q1 and make telescopic elimination by the following sequence of steps: starting with the row i=q, we subtract the previous row from ith, then change the sign of the ith row. Then we increment i by 1. We repeat this algorithm up to the last row of this matrix. Note, that the last row turns to 0, so we eliminate it from the matrix. The result is the matrix with (2q1) rows:

graphic file with name entropy-24-00497-i028.jpg (35)

The same transformation we perform in A(2),3, working with block-rows instead of rows. The result is the following matrix with (2q1) block-rows:

graphic file with name entropy-24-00497-i029.jpg (36)

3.4.2. Resolution of the Level-0 Blocks in A(2),3

Consider the block-rows of the appearance |T+2I| in (36). According (30), it equals to the matrix Inline graphic, where first q rows are the same as q last ones, and those q rows can be eliminated from the matrix. According to our notation, the q×m-block equal to the concatenation of two Iq’s is denoted as (Iq|Iq). The rows we just considered belong to the local basis of A(2),3.

Then we consider the block-rows |T||I|I| in (36). Subtracting from this block-row the basis vectors from two corresponding block-rows |(Iq|Iq)| and taking into account (30), we transform it to:

graphic file with name entropy-24-00497-i031.jpg

Again, the first q rows in this block-row can be crossed out from the matrix, as they are the same as q following ones up to the sign. Then the resulting matrix contains only q(2q1) rows of the local basis:

graphic file with name entropy-24-00497-i032.jpg (37)

3.4.3. Resolution of the Level-0 Blocks in (A(2),2;A(2),1)

First, we consider block-rows of appearance |T2||I| in A(2),2 (Equation (34)). For each j>q, T2[j]=T2[0]+T2[q]T[jq], hence we can bring all the T2[j] to 0 by the inner linear operations of rows in the block-row, which result in the following appearance of the block-row under the consideration:

graphic file with name entropy-24-00497-i033.jpg (38)

where T2=T2[{0,...,q},·], and J is a (q1)×q-size matrix:

graphic file with name entropy-24-00497-i034.jpg (39)

The set of all the upper block-rows as in (38) is in the echelon form and belongs to the basis of our matrix. Now, we pay attention to q1 first rows in A(2),1 (Equation (35)), taking into account that 1m=T2[0]+T2[q]. Subtracting the correspondent rows of A(2),2 from A(2),1, we bring the rows of the appearance A(2),1[i,·]=|1m||| to the form 0|||(e0|e0)|. Considering this resulting row together with the second block-row from (38), we can see that those are easily transformable to the form 0|||(Iq|Iq)|. As block-rows of the appearance 0|||(Iq|Iq)| are composed from transformed rows of both matrices A(2),2 and A(2),1, we denote this merged matrix of q1 block-rows as Aq1(3),1&2:

graphic file with name entropy-24-00497-i035.jpg (40)

This matrix is in the left echelon form and thus consisted from the basis vectors of M,.

In addition, we consider the last block-row of A(2),2, namely, 0||I|I||I|T2I and subtract from there all the correspondent basis vectors of (40). Each block I then turns to Inline graphic. Adding the upper half of the resulting block-row to the lower (and changing the sign of the upper one), we get Inline graphic. We subtract the last row of A(2),1 from each of last q rows of this block-row. Then these last q rows come to the form 0|||(Iq|Iq), and we append them to (40) to complete the matrix A(3),1&2. Then, subtracting the appropriate rows of the block (Iq|Iq) from the block (IT2)[0,...,q1], we transform it to the form (0q×q|IqN), where N is a q-dimension matrix

graphic file with name entropy-24-00497-i038.jpg (41)

Finally, we consider the block-rows in A(2),2 in (34) of the appearance 0|||T22I|T2|. Let us consider the result of the elimination the basis (Iq|Iq) from the block

graphic file with name entropy-24-00497-i039.jpg (42)

The result of the elimination is Inline graphic. For the block T2, the result of the elimination is Inline graphic. Thus, each block-row under the consideration turns to the following q-row block-row 0|||(0|N)|(0|2IqN)|.

Thus, the result of all the transformations over A(2),2;A(2),1 above is A(3),2;A(3),1&2, where

graphic file with name entropy-24-00497-i042.jpg
graphic file with name entropy-24-00497-i043.jpg (43)

We note, that all the rows of A(2),1 in (35) of the appearance 0|||1m| are spanned by A(3),1&2 as the row’s sums over the correspondent block-row.

3.4.4. Resolution of the A(3),1&2 Basis

To apply Lemma 2, it is necessary to subtract vectors of basis A(3),1&2 from the first (q1) block-rows of A(3),2. The matrix A(3),3 contains exactly the same block-rows as A(3),1&2 which can be simply crossed out.

Subtracting block (Iq|Iq) from block (Iq+1|0), we obtain the latest in form Inline graphic. We denote the (q+1)×q block Iqe0 as (Iq+1). Then, after applying Lemma 2 to remove the basis A(3),1&2 and corresponding columns, we obtain the matrix

A(4)=A(4),2;A(4),3,

where

graphic file with name entropy-24-00497-i045.jpg (44)
graphic file with name entropy-24-00497-i046.jpg

3.4.5. Elimination of the Left-Side Matrices

We note that each row in block (Iq|Iq) is spanned by the rows of T2, namely, (Iq|Iq)[j]=T2[j]T2[j+1] (j{0,...,q1}). Subtracting the correspondent rows of A(4),2 from A(4),3, and applying Lemma 2, we obtain

graphic file with name entropy-24-00497-i047.jpg
graphic file with name entropy-24-00497-i048.jpg (45)

Here, the left side is crossed out, and matrix A(5)=A(5),2;A(5),3 is the matrix of q×q level-0 blocks.

3.4.6. Resolution of N and 2IqN Blocks

Up to this moment, we performed transformations in matrices without connection to any particular modulus. Considering blocks N and 2IqN in A(5),2 (Equation (45)), we can see two different situations taking into account the prime modulus p=2 or p>2:

  • In the case of p>2, each N defined in (41) can be transformed to Iq by the linear transformation steps such as additions of rows, multiplications by (−1) and 21 (which exists due to the fact that p is odd). Applying the same transformations to the adjacent block 2IqN, we turn it into Iq*, where
    graphic file with name entropy-24-00497-i049.jpg (46)
  • In the case of p=2, each block-row of the appearance |N|2IqN| in (45) contains q equal rows |1q|1q|.

According to the dichotomy above, we next consider two cases.

3.4.7. Case p1=2, p2=q, p>2

As described in the previous subsection, we start from matrix A(6)=A(6),2;A(6),3, where

graphic file with name entropy-24-00497-i050.jpg

Performing inside each block-row of A(6),3 two operations: multiplication rows at indexes from 0 to q1 by (−1), and circular permutation of rows, we transform A(6),3 to the form

graphic file with name entropy-24-00497-i051.jpg

which is obviously spanned by rows of A(6),2, and therefore rank(M,)=rank(M).

Theorem 9.

Assume m=2q, and p,q are odd prime numbers. Then there is no share conversion from (2,3)-CNF over Z2q to three-additive secret-sharing scheme over Zpβ for any β.

Proof. 

The proof follows from Theorem 8 and the fact that rank(M,)=rank(M). □

3.4.8. Case p1=2, p2=q, p=2

Here, we start from matrix A(6)=A(6),2;A(6),3, where

graphic file with name entropy-24-00497-i052.jpg

Performing the same permutation of rows in each block-row in A(6),3 as for the case p>2, we obtain block-rows in form |Iq|Iq<<1|, where Iq<<k according to our notation is the result of the left k-bit circular shift in Iq. We remark that Iq<<k1Iq<<k2=Iq<<(k1+k2)modq. Subtracting the last block-row of A(6),2 from the first block-row of A(6),3, we obtain

A(7),3[0]=0|IqIq<<1|Iq||Iq|IqN.

The matrix IqIq<<1 is an invertible matrix, hence it is the linear transformation matrix. We subtract the row (IqIq<<1)A(7),3[1] from A(7),3[0] to obtain

A(7),3[0]=0|0|Iq(IqIq<<1)Iq<<1||Iq|IqN.

We stress, that Iq(IqIq<<1)Iq<<1=IqIq<<1Iq<<2. Then we similarly subtract the 3rd block-row multiplied by the 3rd element of the first block-row, then 4th, and so on. As a result, the first block-row takes the form:

A(7),3[0]=0|0|0||0|IqNIq<<1Iq<<2Iq<<(q1).

Taking into account that k=0q1Iq<<k=1q×q=N, the first block-row of A(7),3[0] equals zero and can be crossed out of the matrix.

Now, we make some elimination steps to bring matrix A(6),2 to the echelon form (such that all the rows there are basis rows). For this, we subtract all the rows with even ordinal numbers from the first row of the last block-row. The resulting last block-row in A(6),2 turns to K|K||K|KN, where

graphic file with name entropy-24-00497-i053.jpg (47)

In both blocks K and KN, the first row is spanned by others (as their sum), thus the first row of this block-row can be crossed out. The remaining rows in this block-row are basis vectors, which do not span A(7),3, and thus, according to Lemma 2 can be thrown out the next consideration (together with the first row which also does not span A(7),3). Then A(7)=A(7),2;A(7),3, where

graphic file with name entropy-24-00497-i054.jpg

Matrix A(7),3 contains (q2) block-rows with q rows each. We make the last elimination step by subtracting each row of A(7),2 from the first row of the correspondent block-row of A(7),2. Then each block Iq turns to K, and each Iq<<1 turns to K<<1, where the first row is the sum of others. Hence, each block-row in A(7),3 loses the first row, and the rest of them are not spanned by the basis vectors of A(7),2. Thereby, there are (q2) block-rows with (q1) rows each, and rank(M,)rank(M)=(q1)(q2).

Theorem 10.

Assume m=2q, where q is an odd prime number. Then there exists a share conversion from (2,3)-CNF over Z2q to a three-additive secret-sharing scheme over Z2(q1)(q2).

Proof. 

The proof follows from Theorem 8 and rank(M,)rank(M)=(q1)(q2). □

4. Computer Search Results on the Set Sm and the Extended Set Sm

Table 4 in the work of Beimel et al. [13] reports ranks of the matrices M and M, for m=6, 10, 14, 15, 21, 35 and p=2, 5, 7, 11. Unfortunately, some of the data there go against the proven properties of those matrices. For instance, in [32] it was proven that there exists a share conversion in case m=p1·p2 and p=p1, where p1 and p2 are distinct odd primes. At the same time, Table 4 in [13] shows that for the case m=5·7 it holds that rank(M)=rank(M,) over Z7, which means the absence of the conversion. Moreover, rank(M) cannot be less than m2, since the matrix M has an identity block matrix of the size m2×m2 in the upper left corner. However, for case m=35 in Table 4 in [13], this rank appears to be less. Therefore, we recalculated this table (also by computer search) in Table 1 and Table 2 to correct the result of [13] as well as to check the soundness of our derivations.

Table 1.

Rank of M and difference between ranks M and M, (rank(M); β) for some even m over different Zp.

m 2·3=6 2·5=10 2·7=14 2·11=22 2·13=26
Sm {1,3,4} {1,5,6} {1,7,8} {1,11,12} {1,13,14}
p=2 87 ; 2 247 ; 12 487 ; 30 1207 ; 90 1687 ; 132
p=3 89 ; 0 259 ; 0 517 ; 0 1297 ; 0 1819 ; 0
p=5 89 ; 0 259 ; 0 517 ; 0 1297 ; 0 1819 ; 0
p=7 89 ; 0 259 ; 0 517 ; 0 1297 ; 0 1819 ; 0

Table 2.

Rank of M and difference between ranks M and M, (rank(M); β) for some odd m over different Zp.

m 3·5=15 3·7=21 3·11=33 5·7=35
Sm {1,6,10} {1,7,15} {1,12,22} {1,15,21}
p=2 617 ; 0 1229 ; 0 3077 ; 0 3529 ; 0
p=3 593 ; 24 1169 ; 60 2897 ; 180 3529 ; 0
p=5 609 ; 8 1229 ; 0 3077 ; 0 3409 ; 120
p=7 617 ; 0 1217 ; 12 3077 ; 0 3457 ; 72

The results in Table 1 confirm our conclusions. Indeed, for the case of m=2q there is a conversion if and only if the modulus of the group is 2, and in this case β=(q1)(q2). Table 2 is relevant to the result of [32]. For the case of odd m=p1·p2, there is a conversion if the modulus of the group p equals either p1 or p2.

In this paper, as well as in [32], only the case of the set Sm of size 3 was considered. However, as we noted in the Introduction, the larger sets if the conversion for them exists, could result in MV families with higher VC dimension and hence in better PIR. For cases when the conversion exists in respect to the relation CSm, we also decided to check the extended sets Sm, trying different additional values from Zm and checking the ranks of M and M,.

For even m, we only tested possible extensions for Sm modulo 2 (because if there is no conversion for a set Sm, then there is no conversion for any extended set). Of all the cases in Table 1, only for m=2·7 there are extended sets Sm={1,3,7,8} and {1,5,7,8} with β>0 (namely, β=6). The set Sm={1,3,5,7,8} provides β=0 and therefore the absence of the conversion.

Surprisingly, for odd m’s the result is more encouraging: for all m and p in Table 2 which provide β>0 for Sm, there were also extended sets Sm with non-zero β. We summed them in Table 3. In the row Sm\Sm, there is a subset extending Sm up to Sm. It is interesting that any number of entries added from Sm\Sm to Sm gives the same rank(M) and β. It is also interesting that the set Sm in all the checked cases with the odd m contains all the entries which are equal to 1 modulo p2 (taking p1=p) except from 1 and (0,1)Zm which are already in Sm. Namely, Sm\Sm=(2,1)Zm,...,(p1,1)Zm.

Table 3.

Extensions for some sets Sm allowing the share conversion.

p 3 3 3 5 5 7 7
m 3·5=15 3·7=21 3·11=33 3·5=15 5·7=35 3·7=21 5·7=35
Sm\Sm {11} {8} {23} {4,7,13} {8,22,29} {4,10,13,16,19} {6,11,16,26,31}
rank(M) 607 1201 2989 627 3511 1257 3547
β 12 30 90 2 30 2 12

Acknowledgments

We thank Yuval Ishai and Klim Efremenko for helpful discussions.

Abbreviations

The following abbreviations are used in this manuscript:

PIR Private Information Retrieval
CC Communication complexity

Appendix A. The Correction Notice to Paskin-Cherniavsky and Schmerler

Here, we correct some computational mistakes made in [32]. The main mistake is the appearance of the matrix A2, which correction implies also some changes in the following proof of the result. Thought, those mistakes do not affect the main result of [32] (namely, the existence of the conversion for m=p1p2, p=p1).

The major computation mistake appears in Subsection 4.5.1 of [32], therefore the following correction notice reproduces the corrected article starting from Subsection 4.5.1 up to the end the Section 4. In this section, we slightly change the enumeration of matrices to make them consistent with the present work, where we start with the matrix A in (9), which is denoted as A(6) in [32]. Here we correct the mistake made in the previous-step matrix A(4) and show how it affects the following proof. Therefore, we change the upper indexes in the following way: we write A(1),· instead A(4),·; A(0),· instead A(5),·; A· instead A(6),·; A(1),· instead A(7),·, etc. In addition, as we changed some notation in matrices, we note that we use here the notation T2 for the matrix previously denoted T0 (to be consistent with the present work), and also we use R1· instead R˜1·, and R2· instead R1·. Similarly, we use L1· instead L˜1·, and L2· instead L1·.

Appendix A.1. The Matrix A(1),2

The mistake in the construction of A1 and A2 only affects the last block-rows of these matrices (i.e., for i=p21). Therefore, we will consider in detail how these block-rows are built. According to the Section 4.5 in [32], the Type-2 vectors are in the form:

rb,c2=eb,ceb,c+(1,0)Zmk=0(0,1)Zmeb+k,ceb+k,c+1. (A1)

When i=p21, each term under the summation in (A1) is similar to (17):

eb+k,ceb+k,c+1==0p22B1[,b+k]=0p21+jB2[0,,b+k]+=0j1B2[(p21),,b+k]. (A2)

The first two terms of (A1) differ for distinct j: if j<p11 they are

eb,ceb,c+(1,0)Zm=eb,p21+j(1,0)Zmeb,p21+(j+1)(1,0)Zm=B2[p21,j,b]. (A3)

For i=p21, j=p11, the first two terms in (A1) are

eb,ceb,c+(1,0)Zm=eb,p21+(p11)(1,0)Zmeb,p21+p1(1,0)Zm==0p12B2[p21,,b]. (A4)

Equations (A3) and (A4) give us the matrix R21 in the last block of the last block-row of A(1),2. Equation (A2) gives the last block-row in A(1),L,2, and the blocks R23 and R22 in the last block-row of A(1),R,2. Upper block-rows in A(1),2 remain as in [32].

A(1),2=A(1),L,2|A(1),R,2

Here, the “right side” A(1),R,2 is a p2×p2 block matrix. Its content is as follows.

graphic file with name entropy-24-00497-i055.jpg

The left-side matrix A(1),L,2 is a block matrix of size p2×1 (where indeed the number of rows in each of its p2 blocks is consistent with that of A(1),R,2). It has the following structure (There was a missing “-” in the description of A(1),L,2[p21] in [32]).

graphic file with name entropy-24-00497-i056.jpg

We refer to this partition into p2×(p2+1) blocks of A(1),2 as the “Level-1” partition of A(1),2. We continue next by describing the “Level-0” detail of R21,R22,R23,L2(1),i in A(1),R,2,A(1),L,2. The matrix L2(1),i for i{0,,p22} is a p1×(p21) block matrix of the following form:

graphic file with name entropy-24-00497-i057.jpg

for a m×m circulant matrix T2 specified in (4). Note that by the structure of A(1),L,2, the last matrix L2(1),p21 is a block matrix of size p1×(p21), where each block equals T2. The matrix R21 is a p1×(p11) matrix specified in (5). The matrix R22 is a p1×(p11) matrix given in (6). Finally, the matrix R23 is a p1×(p11) block matrix (7).

Note that (p2modp11) is always smaller than p11 since p2 is prime (and thus is not a multiple of p1).

Appendix A.2. The Matrix A(1),3

We choose (B,C)=(0,0). Then, by Equation (12) and a simple calculation, the line is of the form (Note that another T0,0 element is required to take care of the e0,0e0,(0,1)Zm part, so it is subtracted, and is thus missing from the first sum):

b=1(0,1)Zm1Tb,0+j=0p12R0,1+j·(1,0)Zm

Appendix A.3. The Matrix A(1),1

We consider in detail now only the last block-row of A(1),1. According to the Section 4.5 in [32], the Type-1 vectors are in the form:

rc1=bZmeb,ceb,c+1. (A5)

When i=p21, each term under the summation in (A5) is:

eb,ceb,c+1=eb,p21+j(1,0)Zmeb,p2+j(1,0)Zm==0p22B1[,b]=0p21+jB2[0,,b]+=0j1B2[(p21),,b]. (A6)

The first term in (A6) gives the block filled by (−1)’s in the left part of the matrix A(1),1, the second term gives R13 in the first block of the right block-row, and the third term gives R12 in the last block of the last block-row of A(1),1. Upper block-rows in A(1),1 remain as in [32].

The matrix A(1),1 then is of the form A(1),1=(A(1),L,1|A(1),R,1). To describe the left and right parts, we apply a certain transformation to A(1),L,2 and A(1),R,2, respectively. As before, we view each as a block matrix comprised of blocks of size m×m (A(1),L,2 has m×(p21) blocks, and A(1),R,2 has m×p2(p11) blocks. That is, the resulting A(1),L,1 equals:

graphic file with name entropy-24-00497-i058.jpg

where L1(1),i equals:

graphic file with name entropy-24-00497-i059.jpg

The resulting matrix A(1),R,1 equals (The last block-row is changed to correct the mistake made in [32]):

graphic file with name entropy-24-00497-i060.jpg

where the resulting R12 is defined in (2), and R13 in (3). (The matrix R13 is corrected in comparison with [32]).

Appendix A.4. Another Elimination Sequence

From now on, assume that p=p1 and that p2>2. We leave the full analysis of other cases for future work. We are now able to apply Lemma 2. We perform this step for I2 corresponding to the L-part blocks of A(1) and proceed in several steps. We perform the row operations starting at a grosser resolution and then proceed to a finer resolution.

Appendix A.4.1. Step 1: Working at the Resolution of Level-1 Blocks

View A(1),2 as a block matrix of Level-1 as described above. Let V(1),2 denote the corresponding block matrix. Replace the last row of V(1),2, V(1),2[p11,·] by i=0p21V(1),2[i,·]. We thus obtain a new matrix A(0),2 of the following form. A(0),2=A(0),L,2|A(0),R,2 has the same block structure as A(1),2 on all levels, so we do not repeat that, but rather only review its content.

The resulting right side A(0),R,2 is as follows. (The matrix A(0),R,2 corresponds to A(5),R,2 in [32] and has the different form in the last block-row because of the corrected mistake)

graphic file with name entropy-24-00497-i061.jpg

The resulting left-side matrix A(0),L,2 is (The matrix A(0),L,2 corresponds to A(5),L,2 in [32]):

graphic file with name entropy-24-00497-i062.jpg

We perform a similar transformation on A(1),1, resulting in:

A(0),1=(A(0),L,1|A(0),R,1)

where A(0),R,1 equals (The matrix A(0),R,1 corresponds to A(5),R,1 in [32] and is in different from it because of the corrected mistake):

graphic file with name entropy-24-00497-i063.jpg

and A(0),L,1 equals (The matrix A(0),L,1 corresponds to A(5),L,1 in [32]):

graphic file with name entropy-24-00497-i064.jpg

Appendix A.4.2. Step 2: Working at the Resolution of Level-0 Blocks

Here, we view the matrix A(0) as a block matrix over Level-0 blocks. That is, denote by (i,j) the row block corresponding to the jth Level-0 block inside the ith Level-1 block of A. We transform A(0) into a matrix A as follows.

For each i{0,,p22},j{1,,p11}, replace each row in V(0),2[(i,j),·] with V(0),2[(i,j),·]V(0),2[(i,0),·]. The resulting matrix A2 is of the form A2=(AL,2|AR,2). (The matrix A2 corresponds to A(6),2 in [32]).

The right side AR,2 is as follows. (The matrix AR,2 corresponds to A(6),R,2 in [32] and is in different from it because of the corrected mistake).

graphic file with name entropy-24-00497-i065.jpg

where R24 is given in (8). The resulting left-side matrix AL,2 is (The matrix AL,2 corresponds to A(6),L,2 in [32]).:

graphic file with name entropy-24-00497-i066.jpg

where L2i is given in (11).

Finally, we apply a similar transformation to A(0),1 resulting in AL,1 that equals (The matrix AL,1 corresponds to A(6),L,1 in [32]):

graphic file with name entropy-24-00497-i067.jpg

where L1i is given in (10). The resulting right-hand side is AR,1=A(0),R,1 (there is no change, since the first block-row in V(0),R,1 is zero).

Appendix A.4.3. Step 3: Working within Level-0 Blocks

Here, we move to working with individual rows and complete the task of leaving a basis of the original rows of A(1),L as the set of non-zero rows of the matrix A(1),L obtained by a series of row operations. To this end, our goal is to understand the set of remaining rows in AL. In the AL,2 part, each Level-0 block-column (with blocks of size m×m) has only G=defRows(T2){(1,,1)} (here, one appears m times) as non-zero rows, and in each row, there are non-zero entries in only one of the blocks. Thus, it suffices to find a basis for the set G of vectors.

Lemma A1.

Assume p=p1. Then, the index set I={k|0k(p11)p2} satisfies that Rows(T2[I,[m]]) is a basis for G. In particular, for each iZp, we have j=0p11T2[i+j·p2,[m]]=x·(1,,1). Here, x is computed as follows: first calculate y as p21 modulo p1 (that is, in Zp1). Then, we “lift” y back into Z (1yp11) and then set x to be y modulo p—that is, x is an element of Zp (note that all non-zero coefficients in the linear combination that results in (1,,1) indeed belong to I).

Another observation that will be useful to us identifies the dual of T2.

Lemma A2.

Assume p=p1. Then, the set of vectors:

S={j=0p11ej·p2ei+(j+1)·p2|iZp2\{0}}

is a basis of Ker(T2), where Ker(T2)=def{v|v·T2} denotes the left kernel of the matrix T2.

The observations are rather simple to prove by basic techniques; see [32]. Note that the general theory of cyclotomic matrices is not useful here, as it holds over infinite or large (larger than matrix size) fields, so we proceed by ad-hoc analysis of the (particularly simple) matrices at hand.

We handle the A(1),2 part first (The matrix A(1),2 corresponds to A(7),2 in [32]). We conclude from Lemma A1 that for every block specified by (i,j) where ip21, in VL,2[(i,j),·], the rows indexed by bI (as in Lemma A1) span all rows in that block. Furthermore, for the purpose of Lemma 2, we b-zero the rest of the rows, by a sequence of row operations as specified by Ker(T2) in Lemma A2, starting from row (p11)p2+1 and moving forward up to m1. That is, for b -zeroing row (p11)p2+k (where k>0) in VL,2[(i,j),·] as above, we store the combination:

h=0p11V1[(i,j,k+h·p2),·]V1[(i,j,k+(h+1)·p2),·]

in row (i,j,k) of A(1),2.

Overall, the resulting A(1),2 is as follows: A(1),R,2 is identical to AR,2, except for replacing R24 with R25. That is, in the last block row R25, all cells are R12, and there are p1 such cells.

Here, R12 is of the form:

graphic file with name entropy-24-00497-i068.jpg
graphic file with name entropy-24-00497-i069.jpg

Next, we handle the A(1),1 part (Here, A(1),1 corresponds to A(7),1 in [32]). Here, we b-zero the remaining rows in AL,1 by adding the right combination of rows in AL,2. The combination is determined by the “in particular” part of Lemma A2. The resulting matrix A(1),L,2 is identical to AL,2, except for T2 in each L2i being replaced by T2. Here, T2 has the form:

graphic file with name entropy-24-00497-i070.jpg

Here, A(1),L,1 becomes zero, which was our goal. Note that as opposed to previous transformations, the transformation performed on AL,1 does not “mirror” the transformation performed on AL,2 and in fact involves rows from both AL,2 and AL,1. A(1),R,1 is identical to AR,1, except that in each Level-1 block (i,i) for i{0,,p22}, the first row of R12 (the content of this block) is replaced by (We correct here the typo in [32], by adding the exponent (1) to x):

i=0p11x1ei·p2.

It remains to b-zero the L-part of A3. For simplicity, we focus on VL,3[0,0] (which is the only non-zero block in VL,2) and then use the resulting linear dependence to produce the new row V3[0,·].

VL,3[0,0]=x1i=0p11VL,2[(0,0,i·p2),0]VL,2[(0,0,(1,0)Zm+1),0]

This results in:

A(1),R,3=x1i=0p11e(0,0,i·p2)+e(0,0,(1,0)Zm)+b=1(0,1)Zm1Tb,0[R]+j=0p12R0,1+j·(1,0)Zm[R] (A7)

Appendix A.4.4. Reduced Matrix We Will Analyze Directly

Taking I1 to be the set of rows in A(1) that correspond to non-zero rows in A(1),L,1 and I2 corresponding to L, we obtain the following matrix A(2). (The matrix A(2) here corresponds to A(8) in [32]). On Level-1, it has a block structure similar to that of A(1),R (where the number of rows changes in some of the matrices). More concretely, A(2),2 has the form (The correction of the mistake in [32] leads to the changed first block in the last block-row in A(2),2):

graphic file with name entropy-24-00497-i071.jpg

Here, R25, is identical to R25 except that the top mp2+1 rows in it are removed. That is, it is identical to R24, except that the (0,0)th Level-0 block in R24 replaces I by C, which are equal.

graphic file with name entropy-24-00497-i072.jpg

Similarly, R22, is obtained from R22 in the same manner. In this case, only zero rows are removed. A(2),1 is precisely A(1),R,1 (no rows were eliminated from there, as all corresponding rows on the left side became zero). Similarly, A(2),3=A(1),R,3.

Appendix A.5. Completing the Proof—Analysis of A(2)

We are now ready to make our conclusion, assuming p=p1 and p1,p2>2. We stress that further analysis of the matrix is needed for identifying all p’s for which a share conversion exists. In fact, some of the detailed calculations of the resulting matrix structure are not needed for our conclusion, and we could instead identify only the properties that we need of various sub-matrices. However, some of the details may be useful for future analysis, so we made all the calculations.

Our last step is to reduce the matrix A(2) “modulo” the set G: for every row r in A(2) and every Level-0 block in this row, we reduce the contents of that row “modulo” span(Rows(T2)). That is, we complement the basis of Rows(T2) specified in Lemma A1 into a basis of Zpm, where e0 is one of the added vectors and define a linear mapping L taking elements of Rows(T2[I,·]) to zero and other elements of the basis onto themselves (it is inconsequential what the other base elements are). Indeed, observe that e0 is not in span(Rows(T2)), as it is not in Ker(Ker(span(Rows(T2)))), as implied by Lemma A2. To verify this, observe for instance that:

i=0p11(ei·p2e1+i·p2),e0=10.

We apply a linear mapping L taking xspan(Rows(T2)) to 0 and other base elements to themselves. Recall that Level-0 blocks indeed have m columns each. We make the following observations. We let A(3) denote the resulting matrix. (Here, A(3) corresponds to A(9) in [32]).

Observation A1.

The rows of A(3),1 are zero.

Observation A2.

A(3),3 maps to b=1(0,1)Zm1Tb,0[R]+j=0p12R0,1+j·(1,0)Zm[R].

Observation A1 follows easily from the form of the matrix A(2) and Lemmas A1 and A2, which implies that span(Rows(T2)) is exactly the kernel of S from Lemma A2 (this is the reason we need Lemma A2: it is easier to verify that a given vector is not in Ker(span(S)), rather than verifying it is not in span(T2)).

Observation A2 follows by the structure of A(2) and definition of L.

Now, if A(2),3 is spanned by the rest of the rows in A(2), then it must be the case that the same dependence exists in A(3). Thus, it suffices to prove that the latter does not hold. Assume for the sake of contradiction that:

v(A(3),1;A(3),2)=A(3),3

for some vector v. In the following, we use V0 for viewing v as a block vector with Level-0 blocks. Note that unusually for this type of matrix, the blocks in the first row have p21 rows, and in other block row, the cells have m rows, as usual. Similarly, we use V1 to impose Level-1 structure onto v.

By the structure of R22,, we conclude that A(3),2 is of the form (we note that the corrected mistake in [32] does not affect the appearance of A(3),2 as it does apply only to the blocks spanned by the basis of T2. Hence the following consideration is exactly as in the original work of Paskin-Cherniavsky and Schmerler):

graphic file with name entropy-24-00497-i073.jpg

Observe that in A(3),3, non-zero values exist only in Level-1 blocks i=0,1. As there are p2 such blocks and p2>2, by our assumption, we conclude that the last row contributes zero to v(A(3),1;A(3),2), as in the last block, the output needs to be zero, and it equals V[p2]A(3),2, which is the same contribution for all (Level-1) blocks.

To agree with A(3),3 at block i, we must then have v·R25,=e0. Viewing R25, as a block-matrix of Level-0, because of the zeroes at all blocks but Block 0, the contributions of all block-rows but the first one to v·R25, is:

(2+(p12))·V1[p2]=p1·V1[0]=0.

In the above, the last equality is due to the fact that p=p1. Thus, we must have V1[0]·C=e0. However, we observe that Rows(C) is a subset of Ker(span(S)), where S is specified in Lemma A2 and thus cannot equal e0 (which is not in Ker(span(S))).

This concludes the proof of Theorem A1:

Theorem A1.

Assume m=p1·p2, p=p1, and p1,p2>2. Then, there exists a row v in M such that Rows(M) does not span v.

Author Contributions

The authors contributed equally to this work. All authors have read and agreed to the published version of the manuscript.

Funding

This work was supported by ISF grant 152/17 and by the Ariel Cyber Innovation Center in conjunction with the Israel National Cyber directorate in the Prime Minister’s Office.

Institutional Review Board Statement

Not applicable.

Informed Consent Statement

Not applicable.

Conflicts of Interest

The authors declare no conflict of interest. The funders had no role in the design of the study, in the writing of the manuscript, or in the decision to publish the results.

Footnotes

Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

References

  • 1.Chor B., Kushilevitz E., Goldreich O., Sudan M. Private Information Retrieval. J. ACM. 1998;45:965–981. doi: 10.1145/293347.293350. [DOI] [Google Scholar]
  • 2.Angel S., Setty S. Unobservable communication over fully untrusted infrastructure; Proceedings of the 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI 16); Savannah, GA, USA. 2–4 November 2016; pp. 551–569. [Google Scholar]
  • 3.Mittal P., Olumofin F.G., Troncoso C., Borisov N., Goldberg I. PIR-Tor: Scalable Anonymous Communication Using Private Information Retrieval; Proceedings of the 20th USENIX Security Symposium; San Francisco, CA, USA. 8–12 August 2011; p. 31. [Google Scholar]
  • 4.Gupta T., Crooks N., Mulhern W., Setty S., Alvisi L., Walfish M. Scalable and private media consumption with Popcorn; Proceedings of the 13th (USENIX) Symposium on Networked Systems Design and Implementation (NSDI 16); Santa Clara, CA, USA. 16–18 March 2016; pp. 91–107. [Google Scholar]
  • 5.Henry R., Herzberg A., Kate A. Blockchain access privacy: Challenges and directions. IEEE Secur. Priv. 2018;16:38–45. doi: 10.1109/MSP.2018.3111245. [DOI] [Google Scholar]
  • 6.Gentry C., Halevi S., Magri B., Nielsen J.B., Yakoubov S. Random-Index PIR and Applications. Technical Report, Cryptology ePrint Archive, Report 2020/1248. 2020. [(accessed on 19 December 2021)]. Available online: https://eprint.iacr.org.
  • 7.Green M., Ladd W., Miers I. A protocol for privately reporting ad impressions at scale; Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security; Vienna, Austria. 24–28 October 2016; pp. 1591–1601. [Google Scholar]
  • 8.Grissa M., Hamdaoui B., Yavuz A.A. Unleashing the power of multi-server pir for enabling private access to spectrum databases. IEEE Commun. Mag. 2018;56:171–177. doi: 10.1109/MCOM.2018.1701341. [DOI] [Google Scholar]
  • 9.Tan Z., Wang C., Yan C., Zhou M., Jiang C. Protecting privacy of location-based services in road networks. IEEE Trans. Intell. Transp. Syst. 2020;22:6435–6448. doi: 10.1109/TITS.2020.2992232. [DOI] [Google Scholar]
  • 10.Günther D., Holz M., Judkewitz B., Möllering H., Pinkas B., Schneider T. PEM: Privacy-preserving Epidemiological Modeling. [(accessed on 20 December 2021)];Cryptol. ePrint Arch. 2020 Available online: https://eprint.iacr.org/2020/1546. [Google Scholar]
  • 11.Efremenko K. 3-Query Locally Decodable Codes of Subexponential Length. SIAM J. Comput. 2012;41:1694–1703. doi: 10.1137/090772721. [DOI] [Google Scholar]
  • 12.Yekhanin S. Towards 3-query locally decodable codes of subexponential length. J. ACM. 2008;55:1:1–1:16. doi: 10.1145/1326554.1326555. [DOI] [Google Scholar]
  • 13.Beimel A., Ishai Y., Kushilevitz E., Orlov I. Share Conversion and Private Information Retrieval; Proceedings of the 27th Conference on Computational Complexity, CCC 2012; Porto, Portugal. 26–29 June 2012; pp. 258–268. [DOI] [Google Scholar]
  • 14.Dvir Z., Gopi S. 2-Server PIR with Subpolynomial Communication. J. ACM. 2016;63:39:1–39:15. doi: 10.1145/2968443. [DOI] [Google Scholar]
  • 15.Kushilevitz E., Ostrovsky R. Replication is NOT Needed: SINGLE Database, Computationally-Private Information Retrieval; Proceedings of the 38th Annual Symposium on Foundations of Computer Science, FOCS’97; Miami Beach, FL, USA. 19–22 October 1997; pp. 364–373. [DOI] [Google Scholar]
  • 16.Mughees M.H., Chen H., Ren L. OnionPIR: Response Efficient Single-Server PIR; Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security; Virtual, Korea. 15–19 November 2021; pp. 2292–2306. [Google Scholar]
  • 17.Ali A., Lepoint T., Patel S., Raykova M., Schoppmann P., Seth K., Yeo K. Communication–Computation Trade-offs in PIR; Proceedings of the 30th USENIX Security Symposium (USENIX Security 21); Virtual. 11–13 August 2021; pp. 1811–1828. [Google Scholar]
  • 18.Park J., Tibouchi M. European Symposium on Research in Computer Security. Springer; Berlin/Heidelberg, Germany: 2020. SHECS-PIR: Somewhat Homomorphic Encryption-Based Compact and Scalable Private Information Retrieval; pp. 86–106. [Google Scholar]
  • 19.Corrigan-Gibbs H., Kogan D. Annual International Conference on the Theory and Applications of Cryptographic Techniques. Springer; Berlin/Heidelberg, Germany: 2020. Private information retrieval with sublinear online time; pp. 44–75. [Google Scholar]
  • 20.Gilboa N., Ishai Y. Annual International Conference on the Theory and Applications of Cryptographic Techniques. Springer; Berlin/Heidelberg, Germany: 2014. Distributed point functions and their applications; pp. 640–658. [Google Scholar]
  • 21.Beimel A., Ishai Y., Kushilevitz E., Raymond J. Breaking the O(n1/(2k-1)) Barrier for Information-Theoretic Private Information Retrieval; Proceedings of the 43rd Symposium on Foundations of Computer Science (FOCS 2002); Vancouver, BC, Canada. 16–19 November 2002; pp. 261–270. [DOI] [Google Scholar]
  • 22.Ben-Aroya A., Efremenko K., Ta-Shma A. Local list decoding with a constant number of queries; Proceedings of the 2010 IEEE 51st Annual Symposium on Foundations of Computer Science; Las Vegas, NV, USA. 23–26 October 2010; pp. 715–722. [Google Scholar]
  • 23.Chee Y.M., Feng T., Ling S., Wang H., Zhang L.F. Query-efficient locally decodable codes of subexponential length. Comput. Complex. 2013;22:159–189. doi: 10.1007/s00037-011-0017-1. [DOI] [Google Scholar]
  • 24.Dvir Z., Gopalan P., Yekhanin S. Matching Vector Codes. SIAM J. Comput. 2011;40:1154–1178. doi: 10.1137/100804322. [DOI] [Google Scholar]
  • 25.Efremenko K. From irreducible representations to locally decodable codes; Proceedings of the Forty-Fourth Annual ACM Symposium on Theory of Computing; New York, NY, USA. 20–22 May 2012; pp. 327–338. [Google Scholar]
  • 26.Itoh T., Suzuki Y. Improved constructions for query-efficient locally decodable codes of subexponential length. IEICE Trans. Inf. Syst. 2010;93:263–270. doi: 10.1587/transinf.E93.D.263. [DOI] [Google Scholar]
  • 27.Cramer R., Damgård I., Ishai Y. Share Conversion, Pseudorandom Secret-Sharing and Applications to Secure Computation. In: Kilian J., editor. Proceedings of the Theory of Cryptography, Second Theory of Cryptography Conference, TCC 2005; Cambridge, MA, USA. 10–12 February 2005; Berlin/Heidelberg, Germany: Springer; 2005. pp. 342–362. [DOI] [Google Scholar]
  • 28.Vapnik V.N., Chervonenkis A.Y. On the uniform convergence of relative frequencies of events to their probabilities. Theory Probab. Appl. 1971;16:264–280. doi: 10.1137/1116025. [DOI] [Google Scholar]
  • 29.Ben-Or M., Goldwasser S., Wigderson A. Completeness Theorems for Non-Cryptographic Fault-Tolerant Distributed Computation (Extended Abstract). In: Simon J., editor. Proceedings of the 20th Annual ACM Symposium on Theory of Computing; Chicago, IL, USA. 2–4 May 1988; New York, NY, USA: ACM; 1988. pp. 1–10. [DOI] [Google Scholar]
  • 30.Grolmusz V. Superpolynomial size set-systems with restricted intersections mod 6 and explicit Ramsey graphs. Combinatorica. 2000;20:71–86. doi: 10.1007/s004930070032. [DOI] [Google Scholar]
  • 31.Ito M., Saito A., Nishizeki T. Multiple Assignment Scheme for Sharing Secret. Volume 6. Springer; Berlin/Heidelberg, Germany: 1993. pp. 15–20. [Google Scholar]
  • 32.Paskin-Cherniavsky A., Schmerler L. On Share Conversions for Private Information Retrieval. Entropy. 2019;21:826. doi: 10.3390/e21090826. [DOI] [Google Scholar]
  • 33.Beimel A. Secret-Sharing Schemes: A Survey. In: Chee Y.M., Guo Z., Ling S., Shao F., Tang Y., Wang H., Xing C., editors. Coding and Cryptology—Proceedings of the Third International Workshop, IWCC 2011, Qingdao, China, 30 May–3 June 2011. Volume 6639. Springer; Berlin/Heidelberg, Germany: 2011. pp. 11–46. [DOI] [Google Scholar]

Articles from Entropy are provided here courtesy of Multidisciplinary Digital Publishing Institute (MDPI)

RESOURCES