Next Article in Journal
Dynamic Shannon Performance in a Multiobjective Particle Swarm Optimization
Next Article in Special Issue
Evaluating Secrecy Capacity for In-Body Wireless Channels
Previous Article in Journal
Dimensionality, Granularity, and Differential Residual Weighted Entropy
Previous Article in Special Issue
Some New Results on the Gaussian Wiretap Feedback Channel
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

On Share Conversions for Private Information Retrieval

by
Anat Paskin-Cherniavsky
* and
Leora Schmerler
Computer Science Department, Ariel University, Ariel 40700, Israel
*
Author to whom correspondence should be addressed.
Entropy 2019, 21(9), 826; https://doi.org/10.3390/e21090826
Submission received: 10 June 2019 / Revised: 2 August 2019 / Accepted: 6 August 2019 / Published: 23 August 2019
(This article belongs to the Special Issue Information-Theoretic Security II)

Abstract

:
Beimel et al. in CCC 12’ put forward a paradigm for constructing Private Information Retrieval (PIR) schemes, capturing several previous constructions for k 3 servers. A key component in the paradigm, applicable to three-server PIR, 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 Z m to three-additive sharing over Z p β for primes p 1 , p 2 , p where p 1 p 2 and m = p 1 · p 2 . The share conversion is with respect to the modified universal relation C S m . They reduced the question of whether a suitable share conversion exists for a triple ( p 1 , p 2 , p ) to the (in)solvability of a certain linear system over Z p . Assuming a solution exists, they also provided a efficient (in m , log p ) construction of such a sharing scheme. They proved a suitable conversion exists for several triples of small numbers using a computer program; in particular, p = p 1 = 2 , p 2 = 3 yielded the three-server PIR with the best communication complexity at the time. This approach quickly becomes infeasible as the resulting matrix is of size Θ ( m 4 ) . In this work, we prove that the solvability condition holds for an infinite family of ( p 1 , p 2 , p ) ’s, answering an open question of Beimel et al. Concretely, we prove that if p 1 , p 2 > 2 and p = p 1 , then a conversion of the required form exists. We leave the full characterization of such triples, with potential applications to PIR complexity, to future work. Although larger (particularly with m a x ( p 1 , p 2 ) > 3 ) triples do not yield improved three-server PIR communication complexity via BIKO’s construction, a richer family of PIR protocols we obtain by plugging in our share conversions might have useful properties for other applications. Moreover, we hope that the analytic techniques for understanding the relevant matrices we developed would help to understand whether share conversion as above for C S m , where m is a product of more than two (say three) distinct primes, exists. The general BIKO paradigm generalizes to work for such Z m ’s. Furthermore, the linear condition in Beimel et al. generalizes to m’s, which are products of more than two primes, so our hope is somewhat justified. In case such a conversion does exist, plugging it into BIKO’s construction would lead to major improvement to the state of the art of three-server PIR communication complexity (reducing Communication Complexity (CC) in correspondence with certain matching vector families).

1. Introduction

A Private Information Retrieval (PIR) protocol [1] is a protocol that allows a client to retrieve the i th bit in a database, which is held by two or more servers, each holding a copy of the database, without exposing information about i to any single server (assuming the servers do not collaborate). In the protocol specification, the servers do not communication amongst each other. The main complexity measure to optimize in this setting is the communication complexity between client ans servers. In the single-server setting, the Communication Complexity (CC) is provably very high - provably, the whole database needs to be communicated. In the computational setting [2], communication-efficient single-server PIR is essentially solved with essentially optimal CC [3]. In this work, we focus on information theoretic (in fact perfect) PIR protocols. See [4] and the references within for the additional motivation for the study of information theoretic PIR.
All known PIR protocols only use one round of communication (although it is not part of the definition of PIR), so we will only consider this setting. In this setting, the client sends a query to each server and receives an answer in return. PIR is a special case of secure Multi-Party Computation (MPC), which is a very general and useful cryptographic primitive, allowing a number of parties to compute a function f over their inputs while keeping that input private from an adversary that may corrupt certain subsets of the parties (to the extent allowed by knowing the output of f) [5,6]. The PIR setting is useful on its own right, as a minimalistic useful client-server setting of MPC, where the goal is to minimize communication complexity, potentially minimizing the overhead on the client, which may be much weaker than the server.
In [4], the authors proposed the following approach to constructing PIR protocols, which captures some of the previous protocols for three servers or more, and put forward a new three-server PIR protocol, with the best known asymptotic communication complexity to date.
Let us describe their general framework, for a k-server PIR.

1.1. Biko’s Framework for K-Server PIR

The framework uses two key building blocks. One is a pair of k-party linear secret sharing schemes S h 1 , S h 2 over abelian rings G 1 , G 2 , respectively. The pair S h 1 , S h 2 is also equipped with a share conversion scheme from S h 1 , S h 2 with respect to some “useful” relation R G 1 × G 2 . That is, for a value s shared according to S h 1 , the scheme allows locally (performing a computation on each share separately) computing a sharing of a value o according to S h 2 , such that R ( s , o ) holds (note that this is generally non-trivial, as the conversion is performed locally on each share, without knowing anything about the other shares or the randomness used to generate the sharing).
In [4], G 1 , G 2 used small (constant) finite rings. The notion of share conversion employed in [4] generalized [7]’s work on locally converting from the arbitrary linear secret-sharing schemes without changing the secret, by allowing an arbitrary relation between the secrets and by allowing S h 1 , S h 2 to be linear over different rings. The second building block is an encoding of the inputs x { 0 , 1 } n as a longer element u G 1 l . The PIR protocol has the following structure:
  • The client “encodes” the input x { 0 , 1 } n via u G 1 l for a quite large, but not very large l ( n ) from a certain code C G 1 l .
  • Every bit u j is shared via S h 1 . The client sends each share s i , j to server S j .
  • The servers are able to evaluate locally any shallow circuit from a certain set F roughly as follows. At the bottom level, we use the linearity of S h 1 to evaluate a sequence of gates taking linear combinations of the u i ’s over G 1 . Let y denote the resulting shared values vector. Apply the share conversion to the output of each of the y i ’s to obtain a converted vector y of values over G 2 . Finally, locally evaluate some linear combination of the elements y , using the linearity of S h 2 . Each server sends its resulting share to the client. The particular circuit to evaluate is that of an “encoding” f : C G 2 of their database, in turn viewed as a function f : { 0 , 1 } n { 0 , 1 } .
  • The client reconstructs the output value from the obtained shares, using S h 2 ’s reconstruction procedure. It then decodes f ( x ) from f ( u ) (the decoding procedure takes only f ( u ) as input; it does not use x or the client’s randomness).
Note that the “privacy” property of S h 1 takes care of keeping the client’s input private from any single server. It is not known how, and likely impossible, to devise a share conversion scheme for a relation that is sufficiently useful to compute locally all functions f : { 0 , 1 } 1 l { 0 , 1 } following the framework suggested above, in a way that encodes every f : { 0 , 1 } l { 0 , 1 } . Therefore, to encode all functions f : { 0 , 1 } l { 0 , 1 } , BIKOencodes the inputs x and function f : { 0 , 1 } n { 0 , 1 } using a larger parameter l > n . To gain in communication complexity, the code C is carefully chosen so that the resulting family F { f : G 1 l { 0 , 1 } } implemented by the above protocol is as large as possible (relative to l). More precisely, its VCdimension is at least 2 n , allowing one to implement any Boolean function on { 0 , 1 } n . On the other hand, we must be able to match it with a relation R for which a share conversion exists (Recall that the VC dimension captures the ability of a set F of functions f : D { 0 , 1 } to “encode” any function f : { 0 , 1 } n { 0 , 1 } by restriction to a subset I D of size 2 n of values. Here, D is typically larger than { 0 , 1 } n . By Saur’s lemma, the VC dimension is very closely related to the size of the family F .) There is a tradeoff between the share conversions we are able to devise and the complexity of F . The larger F in the above scheme is, the smaller l that can be used for the encoding, and the lower the communication complexity of the resulting PIR protocol. Note that the framework yields constructions where the communication complexity of O ( l ) bits is dominated by the client’s message length and only constant-length server replies. On the other hand, for more complex F , one would need share conversion schemes for “trickier” relations, which are harder to come by.
Only a few families of instantiations of the framework are known, with [4]’s particular instantiation for three-server PIR as one example. Other instantiations are implicit in some previous PIR protocols; see Section 2, or [4] for additional examples and more intuition.

1.1.1. BIKO’s New Family of Three-Server PIR

In their new three-server PIR, the work in [4] instantiated the components of the above framework using a certain (family of) rings G 1 , G 2 , for which suitable encodings and share conversion exist. Details follow. The rings are parameterized by three numbers p 1 , p 2 , p , where p 1 , p 2 are distinct primes. Let us denote m = p 1 · p 1 . The various components are instantiated as follows:
  • S h 1 is the (2,3)-CNF secret sharing scheme for the ring G 1 = Z m , for certain m = p 1 · p 2 , where p 1 , p 2 are distinct primes. S h 2 is the three-additive secret sharing over the ring G 2 = Z p β , for some β N .
  • Let S Z m \ { 0 } . The input x { 0 , 1 } n is encoded as an element u of an S-Matching Vector (MV) C Z m l family of size at least 2 n over Z m [8]. Briefly, for S Z m \ { 0 } , such an S-MV family is a sequence of vectors v 1 , , v L Z m l , where for all i, < v i , v i > = 0 , and for all i j , < v i , v j > S . In particular, [8] demonstrates that an S-MV family of any VC dimension exists for all m = p 1 p 2 where p 1 , p 2 are distinct primes for S as small as S m ; the set of all elements in Z m that are zero or one modulo each of the p i ’s, expect for zero. In particular, the vector’s length for an instance corresponding to VC dimension 2 n is l = 2 O ˜ ( n ) .
  • A share conversion between S h 1 and S h 2 for a relation C S m is obtained for certain triples ( p , p 1 , p 2 ) . Informally, this relation maps S m to zero and zero to some non-zero value in G 2 . This type of share conversion scheme is another novel technical contribution of [4] (and the focus of our work).
The complete BIKO construction is roughly as follows:
  • The client sends an encoding u = u ( x ) of its input x { 0 , 1 } n , which belongs to the the S m MV-family C Z m l (here, l = O ( 2 n l o g ( n ) ) can be achieved). The servers locally evaluate the following circuit:
    C ( u 1 , , u l ) = O R j ( f i · < u j , u > )
    using the following “noisy” procedure:
  • Generate the vector of values ( y i ) f ( i ) = 1 where y i = < u i , u > . This evaluation uses the linearity of CNF and produces a local S h 1 = ( 2 , 3 ) -CNF over the Z m share of each value y i .
  • Apply share conversion from S h 1 to S h 2 as specified above on each y i , obtaining a vector of y i ’s, shared according to S h 2 .
  • Locally evaluate i y i , and then, send ( S h 2 ) shares to the client. The client outputs zero if this value is zero, and one otherwise.
It is not hard to see that the above construction always produces the correct value. In particular, by the definition of C S m , only (the conversion of) < u i , u i > contributes a non-zero value y i to i y i .
Theorem 1 
([4], informal). Assume there exists a share conversion scheme from ( 2 , 3 ) -CNF over G 1 = Z m and three-additive over G 2 = Z p β for some β, where m = p 1 · p 2 is as above. Then, there exists a three-server PIR with communication complexity O ( 2 2 · p 2 n l o g ( n ) ) , where p 2 > p 1 . The best asymptotic communication complexity is obtained by setting m = 6 , p = 2 , using [8]’s S m -MV family over G 1 l over Z 6 with l = 2 O ˜ ( n ) and a share conversion with respect to C S m for p 1 = p = β = 2 , p 2 = 3 . In particular, the servers’ messages are of length O ( 1 ) .
Intuitively, having S-MV families for a “small” S as above facilitates the construction of share conversion schemes as we needed for C S , since a small S imposes fewer constraints on the pairs ( s , s ) in the relation.
To conclude, it follows from Theorem 1 that to obtain three-server PIR with sub-polynomial (in database size) CC, it suffices to design a share conversion for C S m from S h 1 to S h 2 over groups G 1 , G 2 corresponding to any triple of parameters p 1 , p 2 , p as described above. Another useful contribution of [4] is reducing the question of whether such a conversion exists (for some β ) to a system of equations and inequalities over F p ; see the following sections for more details on the usefulness of this characterization (a solution to the system corresponds to the share conversion scheme).

1.1.2. On the Choice of Input and Output Schemes

In retrospect, trying to convert from CNF to additive is a natural choice. For once, the CNF scheme is known as the most redundant secret sharing scheme and additive is the least redundant one [7]. More specifically, CNF sharing is convertible to any other linear scheme over the same field for the same access structure, or one contained it with respect to the identity relation. This implies that for any relation, if share conversion between two linear schemes exists for that relation, it must exist for CNF to additive. Here the more standard linearity over fields is considered, and the same field us used for both schemes. Still, for the more general notion of linearity over rings, and allowing different rings for the two schemes, this still provides quite strong evidence that starting with CNF, and trying to convert to additive is a good starting point. As to the choice of the structure of the particular G 1 , G 2 over which the conversion is defined, following are some of [4]’s considerations for their choice. One observation is that trying to convert from, say, Z m to Z p would require finding a solution to a system of inequalities over Z p for a fixed p. This problem is generally NP-complete, which is likely to make the problem hard to analyze, even in this special case. Thus, the authors extend the search to allow conversion to three-additive over some extension field F p β . As β is constant, it does not have much effect on the share complexity of the resulting PIR protocol.
Using composite sizes for both G 1 = Z m and G 2 = Z m would lead to a greatly improved VC dimension of F , with respect to the canonical relation C S , where S = Z m \ { 0 } . In fact, the F = + Z m ( m o d m ) that can be locally evaluated over Z m l is universal, resulting in near-optimal O ( log ( n ) ) communication complexity. However, [4] have proven this type of conversion does not exist, indicating that C S for smaller S for such G 1 , G 2 could also be hard to find.

1.2. Our Contribution

As described above, the contribution of [4] was two-fold. First, they put forward a useful framework for designing PIR protocols, capturing some of the best-known three-server (or more) PIR protocols. Second, they put forward an instantiation of the framework, which reduces the question of the existence of a three-server PIR protocol to the existence of a share conversion for certain parameters p 1 , p 2 , p and certain linear sharing schemes over abelian rings G 1 , G 2 determined by the parameters. They further reduced the question of the existence of a share conversion as above for parameters p 1 , p 2 , p to the question of whether a corresponding system of linear equations is solvable over Z p . This system in turn is not solvable over some extension field F p β iff a certain system of both equalities and inequalities over Z p is solvable over some field F p β .
While the solvability of a system A x = b can be verified efficiently for a concrete instance, it does not provide a simple condition for characterizing triples ( p , p 1 , p 2 ) for which solutions exist. More concretely, even the question of whether an infinite set of such triples exists remains open. We resolve this question in the affirmative, proving the following.
Theorem 2.
Let 2 < p 1 , p 2 where p 1 p 2 are primes. Then, a share conversion from ( 2 , 3 ) -CNF over Z p 1 p 2 to three-additive over Z p 1 β exists for some β > 0 .
In a nutshell, our goal is to study the solvability of the particular system A x = b from [4] corresponding to a given p , p 1 , p 2 . Our main tool is a clever form of elimination operations on the (particular) matrix ( A ; b ) , so that at each step, the intermediate system A x = b is solvable iff A x = b is. The special type of elimination we develop is useful here as it allows keeping our particular system relatively simple at every step. This is as opposed to using standard Gaussian elimination, for instance, which would have made the resulting system quite messy. The operations are largely oblivious of the particular value of p 1 , p 2 , p until a very late point in the game. The proof consists of a series of a (small) number of our elimination steps. On a high level, we perform a few such steps. At this point, the matrix becomes quite complicated (at the end of Section 4.2). Then, we perform a change of basis (Section 4.5) to facilitate another convenient application of the step. At this point, we are ready to complete the proof by directly proving that the system is not solvable (and thus, a share conversion exists).

1.2.1. On the Potential Usefulness of Our Result for PIR

In this work, we identified a certain infinite set of parameters ( p 1 , p 2 , p ) for which a share conversion as required in Theorem 1 exists. This result itself does not appear to yield improved three-server PIR protocols by instantiating the share conversion with the newly-found parameters via Theorem 1. Indeed, increasing p 2 beyond the minimal possible p 2 = 3 (which was already known) does not seem to help. However, Theorem 1 generalizes to m’s, which are products of a larger number of primes. If a share conversion for G 1 = Z m , G 2 = Z p β derived from such m = p 1 · p 2 · p 3 , p exists, it can be paired with an S m -MV family (which is also known to exist from [8]) with significantly improved (over m a product of two primes) VC dimension, to obtain an improved three-server PIR seamlessly. Specifically for m = p 1 · · p r , an S m MV family with VC dimension 2 n in Z m l for e x p ( O ˜ ( l o g 1 / r ( n ) ) ) exists.
Therefore, it remains to design a corresponding share conversion scheme (or prove it impossible to rule out this direction). Furthermore, the linear algebraic characterization of the existence of such sharing schemes remains the same. Therefore, hopefully, the analytic techniques we developed here for the the case where m is a product of two primes that could help understand the case of a larger number of primes.

1.2.2. Road Map

In Section 2, we refer to some related work on PIR. In Section 3, we include some of the terminology and preliminary results from [4], which is our starting point. In Section 4, we present our main result, which is broken into subsections as follows. As explained above, we start with the reduction of the problem by [4] to verify whether a certain matrix-vector pair ( A , b ) , R o w s ( A ) spans b. We perform a series of elimination steps on the matrix ( A | b ) to bring it to a simpler form ( A , b ) so that R o w s ( A ) spans b iff R o w s ( A ) spans b. All elimination steps are of the same general form. Section 4.1 formalizes this form as a certain lemma. Section 4.2 outlines an initial sequence of applications of that lemma. In Section 4.5, we perform a change of basis to help facilitate further use of the lemma. In Section 4.6, we indeed apply the lemma once again. Finally, in Section 4.7, we obtain a simple enough matrix ( A | b ) for which we are able to prove A spans b directly for the proper choice of parameters, proving our positive result.

2. Related Work

2.1. Schemes with Polynomial CC

As stated in the Introduction, our work is a followup on a particular approach to constructing PIR protocols [1], focusing on k = 3 servers (almost the hardest case). We will survey some of the most relevant prior works on PIR (omitting numerous others). Already in [1], the authors suggested a non-trivial solution to the hardest two-server case, with communication complexity O ( 2 n / 3 ) , and more generally, O ( 2 n k ) for k 3 servers. Building on a series of prior improvements, the work in [9] put forward protocols with CC 2 O ( n · l o g l o g k k l o g k ) for large k. Their result also improved upon the state-of-the-art at the time for small values of k, in particular achieving CC of O ( 2 4 n / 21 ) for k = 3 , improving upon the best previously-known CC of O ( 2 n / 5 ) .

Work Falling in the Framework on BIKO

In [9], they restated some of the previous results in a more arithmetic language, in terms of polynomials. Furthermore, they considered a certain encoding of the inputs and element-wise secret sharing the encoding, which is somewhat close to the BIKO framework.
Particularly interesting for our purposes is their presentation of a “toy” protocol achieving CC of O ( 2 n / 2 ) from earlier literature reformulated in [9], which constituted one of the building blocks of the construction of [9]. That protocol was almost an instance of the BIKO framework as sketched in the Introduction, and it is instructive to consider the differences (the full-fledged result of [9] used additional ideas, and we will not go over it here for the sake of simplicity).
  • The client “encodes” its input x { 0 , 1 } n via u F 2 l where l 2 n / 2 by mapping the input to a vector with exactly two ones and zeroes elsewhere.
  • Every bit u j is shared via S h 1 , which is ( 2 , 3 ) -CNF over F 2 .
  • The servers represent their database as a degree-two polynomial in F [ x 1 , , x l ] (where all monomials are of degree exactly two). To evaluate a polynomial:
    f ( x ) = i < j l a i , j x i x j
    proceed as follows:
    (a)
    At the bottom level, perform a two-to-one share conversion for evaluating each monomial, where the output for gate x i x j is a three-additive sharing of the result x i x j . In some more detail, let x i , 1 + x i , 2 + x i , 3 denote the additive shares produced in Step 1 of the CNF-sharing. The computation is made possible since ( x i , 1 + x i , 2 + x i , 3 ) · ( x j , 1 + x j , 2 + x j , 3 ) , which needs to be computed; for every share-monomial x i , k x k , d , at least one of the servers does not miss any shares in it. Each server outputs the sum of the monomials it knows as its new share.
    (b)
    Using the linearity of the three-additive scheme, the servers compute a three-additive sharing f ( x ) , based on the shares of the individual monomial evaluations y i .
    Each server sends its resulting share to the client.
  • The client reconstructs the output value from the obtained shares, as in BIKO.
This framework differs from BIKO in a few ways. First, the structure of the circuit locally evaluated is different. In the above example, “many-to-one” rather than “one-to-one” secret sharing is used at the bottom level. Then, the linearity of S h 2 is employed on the upper level. In BIKO, first, the linearity of S h 1 is used to evaluate a vector of linear combinations, then a one-to-one share conversion from S h 1 is used at the middle level, then again, the linearity of S h 2 is used at the top gate. Besides the different structure of the circuit, using many-to-one share conversion is the main conceptual change. It employs the extra property of ( 2 , 3 ) -CNF, which allows it to evaluate degree-two polynomials, rather than just linear functions. In the evaluation process, the output is already converted to the less redundant three-additive sharing. The relation the share conversion respects is just the evaluation of the monomial: R ( o , x 1 , x 2 ) iff o = x 1 x 2 . Conceptually, local evaluation of linear functions as used in BIKO is in fact already a many-to-one share conversion from a linear scheme to itself, evaluating a relation R ( x 1 , , x l , o ) , which is satisfied iff o = ( x 1 , , x l ) for a certain linear function .

2.2. Schemes with Sub-Polynomial CC

The first three-server PIR protocol with (unconditionally) sub-polynomial (in 2 n ) CC was put forward by [10]. It falls precisely into BIKO’s framework, using a share conversion from the so-called ( 2 , 3 ) -modified Shamir secret over G 1 = Z m for m = p 1 · p 2 where p 1 p 2 are odd primes to three-additive over the field G 2 = F p β where p is some prime, such that m divides | G 2 * | = p β 1 .
To get to three, rather than four servers, some additional properties of G 1 , G 2 were in fact required. The share conversion is with respect to the relation C S m (actually, a slightly stricter relation, even). Concretely, the work in [10] found an example of such groups G 1 , G 2 as above obtained from m = 7 · 73 = 511 , p = 2 , β = 9 , having an additional useful property, which allowed going down from four to three servers via computer-aided search. We note that a share conversion from ( 2 , 3 ) -CNF to three-additive over that pair of groups also exists since ( 2 , 3 ) -CNF can be converted to any linear scheme for an access structure containing a two-threshold (including modified ( 2 , 3 ) -Shamir) [7].
The encoding used is via a S m -MV family over Z m , as in [4]. The evaluation points in the Shamir scheme used are tailored to S m in the corresponding MV family. It achieves a CC of O ( 2 146 n log ( n ) ) , later improved to O ( 2 6 n log ( n ) ) by BIKO’s construction.
Qualitatively, the result of [10], preceded by [11] in terms of using a similar idea, and most later constructions greatly improved the CC relative to earlier constructions such as [9] by using MV-codes rather than low-degree polynomial codes. The former codes had a surprisingly large rate. Indeed, looking at MV-families from the perspective of [12], these are also polynomial codes, over a basis of monomials corresponding to an MV family, rather than low-degree monomials.
All the above examples generalize to larger k, with somewhat improved complexity; we focused on the (hardest) k = 3 here for simplicity.
Two-Server PIR
In a breakthrough result, the work in [13] matched the CC of two-server PIR with the CC of the best-known three-server PIR, improving from the best previously-known 2 n / 3 to 2 O ( n l o g ( n ) ) . Their work cleverly combined and extended several non-trivial ideas, both new and ones that appeared in previous work in some form. In a nutshell, one idea is to encode inputs via MV codes, where the operations on the vectors are done “in the exponent”, resulting in a variant of MV codes as polynomials, as defined in [12] and implicitly used in [10]. Another idea is to output both evaluations of these “exponentiated” polynomials and the vector of their partial derivatives, to yield more information to facilitate reconstruction given only two servers.
As for casting their result into the BIKO framework(we believe it is a meaningful generalization thereof, as we describe below):
  • The client encodes its input x { 0 , 1 } n via a vector u = u ( x ) in an S 6 -MV family C Z 6 l (with l about 2 O ˜ ( n ) as explained above).
  • Every bit u j is shared via S h 1 , which is the ( 2 , 2 ) -modified Shamir scheme over Z m . The evaluation points are zero and one. We note that the choice of m is not as constrained as in the construction of [10], and many other pairs would work as well. This holds as the purpose of the polynomial involved is somewhat different.
  • Let R 6 , 6 denote the ring Z 6 [ z ] / ( z 6 1 ) . Let γ = z , which has multiplicative degree six in R 6 , 6 . The servers are able to evaluate locally the encoded database:
    F ( x 1 , , x l ) = i [ 2 n ] a i x u i
    roughly as follows:
    (a)
    At the bottom level, use the linearity of S h 1 to evaluate locally each y i = < u i , x > .
    (b)
    Convert each of the y i ’s into a ( 2 , 2 ) -sharing scheme S h 2 over a ring G 2 = R 6 , 6 Ω ( l ) , obtaining a vector of y i ’s. The conversion is a many-to-one conversion with respect to a relation R over the entire input vector, the current y i and y i , so that R ( x 1 , , x 2 n , y i , y i ) that outputs C S 6 ( y i , y i ) if ( x 1 , , x 2 n ) is in C , and otherwise undefined.
    (c)
    Use the “almost linearity” of S h 2 over our particular subset of values to evaluate i a i y i . Here. “almost linearity” means that to evaluate a sum of shared secrets, we add some of the coordinates and copy other coordinates.
  • The client reconstructs the output value from the obtained shares, according to S h 2 (the reconstruction function is of degree-two.) In a nutshell, the coefficient a x is the only one determining the free coefficient of a degree-six univariate polynomial obtained from restricting F to the line z + u t , where z is a random vector. The reconstruction procedure uses the shared evaluations as derivatives to compute this free coefficient, which is non-zero iff a x is one. In the original protocol description of [13], the client used the input for reconstructing the output, which is not consistent with share conversion, where the input is not required for reconstruction. We restate the above protocol by letting the servers “play back” the original shares to the client to stay consistent with the BIKO share conversion framework.
To summarize, the construction falls into an extended BIKO framework, where the middle-layer share conversions are many-to-one rather than one-to-one. Furthermore, the scheme S h 2 is non-linear and is defined over a non-constant domain. It is important to observe that the relations used for the conversions are independent of the database function F itself, but only depend on its size. The locally-evaluated relations are as small as O ( 2 n ) , similarly to BIKO. One potential difficulty with using such an extended design framework is in verifying whether a many-to-one share conversion exists, or even one-to-one for a large share domain of S h 2 , as we have here.
One question that remains open in the two-server setting is to make the server’s output size constant as in [4,10] for three servers.

3. Preliminaries

3.1. Secret Sharing Schemes

For a set A [ n ] and sequence of shares s = ( s 1 , , s n ) , we denote s [ A ] by the sequence of shares ( s i ) i A . A secret sharing scheme for n parties implements an access structure specified by a monotone function f : { 0 , 1 } n { 0 , 1 } specifying the so-called qualified sets of parties that recover the secret (preimages of one), while other sets learn nothing about the secret (in this paper, we consider the standard perfect setting). We refer to such a scheme as an n-party secret sharing scheme. More formally, an n-party secret sharing scheme is a randomized mapping:
S h : S × R S 1 × × S n
where S is a finite domain of secrets and R is a randomness set, while S 1 , , S n are finite share domains such that the following holds:
  • Correctness: For all A [ n ] with f ( A ) = 1 , referred to as qualified sets, and all s 1 s 2 S , we have:
    s u p p o r t ( S h r R ( s 1 , r ) [ A ] ) s u p p o r t ( S h r R ( s 2 , r ) [ A ] ) = ϕ
    We use sets and their characteristic vectors interchangeably.
  • Privacy: For all A [ n ] with f ( A ) = 0 and all s 1 s 2 S , the following distributions are equal.
    S h r R ( s 1 , r ) [ A ] ) = ( S h r R ( s 2 , r ) [ A ] )
Access structures where the set of qualified subsets is exactly those of size some t or more, are called threshold access structures.
We say that a secret sharing scheme is linear over some ring G, generalizing the standard notion of linearity over a field, if S = G , R = G l for some l N for some finite Abelian ring G. Each share consists of one or more linear functions for the form l ( s , r 1 , , r m ) = α 0 · s + i α i · r i (Observe that unlike linear schemes over a field, such a scheme does not always have perfect correctness for all secrets s R , but this is not required in our context. We will require perfect privacy though.) A useful property of such schemes is that they allow evaluating locally linear functions of the shares. That is, for a pair of sharings s 1 = ( s 1 1 , , s n 1 ) s 2 = ( s 1 2 , , s n 2 ) of some s 1 , s 2 , respectively, s 1 + s 2 (performing addition coordinate-wise on each group element in the share vector) is a sharing of s 1 + s 2 . Similarly, for a G , a · s 1 is sharing of a · s 1 .
See [14] for a survey on secret sharing.
Let us recall the well-known schemes ( 2 , 3 ) -CNF and 3-additive for completeness. The schemes are more general, ( 2 , 3 ) -CNF is a special case of ( t , n ) -CNF and 3-additive is a special case of ( t , n ) -DNF with t = n = 3 . Here we explicitly recall the definitions only of the special cases we need.
A 3-additive secret sharing scheme over a ring G is a randomized mapping f A D D : S × R S 1 × S 2 × S 3 , where S = S i = G , R = G 2 , such that f A D D ( s ; a 1 , a 2 ) = ( a 1 , a 2 , s a 1 a 2 ) . It is not hard to see that f A D D indeed implements an access structure where only the set { 1 , 2 , 3 } is qualified.
A ( 2 , 3 ) -CNF over a ring G is defined by a randomized mapping f C N F : S × R G 3 for S = G , S i = R = G × G . It is defined as follows f C N F ( s ; a 1 , a 2 ) :
  • Calculate a three-additive sharing ( a , b , c ) = f A D D ( s ; a 1 , a 2 ) .
  • Output shares ( s 1 , s 2 , s 3 ) where s i equals the two elements from the tuple in one, which are not at its index. For example, s 3 = ( a , b ) .
It is not hard to see that ( 2 , 3 ) -CNF is indeed a 2-threshold scheme. It is also not hard to see that the above schemes are linear over their respective rings.
A ( 2 , n ) -modified Shamir scheme over a ring G is defined by a randomized mapping f S h ( s ; z ) : G × G G outputs shares ( s 1 , , s n ) s i = z + s x i , where x i G is a distinct constant ‘evaluation point’.
It is not hard to see that ( 2 , 3 ) -CNF is indeed a two-threshold scheme. It is also not hard to see that the above schemes are linear over their respective rings.

3.2. Share Conversion

We recall the definition of (generalized) share conversion schemes as considered in our paper. Our definition is exactly the definition in [4], in turn adopted from previous work.
Definition 1 
([4]). Let L 1 and L 2 be two n-party secret-sharing schemes over the domains of secrets K 1 and K 2 , respectively, and let C K 1 × K 2 be a relation such that, for every a A 1 , there exists at least one b K 2 such that ( a , b ) C . A share conversion scheme c o n v e r t ( s 1 , , s n ) from L 1 to L 2 with respect to relation C is specified by (deterministic) local conversion functions g 1 , , g n such that: If ( s 1 , s n ) is a valid sharing for some secret s in L 1 , then g 1 ( s 1 ) , g n ( s n ) is a valid sharing for some secret s in L 2 such that ( s , s ) C .
(In [4], they referred to such share conversion schemes as “local” share conversion. As this is the only type we consider here, we will refer to it as simply “share conversion”.)
For a pair of Abelian groups G 1 , G 2 (when G 1 , G 2 are rings, we consider G 1 , G 2 as groups with respect to the + operation of the rings), we define the relation C S as in [4] ( G 1 , G 2 will be clear from the context, so we exclude the groups from the definition of C S to simplify notation).
Definition 2 
(The relation CS [4]). Let G 1 and G 2 be finite Abelian groups, and let S G 2 \ { 0 } (when G 1 , G 2 are rings, we will by default refer to the additive groups of the rings in this context). The relation C S converts s = 0 G 1 to any nonzero s G 2 and every s S to s = 0 . There is no requirement when s S 0 . Formally,
C S = { ( s , 0 ) | s S } { ( 0 , s ) : s G 2 \ { 0 } } { ( s , s ) | s S { 0 } , s G 2 }
Given m = p 1 · p 2 , where p 1 p 2 are primes and p is a prime, we consider pairs of rings G 1 = Z m , G 2 = Z p β . We denote S m = { x G 1 | i [ 2 ] , x mod p i { 0 , 1 } } \ { 0 } .

3.3. Our Starting Point: The Modeling of [4]

In this work, we study the existence of share conversions for three parties with respect to the canonical relation C G 1 , G 2 as above, from ( 2 , 3 ) -CNF to three-additive for various parameters p 1 , p 2 , p .
Our starting point is the characterization from [4] of triples ( p 1 , p 2 , p ) for which a share conversion with respect to ( G 1 , G 2 ) as above exists via a linear-algebraic constraint.
In some more detail, consider ( p 1 , p 2 , p ) as above. A share conversion from ( 2 , 3 ) -CNF to three-additive exists for S m iff a certain condition is satisfied by the following matrix M , over Z p .
In the matrix M , , the rows are indexed by triples ( a , b , c ) Z m 3 , corresponding to ( 2 , 3 ) -CNF sharings of some s S { 0 } . Namely, ( a , b , c ) are the (additive) shares generated by f C N F in Step 1. The rows corresponding to s 0 form M . The rows corresponding to s = 0 form M . The columns of M , are indexed by values in [ 3 ] × Z m × Z m . Intuitively, an index ( i , x , y ) of a column corresponds to share s i of the ( 2 , 3 ) -CNF scheme being equal to ( x , y ) . Row ( a , b , c ) has ones at three locations: ( 3 , a , b ) , ( 2 , a , c ) , ( 1 , b , c ) , and zeros elsewhere. That is, there are zeros at columns corresponding to the shares s i output by f C N F corresponding to ( a , b , c ) produced in Step 1 of f C N F ’s execution.
We are searching for a vector u that by multiplying it with each row of the “equality rows” of the matrix, it will be equal zero, and by multiplying it with one of the inequality rows, it will not be equal to zero.
The solution vector u (and thus, the columns of the matrix) is indexed by [ 3 ] × Z m × Z m . The index of an entry ( i , x , y ) corresponds to a CNF-share s i that equals ( x , y ) , and the value u ( i , x , y ) at this index is the value in F b β to which share s i = ( x , y ) is converted.
Indeed, it is not hard to see that a share conversion scheme exists iff a solution x F p β to the system:
M x = 0 M x 0
exists.
Some basic linear-algebraic observations imply that the above is equivalent to the fact that the rows of M do not span some row of M over F p (this simplification matters, as it does not require us to know β in advance, if it exists).
Furthermore, the work in [4] provided a quantitative lower bound on β , depending on the degree difference between M and M (the latter is not significant towards our goal of just understanding feasibility). Their characterization is summarized in the following theorem.
Theorem 3 
(Theorem 4.5 [4]). Let β = r a n k F p ( M , ) ) r a n k F p ( M ) ) > 0 . Then, we have:
  • If β = 0 , then there is no conversion from ( 2 , 3 ) -CNF sharing over Z m to additive sharing over Z p κ with respect to C S m , for every κ > 0 .
  • If β > 0 , then there is a conversion from ( 2 , 3 ) -CNF sharing over Z m to additive sharing over Z p β with respect to C S m .
    Furthermore, in this case, every row v of M is not spanned by the rows of M .
Moreover, it was proven in [4] that the above is in fact equivalent to having the rows of M not span any row of M . The latter simplification is a result of certain symmetry existing for the particular relation and secret sharing schemes in question.
Corollary 1.
For every row v of M , v is not spanned by the rows of M iff there exists some β > 0 for which a conversion from ( 2 , 3 ) -CNF sharing over Z m to additive sharing over Z p β with respect to C S m exists.
Theorem 3 provides a full characterization via a condition that given ( p 1 , p 2 , p ) can be verified in polynomial time in ( p 1 , p 2 , log ( p ) ) . More precisely, the size of our matrix M , is 4 m 2 × 3 m 2 (in fact slightly smaller, at ( 3 m 2 + 1 ) × 3 m 2 , if working with Corollary 1, but this is insignificant), so verifying the condition amounts to solving a set of linear equations, which naively takes about O ( m 6 ) time, or slightly better using improved algorithms for matrix multiplication, and the running time cannot be better than Ω ˜ ( m 4 ) using generic matrix multiplication algorithms. Thus, the complexity of verification grows very fast with m, becoming essentially infeasible for p 1 , p 2 circa 50.
In any case, direct verification of the condition on concrete inputs does not answer the following fundamental question.
Question 1 (Informal).
Do there exist infinitely many triples ( p 1 , p 2 , p ) for which a share conversion scheme from ( 2 , 3 ) -CNF to three-additive secret sharing (with parameters as discussed above) exists?
It was conjectured in [4] that all tuples where p = p 1 and p 1 , p 2 , p are all odd allow for such a sharing scheme. We answer this question in the affirmative. While it is not clear that our result may be directly useful towards constructing better PIR schemes, our work is a first step towards possibly improving PIR complexity using this direction, in terms of the tools developed. See the discussion in Section 5 for more details.
To resolve this question, we develop an analytic understanding of the condition for the particular type of matrices at hand. Our goal is to simplify the matrices into a more human-understandable form, so we are able to verify directly the linear-algebraic condition for infinitely many parameter triples.

3.4. Some Notation

In this paper, we will consider matrices over some field F , typically over a finite field F = Z p . For matrices A , B with the same number of columns, ( A ; B ) denotes the matrix comprised by concatenating B below A. For matrices A , B with the same number of rows, we denote by ( A | B ) the matrix obtained by concatenating B to the right of A. For entry i , j of a matrix A, we use the standard notation of A [ i , j ] . More generally, for a matrix A F u × v , for subsets R [ v ] of rows and C [ u ] of columns, A [ R , C ] denotes the sub-matrix with rows restricted to R and columns restricted to C (ordered in the original order of rows and columns in A). 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 ] ).
We often consider imposing a block structure upon a matrix A. The block structure is specified by a grid defined by a partition of the columns into non-empty sets of consecutive columns C 1 , , C t and a partition of the rows into non-empty sets of consecutive rows R 1 , , R h . The matrix A viewed as a block matrix is not a t × h matrix where entry ( i , j ) is the sub-matrix A [ C i , R i ] . We denote the block matrix obtained from A by V (for instance, a matrix named A ( 3 ) is replaced by V ( 3 ) ). In a block matrix V, we typically index the matrix by subscripts: V i , j denotes (the matrix at) entry i , j of V. For instance, V i , j [ i , k ] denotes entry [ i , k ] in (sub)matrix V i , j .
Typically, the C i ’s and the R i ’s are of the same size, and C 0 , R 0 start at zero. Sometimes, the sets will not be of the same size (typically, the first or last set will be of a different size than the rest). Furthermore, most generally, C 0 , R 0 may start elsewhere. Additionally, the indices may be consecutive modulo u (v), so one of the sets C i ( R i ) may not consist of truly consecutive indices.
Most of the time, index arithmetic will be done modulo the matrices’ number of rows and columns (we will however state this explicitly).

4. Our Result

4.1. Starting Point and Main Technical Tool

Starting off with Corollary 1, it suffices to prove the following theorem.
We prove the following result.
Theorem 4.
Assume m = p 1 · p 2 , p = p 1 , and p 1 , p 2 > 2 . Then, there exists a row v in M such that R o w s ( M ) does not span v.
As a corollary from Corollary 1 and Theorem 4, we immediately obtain:
Corollary 2.
Assume m = p 1 · p 2 , p = p 1 , and p 1 , p 2 > 2 . Then, there exists some β > 0 for which a conversion from ( 2 , 3 ) -CNF sharing over Z m to additive sharing over Z p β with respect to C S m exists.
To prove Theorem 4, we choose any vector v in the M , , outside of M , and prove that M does not span v. The particular choice of v we will make is a somewhat convenient choice, but any v will do, so we will fix it later. To this end, we apply carefully-chosen row operations, but in a specific way, so we (as humans) can understand the matrices that result.
Our main technical tool is the following simple lemma.
Lemma 1.
Let A denote a matrix in Z p v × u , and let b = A [ v , [ u ] ] . Let I 1 [ v 1 ] , I 2 [ u ] denote non-empty sets of rows and columns, respectively. A obtained from A by a sequence of row operations on A, so that A [ I 1 , I 2 ] is a basis of A [ [ v ] , I 2 ] , and the rest of the rows in A [ I 1 , I 2 ] are zero. Then, R o w s ( A [ [ v ] \ I 1 , [ u ] \ I 2 ] ) span b [ [ u ] \ I 2 ] iff R o w s ( A [ [ v 1 ] , [ u ] ] ) span A [ v , [ u ] ] .
The proof of the Lemma follows by the fact that any solution to x A [ [ v 1 ] , [ u ] ] = A [ v , [ u ] ] must have zero at indices corresponding to I 1 , to obtain zero at the coordinates corresponding to v 2 (and the fact that row operations on [ A ; b ] do not change the solvability of a system A x = b ).
We start with M = [ M ; v ] and need to resolve the question of whether R o w s ( M ) span v. On a high level, we proceed by applying the following lemma several times, thereby reducing the problem to considering a certain submatrix of the original matrix.

4.2. A Few Initial Elimination Sequences

4.2.1. Elimination Step 0

We introduce some more notation we will use along the way. We think of the matrix M , as divided into blocks of 4 × 3 . We denote constants by capital letters (e.g., a secret value S 1 , or index ( A , B ) ) and running indices by small letters, typically a , b , c . Row 1 of the block matrix V, V i , · is indexed inside by ( a , b , c ) , going over all ( a , b , c ) that constitute an additive sharing of S 1 = ( 0 , 1 ) Z m . Here, ( 0 , 1 ) Z m denotes a single element of Z m , corresponding to its residues modulo p 1 and p 2 , respectively. We omit the Z m subscript when it is clear from the context whether a pair ( x , y ) is in Z m or in Z m . Similarly, rows V 2 , · , V 3 , · , V 4 , · correspond to S 2 = ( 1 , 0 ) Z m , S 3 = ( 1 , 1 ) Z m , S 4 = ( 0 , 0 ) Z m , respectively. The rows inside rows 1 , 2 , 3 in the block matrix are internally indexed by ( a , b ) (c is determined by a , b , S i as S i a b ), where the ( a , b ) ’s are ordered lexicographically (we stress that the particular order is not important for analyzing the rank of the matrix, but it will play some role in creating a matrix that “looks simple” and is easier to understand). The last block is indexed by some ( A , B ) Z m × Z m to be chosen later; as follows from Corollary 1, any ( A , B ) can be chosen.
Column V · , 1 in the block matrix is internally indexed by the CNF-share ( a , b ) received by P 3 . Column V · , 2 is indexed by ( a , c ) (share received by P 2 ), and V · , 3 is indexed by ( b , c ) (share received by P 3 ). As in the case of rows, the values ( x , y ) Z m internally indexing a column of V are ordered lexicographically.
Pictorially, the matrix M , has the following general form.
Entropy 21 00826 i001
In the above, I denotes the identity matrix, and each V i , 1 indeed equals I. The other V i , j ’s for j { 2 , 3 } are m 2 × m 2 permutation matrices, and e x , y Z p m × n denotes a row vector with one at index ( x , y ) , and zeroes elsewhere.
For a fixed i [ 3 ] , row ( a , b ) equals ( e a , b , e a , S i a b , e b , S i a b ) for Block Columns 1 , 2 , 3 respectively.
Next, we apply Lemma 1 to A = M with I 1 = [ m ] , and I 2 = [ m 2 ] ( I 2 corresponds to the first column in the block). The sequence of operations to b-zero the columns in A [ [ 3 m 2 + 1 ] , [ m 2 ] ] is carried out by subtracting from each row e a , b (indexed by ( a , b ) ) in Blocks 2 , 3 , 4 the corresponding row e a , b (indexed by ( a , b ) ) in Block 1. The resulting matrix A (of size ( 2 m 2 + 1 ) × 2 m 2 ) is described in the following.

4.2.2. Elimination Step 1

We view the matrix A as a block matrix with the same subdivision into blocks as in M (with one less block in both rows and columns, with Row 1 and Column 1 removed). Let V denote the corresponding 3 × 2 block matrix.
Consider the row indexed by ( a , b ) in V i , · for i [ 3 ] (corresponds to Block Rows 2 , 3 , 4 respectively in M ). We have:
Observation 1.
The row V i , · indexed by ( a , b ) - V i , · [ ( a , b ) , · ] equals:
( e a , S i a b e a , S 1 a b ; e b , S i a b e b , S 1 a b )
Here, ( a , b ) = ( A , B ) for i = 3 .
The resulting matrix A is depicted next.
Entropy 21 00826 i002
Next, we find a basis for R o w s ( A [ I 1 , [ m 2 ] ] ) and apply Lemma 1 again, “getting rid” of the first block column in A . For i { 1 , 2 , 3 , 4 } , let Δ i , j = S i S j .
We will need another simple observation.
Observation 2.
The rows of V i , 1 for i [ 1 , 2 ] are a permutation of the sequence of all m 2 vectors of the form ( x , y ) ( x , y + Δ 1 , i + 1 ) . Additionally, Δ 1 , 2 = ( 1 , 1 ) Z m , and therefore, ( 1 , 1 ) Z m generates Z m .
We are now ready to demonstrate that the set of rows of V 1 , 1 , according to the coordinate of one in their row: B = { ( a , b ) | c = S 2 a b m 1 } constitutes the basis of V · , I 2 for I 2 = [ m 2 ] , as we seek. Therefore, we will again be able to apply Lemma 1. The other rows are spanned by this set, in one of two ways. We classify them into two types according to these ways. We refer to them as Type 1 and Type 2.
Type 1 constitutes of rows in V 1 , 1 indexed by ( a , b ) with c = S 2 a b = m 1 , for which the location of the ‘1’ in V 1 , 1 [ ( a , b ) , · ] is ( a , c ) for c as above. We observe that every such row is spanned by V 1 , 1 [ B , · ] , as for every a Z m , we have:
b Z m V 1 , 1 [ ( a , b ) , · ] =
c Z m e a , c e a , c + Δ 1 , 2 =
c Z m e a , c c Z m e a , c + Δ 1 , 2 =
1 1 = 0
Here, the transition from Equation (2) to Equation (3) is by Observation 1 and the observation that for a fixed a, ( S 2 a b ) b Z m is a permutation over Z m , so the change of coordinates we perform is valid. We b-zero rows ( a , b ) of V 1 , 1 of Type 1 by adding all other rows of the form ( a , b ) to each of them.
Type 2 includes all rows in V i , 1 for i { 2 , 3 } are of this type. Consider a row indexed by ( a , b ) in V i , 1 (in particular, the row in block V 3 , · is of that type). It is spanned by rows in B as follows:
j = 0 Δ 1 , i + 1 Δ 1 , 2 1 V 1 , 1 [ ( a , b + Δ 2 , i + 1 j · Δ 1 , 2 ) , · ] =
j = 0 Δ 1 , i + 1 Δ 1 , 2 1 ( e a , S i + 1 a b + j · Δ 1 , 2 e a , S i + 1 a b + ( j + 1 ) · Δ 1 , 2 ) =
e a , S i + 1 a b e a , S i + 1 a b + Δ 1 , i + 1 = V i , 1 [ ( a , b ) , · ]
Here, the transition to Equation (8) is by observing that a telescopic sum is formed, where all but the first and last e x , y ’s in the sum cancel out. Note that the number in the superscript of the sum indeed exists, as Δ 1 , 2 generates Z m , and so, in particular, Δ 1 , i + 1 = k · Δ 1 , 2 for some integer k > 0 .
Rearranging the equality above, we get:
V i , 1 [ ( a , b ) , · ] j = 0 Δ 1 , i + 1 Δ 1 , 2 1 V 1 , 1 [ ( a , b + Δ 2 , i + 1 j · Δ 1 , 2 ) , · ] = 0
That is, we have identified the linear combinations of rows in B that add up to V i , 1 .

4.3. Elimination Step 2

After applying Lemma 1 to each row to Type 1 and Type 2 and making it zero, we turn to considering the remaining matrix A Z p ( m + m 2 + 1 ) × m 2 . It is a block matrix of size 3 × 1 , with blocks corresponding to V 1 , 2 , V 1 , 3 , V 1 , 4 in A , with m , m 2 , and one row, respectively. Let us calculate the form of rows of both types, when restricted to V (following elimination step 1 from Section 4.2.2).
Type 1 in V : From Equation (2), we conclude that for a fixed a, for the (single) b such that ( a , b ) B , we have:
V 1 , 1 [ ( a , b ) , · ] =
b Z m V 1 , 2 [ ( a , b ) , · ] =
b Z m ( e b , S 2 a b e b , S 1 a b )
Type 2 in V : This type consists of row blocks i { 2 , 3 } in V . By construction, we have:
V i , 1 [ ( a , b ) , · ] = V i + 1 , 2 [ ( a , b ) , · ] j = 0 Δ 1 , i + 1 Δ 1 , 2 1 V 1 , 2 [ ( a , b + Δ 2 , i + 1 j · Δ 1 , 2 ) , · ]
Fix some ( a , b ) Z m × Z m . Now, from Observation 1 and Equation (9), it follows that for all ( a , b ) Z m × Z m , we have:
V i , 1 [ ( a , b ) , · ] =
V i , 2 [ ( a , b ) , · ] j = 0 Δ 1 , i + 1 Δ 1 , 2 1 V 1 , 2 [ ( a , b + Δ 2 , i + 1 j · Δ 1 , 2 ) , · ] =
e b , S i + 1 a b e b , S 1 a b j = 0 Δ 1 , i + 1 Δ 1 , 2 1 ( e b + Δ 2 , i + 1 j · Δ 1 , 2 , S i + 1 a b Δ 2 , i + 1 + j · Δ 1 , 2 e b + Δ 2 , i + 1 j · Δ 1 , 2 , S 1 a b Δ 2 , i + 1 + ( j + 1 ) · Δ 1 , 2 )

4.4. Permuting the Columns

Next, we permute the columns of A , to gain insight into its form. Note that this does not affect the question of whether A [ m + m 2 + 1 ] (last line) is spanned by the rest of the rows in A , R o w s ( A [ [ m + m 2 ] , [ m 2 ] ] ) . We refer to the new matrix as A ( 3 ) and the resulting block matrix as V ( 3 ) .
The permutation is as follows: the content of a column indexed by ( b , c ) Z m × Z m moves to ( b , b + c ) / Δ 1 , 2 in the new matrix. We therefore obtain the following matrix M for Types 1 and 2, respectively (from Equations (12) and (16)).

4.4.1. Type 1

V 1 , 1 ( 3 ) [ ( a , b ) , · ] = b Z m e ( b , S 2 a ) / Δ 1 , 2 e ( b , S 1 a ) / Δ 1 , 2 =
b , c Z m e ( b , c ) / Δ 1 , 2 e ( b , c + Δ 1 , 2 ) / Δ 1 , 2 =
b , c Z m e b , c e b , c + 1
Here, the last transition is due to the fact that dividing by Δ 1 , 2 is a permutation over Z m (as Δ 1 , 2 is invertible).

4.4.2. Type 2

For i { 2 , 3 } , we have:
V 1 , i ( 3 ) [ ( a , b ) , · ] =
e ( b , S i + 1 a ) / Δ 1 , 2 e ( b , S 1 a ) / Δ 1 , 2 j = 0 Δ 1 , i + 1 Δ 1 , 2 1 ( e ( b + Δ 2 , i + 1 j · Δ 1 , 2 , S i + 1 a ) / Δ 1 , 2 e ( b + Δ 2 , i + 1 j · Δ 1 , 2 , S 1 a + Δ 1 , 2 ) / Δ 1 , 2 ) =
e b , c e b , c + Δ 1 , i + 1 / Δ 1 , 2 j = 0 Δ 1 , i + 1 Δ 1 , 2 1 ( e ( b j + Δ 2 , i + 1 / Δ 1 , 2 , c ) e ( b j + Δ 2 , i + 1 / Δ 1 , 2 , c + 1 ) =
e ( b , c ) e ( b , c + Δ 1 , i + 1 / Δ 1 , 2 ) j = 0 Δ 1 , i + 1 Δ 1 , 2 1 e b + j , c e b + j , c + 1
In Equation (21), we simply rename b = b / Δ 1 , 2 , c = ( S i + 1 a ) / Δ 1 , 2 . In Equation (22), we observe that for j = Δ 1 , i + 1 Δ 1 , 2 , we have:
b j + Δ 2 , i + 1 / Δ 1 , 2 = b + 1 + Δ 2 , i + 1 Δ 1 , i + 1 Δ 1 , 2 = b + 1 + Δ 2 , 1 Δ 1 , 2 = b + 1 1 = b
Thus, making a change of coordinates and letting the index j in the ∑ in Equation (23) run from j = Δ 1 , i + 1 Δ 1 , 2 1 down to zero yield the expression in Line 23.

4.4.3. Summary

We have obtained a matrix with rows of the following form.
  • Type 1 (contributed by Row Block 1 in V ( 3 ) ) yields all vectors of the form:
    b Z m e b , c e b , c + 1
    for c Z m .
  • Type 2 (contributed by Row Block 2 in V ( 3 ) ) yields all vectors of the form:
    e ( b , c ) e ( b , c + Δ 1 , 3 / Δ 1 , 2 ) j = 0 Δ 1 , 3 Δ 1 , 2 1 e b + j , c e b + j , c + 1 = e ( b , c ) e ( b , c + ( 1 , 0 ) Z m ) j = 0 ( 0 , 1 ) Z m e b + j , c e b + j , c + 1 =
    For all pairs b , c Z m .
  • The last line of V ( 3 ) is subsequently referred to as Type 3. Similarly to Type 2, it follows from Equation (23) that the line in the last block ( i = 3 ) has the form:
    e ( B , C ) e ( B , C + ( 0 , 1 ) Z m ) j = 0 ( 1 , 0 ) Z m e B + j , C e B + j , C + 1
    Here, B , C Z m is some pair of constants (corresponding to A , B to be chosen above) to be fixed later.
In the above, ( 1 , 0 ) Z m = ( 0 , 1 ) Z m 1 in the sum limit corresponds to “lifting” the element of Z m into Z and viewing as an integer in { 0 , , m 1 } . Note that no “wrap around” occurs as ( 0 , 1 ) 0 in Z m , so we get the correct number in the sum limit.

4.5. A Change of Basis

Occasionally, we will refer to rows A ( 3 ) as matrices, with rows indexed by b and columns by c.
As we have witnessed, so far, we have performed applications of Lemma 1 on the original matrix A, which was a simple block matrix of size 4 × 3 blocks, and the upper three row blocks had three cells of size m 2 × m 2 each and another “block” row with three cells of size 1 × m 2 each cell. By performing two applications of the lemma, we obtained a much smaller matrix A ( 3 ) . Namely, we obtained a block matrix with 3 × 1 blocks, with cells of size m × m 2 , m 2 × m 2 , and 1 × m 2 , respectively. The price we have paid for the reduction in size is that the structure of the matrix has became more complex. In particular, it is no longer clear how to identify additional row sets I 1 to continue applying the lemma conveniently.
To create a matrix of more manageable form, we perform a change of basis. We suggest the following basis for the row space of A ( 3 ) . B = B 1 B 2 . Here:
B 1 = { e b , i e b , i + 1 | b Z m , i { 0 , , p 2 2 } , }
and:
B 2 = { e b , i + j · ( 1 , 0 ) Z m + e b , i + ( j + 1 ) · ( 1 , 0 ) Z m | b Z m , i Z p 2 , j Z p 1 \ { p 1 1 } }
In all indices here and elsewhere, the arithmetic is over Z m .
Indeed B 1 B 2 is a basis of R o w s ( A ( 3 ) ) . To prove this, we first note that it is an independent set. Roughly, this follows by separately considering the vectors in B with nonzero values in each row ( b , · ) separately and the fact that p 2 divides m.
Next, we show that the rows of A ( 3 ) are indeed spanned by the above set of vectors. Furthermore, the matrix re-written in this basis will have a nice block structure that we will be able to exploit for the purpose of using Lemma 1.
We denote by T b , i = e b , i e b , i + 1 a vector in B 1 and by R b , i + j ( 1 , 0 ) Z m = e b , i + j · ( 1 , 0 ) Z m + e b , i + ( j + 1 ) · ( 1 , 0 ) Z m a vector in B 2 .
To rewrite our matrix A ( 3 ) , we will specify an ordering of the vectors in B, from left to right
  • The columns in B 1 come first, in increasing order of c, starting from zero.
  • The columns of the form R b , i + j ( 1 , 0 ) in B 2 are ordered on several levels:
    (a)
    On the highest level, order R b , i + j · ( 1 , 0 ) ’s according to the index i above, starting from zero up to p 2 1 . There are p 2 blocks of this form on the highest level.
    (b)
    For a fixed i, order R b , i + j · ( 1 , 0 ) ’s according to increasing order of j starting from zero, up to p 1 2 .
    (c)
    For fixed i , j , order in increasing order of b s , starting from zero up to m 1 .
We order the rows of the matrix as follows:
  • The rows of Type 2 appear first, then Type 1, then Type 3 (the distinguished row to span via the others).
  • Within Type 1, we denote r c 1 = b Z m e b , c e b , c + 1 .
  • Within Type 2, denote by r b , c 2 the vector e ( b , c ) e ( b , c + ( 1 , 0 ) Z m ) j = 0 ( 0 , 1 ) Z m e b + j , c e b + j , c + 1 . Consider one such vector, r b , c 2 , We order these vectors according to i, then j, then b, where c = i + j · ( 1 , 0 ) . Similarly, for Type 3, denote r B , C 3 = e ( B , C ) e ( B , C + ( 0 , 1 ) Z m ) j = 0 ( 1 , 0 ) Z m e B + j , B e B + j , C + 1 .
Let us now study the form of the resulting matrix, divided into blocks, as follows from the representation of the various vectors in R o w s ( A ( 3 ) ) in basis B.
Let us represent the matrix as a block matrix, then we further break down each block into lower level blocks as follows. Let us denote the new matrix by A ( 4 ) .
The Type 2 set of rows in A ( 4 ) has structure as depicted in the following matrix. A ( 4 ) = ( A ( 4 ) , 2 ; A ( 4 ) , 1 , A ( 4 ) , 3 ) . Let us describe each of the matrices A ( 2 ) , i below.

4.5.1. The Matrix A ( 4 ) , 2

A ( 4 ) , 2 = ( A ( 4 ) , L , 2 | A ( 4 ) , R , 2 )
Here, the “right side” A R , 2 is a p 2 × p 2 block matrix. Its contents are as follows.
Entropy 21 00826 i003
The left-side matrix A ( 4 ) , L , 2 is a block matrix of size p 2 × 1 (where indeed the number of rows in each of its p 2 blocks is consistent with that of A ( 4 ) , R , 2 ). It has the following structure.
Entropy 21 00826 i004
We refer to this partition into p 2 × ( p 2 + 1 ) blocks of A ( 4 ) , 2 as the “Level-1” partition of A ( 4 ) , 2 .
We continue next with describing the “Level-0” detail of R 2 1 , R 2 2 , R 2 3 , L 2 i of A ( 4 ) , R , 2 , A ( 4 ) , L 2 . The matrix L 1 i for i { 0 , , p 2 2 } is a p 1 × ( p 2 1 ) block matrix of the following form:
Entropy 21 00826 i005
for a matrix T 0 to be specified later. Note that by the structure of A ( 4 ) , L , 2 , the last matrix L 1 p 2 1 is a block matrix of size p 1 × ( p 2 1 ) , where each block equals T 0 .
The matrix R 1 1 is a p 1 × ( p 1 1 ) matrix of the following form.
Entropy 21 00826 i006
Here, I is the m × m identity matrix. The matrix R 1 2 is a p 1 × ( p 1 1 ) matrix of the following form.
Entropy 21 00826 i007
Here, T 0 is a m × m matrix, as above. Finally, the matrix R 2 3 is a p 1 × ( p 1 1 ) block matrix of the following form.
Entropy 21 00826 i008
It remains to specify T 0 . It is a m × m circulant matrix of the following form.
Entropy 21 00826 i009

4.5.2. The Matrix A ( 4 ) , 3

We choose ( B , C ) = ( 0 , 0 ) . Then, the line is of the form:
b = 1 ( 0 , 1 ) Z m 1 T b , 0 + j = 0 p 1 2 R 0 , 1 + j · ( 1 , 0 ) Z m

4.5.3. The Matrix A ( 4 ) , 1

The matrix A ( 4 ) , 1 is of the form A ( 4 ) , 1 = ( A ( 4 ) , L , 1 ; A ( 4 ) , R , 1 ) . To describe the left and right parts, we apply a certain transformation to A ( 4 ) , L , 2 and A ( 4 ) , R , 2 , respectively. First, view each as a block matrix comprised of blocks of size m × m ( A ( 4 ) , L , 2 has m × ( p 2 1 ) blocks, and A ( 4 ) , R , 2 has m × p 2 ( p 1 1 ) ). Now, A ( 4 ) , L , 1 is obtained from A ( 4 ) , L , 2 by applying a linear mapping satisfying l ( T 0 ) = ( 1 , , 1 ) m times to each block X, replacing X by m ( X ) (it is not important how exactly we define it on other inputs). The matrix A ( 4 ) , L , 1 is obtained from A ( 4 ) , L , 1 by replacing each block by a linear transformation that maps I to the zero vector and T 0 to ( 1 , , 1 ) m times . That is, the resulting A ( 4 ) , L , 1 equals:
Entropy 21 00826 i010
where L ˜ 1 i equals:
Entropy 21 00826 i011
The resulting matrix A ( 4 ) , R , 1 equals:
Entropy 21 00826 i012
where the resulting R ˜ 1 2 is of the form:
Entropy 21 00826 i013

4.6. Another Elimination Sequence

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

4.6.1. Step 1: Working at the Resolution of Level-1 Blocks

View A ( 4 ) , 2 as a block matrix of Level-1 as described above. Let V ( 4 ) , 2 denote the corresponding block matrix. Replace the last row of V ( 4 ) , 2 , V ( 4 ) , 2 [ p 1 1 , · ] by i = 0 p 2 1 V ( 4 ) , 2 [ i , · ] . We thus obtain a new matrix A ( 5 ) , 2 of the following form. A ( 5 ) , 2 = ( A ( 5 ) , L , 2 | A ( 5 ) , R , 2 ) has the same block structure as A ( 4 ) , 2 on all levels, so we do not repeat that, but rather only review its content.
The resulting right side A ( 5 ) , R , 2 is as follows.
Entropy 21 00826 i014
The resulting left-side matrix A ( 5 ) , L , 2 is:
Entropy 21 00826 i015
We perform a similar transformation on A ( 4 ) , 1 , resulting in:
A ( 5 ) , 1 = ( A ( 5 ) , R , 1 | A ( 5 ) , L , 1 )
where A ( 5 ) , R , 1 equals:
Entropy 21 00826 i016
and A ( 5 ) , L , 1 equals
Entropy 21 00826 i017

4.6.2. Step 2: Working at the Resolution of Level-0 Blocks

Here, we view the matrix A ( 5 ) as a block matrix over Level-0 blocks. That is, denote by ( i , j ) the row block corresponding to the j th Level-0 block inside the i th Level-1 block of A ( 6 ) . We transform A ( 5 ) into a matrix V ( 6 ) as follows.
For each i { 0 , , p 2 2 } , j { 1 , , p 1 } , replace each row in V ( 5 ) , 2 [ ( i , j ) , · ] with V ( 5 ) , 2 [ ( i , 0 ) , · ] . The resulting matrix A ( 6 ) , 2 is of the form A ( 6 ) , 2 = A ( ( 6 ) , L , 2 | A ( 6 ) , R , 2 ) .
The right side A ( 6 ) , R , 2 is as follows.
Entropy 21 00826 i018
where R 1 4 equals:
Entropy 21 00826 i019
The resulting left-side matrix A ( 6 ) , L , 2 is:
Entropy 21 00826 i020
where L 1 , i is of the form:
Entropy 21 00826 i021
Finally, we apply a similar transformation to A ( 5 ) , 1 resulting in A ( 6 ) , L , 1 that equals:
Entropy 21 00826 i022
where L ˜ 1 , i is of the form:
Entropy 21 00826 i023
The resulting right-hand side is A ( 6 ) , R , 1 = A ( 5 ) , R , 1 (there is no change, since the first block-row in V ( 5 ) , R , 1 is zero).

4.6.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 A ( 4 ) , L ’s rows as the set of non-zero rows of the matrix A ( 7 ) , L obtained by a series of row operations. To this end, our goal is to understand the set of remaining rows in A ( 6 ) , L . In the A ( 6 ) , L , 2 part, each Level-0 block-column (with blocks of size m × m ) has only G = R o w s ( T 0 ) { ( 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 2.
Assume p = p 1 . Then, the index set I = { k | 0 k ( p 1 1 ) p 2 } satisfies that R o w s ( T 0 [ I , [ m ] ] ) is a basis for G. In particular, we have j = 0 p 1 1 T 0 [ j · p 2 , [ m ] ] = x · ( 1 , , 1 ) . Here, x is computed as follows: first calculate y as p 2 1 modulo p 1 (that is, in Z p 1 ). Then, we “lift” y back into Z ( 1 y p 1 1 ) and then set x to be y modulo p – that is, x is an element of Z p (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 T 0 .
Lemma 3.
Assume p = p 1 . Then, the set of vectors:
S = { j = 0 p 1 1 e j · p 2 e i + ( j + 1 ) · p 2 | i Z p 2 \ { 0 } }
is a basis of K e r ( T 0 ) , where K e r ( M ) = { v | v · M } denotes the left kernel of the matrix M.
The observations are rather simple to prove by basic techniques; see Appendix A. 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 ( 7 ) , 2 part first. We conclude from Lemma 2 that for every block specified by ( i , j ) where i p 2 1 , in V ( 6 ) , L , 2 [ ( i , j ) , · ] , the rows indexed by b I (as in Lemma 2) span all rows in that block. Furthermore, for the purpose of Lemma 1, we b-zero the rest of the rows, by a sequence of row operations as specified by K e r ( T 0 ) in Lemma 3, starting from row ( p 1 1 ) p 2 + 1 and moving forward up to m 1 . That is, for b -zeroing row ( p 1 1 ) p 2 + k (where k > 0 ) in V ( 6 ) , L , 2 [ ( i , j ) , · ] as above, we store the combination:
h = 0 p 1 1 V ( 6 ) , 1 [ ( i , j , k + h · p 2 ) , · ] V ( 6 ) , 1 [ ( i , j , k + ( h + 1 ) · p 2 ) , · ]
in row ( i , j , k ) of A ( 7 ) , 2 .
Overall, the resulting A ( 7 ) , 2 is as follows:
A ( 7 ) , R , 2 is identical to A ( 6 ) , R , 2 , except for replacing R 1 4 with R 1 5 .
That is, in the last block row R 1 5 , all cells are R 1 2 , and there are p 1 such cells.
Here, R 1 2 is of the form:
Entropy 21 00826 i024
Entropy 21 00826 i025
Next, we handle the A ( 7 ) , 1 part. Here, we b-zero the remaining rows in A ( 6 ) , L , 1 by adding the right combination of rows in A ( 6 ) , L , 2 . The combination is determined by the “in particular” part of Lemma 3.
The resulting matrix A ( 7 ) , L , 2 is identical to A ( 6 ) , L , 2 , except for T 0 in each L 1 , i being replaced by T 0 . Here, T 0 has the form:
Entropy 21 00826 i026
Here, A ( 7 ) , L , 1 becomes zero, which was our goal. Note that as opposed to previous transformations, the transformation performed on A ( 6 ) , L , 1 does not “mirror” the transformation performed on A ( 6 ) , L , 2 and in fact involves rows from both A ( 6 ) , L , 2 and A ( 6 ) , L , 1 . A ( 7 ) , R , 1 is identical to A ( 6 ) , R , 1 , except that in each Level-1 block ( i , i ) for i { 0 , , p 2 2 } , the first row of R ˜ 1 2 (the content of this block) is replaced by:
i = 0 p 1 1 x e i · p 2 .
It remains to b-zero the L-part of A ( 6 ) , 3 . For simplicity, we focus on V ( 6 ) , L , 3 [ 0 , 0 ] (which is the only non-zero block in V ( 6 ) , L , 2 ) and then use the resulting linear dependence to produce the new row V ( 6 ) , 3 [ 0 , · ] .
V ( 6 ) , L , 3 [ 0 , 0 ] = x i = 0 p 1 1 V ( 6 ) , L , 2 [ ( 0 , 0 , i · p 2 ) , 0 ] V ( ( 6 ) , L , 2 ) [ ( 0 , 0 , ( 1 , 0 ) Z m + 1 ) , 0 ]
This results in:
A ( 7 ) , R , 3 = x i = 0 p 1 1 e ( 0 , 0 , i · p 2 ) + e ( 0 , 0 , ( 1 , 0 ) Z m ) + b = 1 ( 0 , 1 ) Z m 1 T b , 0 [ R ] + j = 0 p 1 2 R 0 , 1 + j · ( 1 , 0 ) Z m [ R ]

4.6.4. A Reduced Matrix We will Analyze Directly

Taking I 1 to be the set of rows in A ( 7 ) that correspond to non-zero rows in A ( 7 ) , L , 1 and I 2 corresponding to L, we obtain the following matrix A ( 8 ) . On Level-1, it has a block structure similar to that of A ( 7 ) , R (where the number of rows changes in some of the matrices). More concretely, A ( 8 ) , 2 has the form:
Entropy 21 00826 i027
Here, R 1 5 , is identical to R 1 5 except that the top m p 2 + 1 rows in it are removed. That is, it is identical to R 1 4 , except that the (0,0)th Level-0 block in R 1 4 replaces I by C, which are equal.
Entropy 21 00826 i028
Similarly, R 1 2 , is obtained from R 1 2 in the same manner. In this case, only zero rows are removed. A ( 8 ) , 1 is precisely A ( 7 ) , R , 1 (no rows were eliminated from there, as all corresponding rows on the left side became zero). Similarly, A ( 8 ) , 3 = A ( 7 ) , R , 3 .

4.7. Completing the Proof - Analysis of A ( 8 )

We are now ready to make our conclusion, assuming p = p 1 and p 1 , p 2 > 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 ( 8 ) “modulo” the set G: for every row r in A ( 8 ) and every Level-0 block in this row, we reduce the contents of that row “modulo” s p a n ( R o w s ( T 0 ) ) . That is, we complement the basis of R o w s ( T 0 ) specified in Lemma 2 into a basis of Z p m , where e 0 is one of the added vectors and define a linear mapping L taking elements of R o w s ( T 0 [ I , · ] ) to zero and other elements of the basis onto themselves (it is inconsequential what the other base elements are). Indeed, observe that e 0 is not in s p a n ( R o w s ( T 0 ) ) , as it is not in K e r ( K e r ( s p a n ( R o w s ( T 0 ) ) ) ) , as implied by Lemma 2. To verify this, observe for instance that:
< i = 0 p 1 1 ( e i · p 2 e 1 + i · p 2 ) , e 0 > = 1 0 .
We apply a linear mapping L taking x s p a n ( R o w s ( T 0 ) ) 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 ( 9 ) denote the resulting matrix.
Observation 3.
The rows of A ( 9 ) , 1 are zero.
Observation 4.
A ( 9 ) , 3 maps to b = 1 ( 0 , 1 ) Z m 1 T b , 0 [ R ] + j = 0 p 1 2 R 0 , 1 + j · ( 1 , 0 ) Z m [ R ] .
Observation 3 follows easily from the form of the matrix A ( 8 ) and Lemmas 2 and 3, which implies that span ( R o w s ( T 0 ) ) is exactly the kernel of S from Lemma 2 (this is the reason we need Lemma 2: it is easier to verify that a given vector is not in K e r ( s p a n ( S ) ) , rather than verifying it is not in s p a n ( T 0 ) ).
Observation 4 follows by the structure of A ( 8 ) and definition of L.
Now, if A ( 8 ) , 3 is spanned by the rest of the rows in A ( 8 ) , then it must be the case that the same dependence exists in A ( 9 ) . Thus, it suffices to prove that the latter does not hold. Assume for the sake of contradiction that:
v ( A ( 9 ) , 1 ; A ( 9 ) , 2 ) = A ( 9 ) , 3
for some vector v. In the following, we use V 0 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 p 2 1 rows, and in other block row, the cells have m rows, as usual. Similarly, we use V 1 to impose Level-1 structure onto v.
By the structure of R 1 2 , , we conclude that A ( 9 ) , 2 is of the form:
Entropy 21 00826 i029
Observe that in A ( 9 ) , 3 , non-zero values exist only in Level-1 blocks i = 0 , 1 . As there are p 2 such blocks and p 2 > 2 , by our assumption, we conclude that the last row contributes zero to v ( A ( 9 ) , 1 ; A ( 9 ) , 2 ) , as in the last block, the output needs to be zero, and it equals V [ p 2 ] A ( 9 ) , 2 , which is the same contribution for all (Level-1) blocks.
To agree with A ( 9 ) , 3 at block i, we must then have v · R 1 5 , = e 0 . Viewing R 1 5 , as a block-matrix of Level00, because of the zeroes at all blocks but Block 0, the contributions of all block-rows but the first one to v · R 1 5 , is:
( 2 + ( p 1 2 ) ) · V 1 [ p 2 ] = p 1 · V 1 [ 0 ] = 0 .
In the above, the last equality is due to the fact that p = p 1 . Thus, we must have V 1 [ 0 ] · C = e 0 . However, we observe that R o w s ( C ) is a subset of K e r ( span ( S ) ) , where S is specified in Lemma 3 and thus cannot equal e 0 (which is not in K e r ( span ( S ) ) ).
This concludes the proof of Theorem 4.

5. Future Directions

Our work leaves several interesting problems open.
  • For what other parameters is a share conversion from ( 2 , 3 ) -CNF to three-additive possible? For instance, surprisingly, p p 1 , p 2 is possible for ( m = 7 · 73 , p = 2 ) as follows from [10]. Our analysis does not explain this phenomenon, as we did not complete the full analysis of the resulting matrix. We believe that given the work we have done, this is a very realistic goal.
  • We need to understand share conversion for different sets S. One direction is by considering m’s, which are a product of more than two primes. As discussed in the Introduction, already using three primes, a conversion from (2,3)-CNF over S m would improve over the best known constructions for three-server PIR via the BIKO paradigm. One advantage of such schemes following the BIKO framework is the constant answer size achieved. Here, we initially worked with two primes, rather than with three, to develop the tools and intuition for a slightly technically simpler setting.
  • As discussed in the Introduction, some of the previous results not falling in the BIKO framework can be viewed as instances of an extended BIKO framework using a “many-to-one” share conversion. Viewing PIR protocols as based on share conversions between secret sharing schemes is apparently “the right” way to look at it. As certain evidence, using the more redundant CNF instead of Shamir as in [10] was a useful insight from secret sharing allowing us to further improve CC. In particular, in the case that there are no share conversions for C S m for m’s that are a product of three or more primes, perhaps a suitable many-to-one conversion may still exist.
    Further extending this view could lead to new insights on PIR design. In particular, in many of the existing schemes, a shallow circuit is evaluated essentially by performing share conversions. In particular, local evaluation of linear functions over the inputs is a special case of such a many-to-one conversion (from a linear scheme to itself). In all schemes we have surveyed here, PIR for a large family F of functions (of size 2 2 n ) was implemented via share conversion for a small set of relations. For instance, BIKO’s 3-PIR was based on 2 n linear functions (implementing inner products with vectors in the MV family) and a share conversion for C S m , thus only O ( 2 n ) relations. Similarly, in the two-server PIR, the situation is similar.
    One concrete direction may be proving lower bounds on PIR protocols based on “circuits” containing only certain share conversion “gates”. Perhaps analogies to circuit complexity could be made, borrowing techniques from circuit lower bounds. Insights for such limited classes of schemes could hopefully advance our understanding of lower bounds for PIR CC; currently, the best-known lower bound even for two-server PIR is 5 n , only slightly above trivial [15].

Author Contributions

A.P.-C. and L.S. contributed equally in this paper.

Funding

This research received no external funding.

Acknowledgments

We thank Roi Benita for greatly simplifying the transition from A to A at an earlier step of working on this project.

Conflicts of Interest

The authors declare no conflict of interest.

Appendix A. Deferred Proofs

Appendix A.1. Proof of Lemma 2

We start with a few Claims to be used by the proof.
Lemma A1.
Let p be a prime and 0 < x < p an integer. Let T 0 ( p ) denote a matrix in Z p × p where the i th row is:
[ T 0 ( p ) [ i , · ] = j = 0 x 1 e i + j .
Then r a n k ( T 0 ( p ) ) = p .
Proof of Lemma A1.
In the following, all index arithmetic in vectors and matrices is done over Z p . First, observe that transpose ( T 0 ( p ) ) = T 0 ( p ) . In particular:
transpose ( T 0 ( p ) ) [ · , i ] = T 0 ( p ) [ p x , · ]
Let us figure out the left kernel of T 0 ( p ) , K. In particular, for all z K , all coordinates of z · T 0 ( p ) are equal.
We note that since for all i Z p :
z · T 0 ( p ) [ · , i ] z · T 0 ( p ) [ · , i + 1 ] = 0 ,
then by the structure of the columns, we have z [ i ] = z [ i + x ] . Since p is prime and x < p , the sequence z [ 0 ] , z [ x ] , z [ 2 x ] , , z [ ( p 1 ) x ] goes over all entries in z. We thus conclude that z = a ( 1 , , 1 ) for some a Z p . By a simple calculation, we have z · T 0 ( p ) = a · x . As x 0 as an element of Z p , then to obtain z T 0 ( p ) = 0 , we must have a = 0 . That is, there is no non-zero linear combination of R o w s ( T 0 ( p ) ) leading to zero, so R o w s ( T 0 ( p ) ) are independent, as required. □
Observation 5.
There exist at least two α j ’s that belong to distinct orbits that are non-zero.
Proof of Observation 5.
For any single orbit I i ( 0 i < p 2 ), one may view the matrix T 0 [ I i , · ] as consisting of 1 × p 2 blocks, with the first block in each row starting at entry i (and one of the blocks possibly wrapping around). The matrix T 0 [ I i , · ] (with rows permuted for convenience) is thus a p 1 × p 1 block-matrix such that every block initially consists of entries of the form a · ( 1 , , 1 ) for a { 0 , 1 } in each block. Consider a linear L mapping applied to the resulting block matrix V 0 i , replacing each block with a single element of Z p that maps ( 1 , , 1 ) to one. Then, clearly, L 0 i = L ( T 0 [ I i , · ] ) is a p 1 × p 1 matrix over Z p satisfying the conditions of Lemma A1. This is the case since p = p 1 , and each row has p 2 1 mod p 1 non-zero blocks. By Lemma A1, the rows of L 0 i are therefore linearly independent. We conclude that so are the rows of T 0 [ I i , · ] (or else the rows of L 0 i would also be dependent via the same linear combination). Therefore, the rows of the T 0 [ I i I , · ] are also linearly independent. □
Proof of Lemma 2.
We start with the “in particular” part. To prove this, recall that in each row in T 0 , there are exactly ( 1 , 0 ) Z m consecutive one. That is, for x = p 2 1 mod p 1 , we have x p 2 = x ( p 2 , 0 ) = ( 1 , 0 ) Z m . That is, p 2 fits into ( 1 , 0 ) Z m p 2 1 mod p 1 (lifted back to Z ) times. Indeed, p 2 1 mod p 1 exists, as p 2 p 1 and is a prime, so it does not equal zero mod p 1 .
We therefore get:
i = 0 p 1 1 T 0 [ i · p 2 , [ m ] ] = x · ( 1 , , 1 )
over Z p . This holds, since at every point, we add exactly x vectors that contribute one to that point. Here, the integer x is viewed as an element of Z p . As p = p 1 , x is non-zero in Z p .
It is not hard to see that every other vector in R o w s ( T 0 ) is spanned by R o w s ( T 0 [ I , [ m ] ] ) : Let use define an orbit as a sub-set of vectors I i = { i + j p 2 | 0 j p 1 1 } for i Z p 2 . It is easy to see that we have j S i T 0 [ j , · ] = j I T 0 [ j , · ] = x ( 1 , , 1 ) for any i Z p 2 . Therefore, for any T 0 [ i + ( p 1 1 ) p 2 , · ] for i + ( p 1 1 ) p 2 I , we have:
T 0 [ i + ( p 1 1 ) p 2 , · ] + j = 0 p 1 2 T 0 [ i + j p 2 , · ] x ( 1 , , 1 ) =
T 0 [ i + ( p 1 1 ) p 2 , · ] + j = 0 p 1 2 T 0 [ i + j p 2 , · ] i = 0 p 1 1 T 0 [ i · p 2 , · ] = 0
Indeed, in the above equation, all summands but T 0 [ i + ( p 1 1 ) p 2 , · ] are in R o w s ( T 0 [ I , · ] ) .
To complete the proof, it remains to prove that R o w s ( T 0 [ I , · ] ) is an independent set. Assume for contradiction that a non-trivial linear combination of R o w s ( T 0 [ I , · ] ) leads to zero. Let:
i I α i T 0 [ i , · ] = 0
where not all α i ’s are zero. Splitting the sum into orbits, we get:
i Z p 2 j I I i α j T 0 [ j , · ] = 0
Consider all orbits i 1 < i 2 < i t in which non-zero coefficients in the above combination exist. By Observation 5, t 2 . In particular, starting from h = 2 , not all α j ’s corresponding to j I h are non-zero (because | I I i | = p 1 only for i = 0 and equals p 1 1 otherwise).
Thus, we have j I i 1 α j T 0 [ j , · ] = g = 2 t j I i g α j T 0 [ j , · ] . Note that the vector on the left-hand side has the property that every block of p 2 consecutive elements starting at some index j p 2 is of the form a ( 1 , , 1 ) . On the right-hand side, as orbit I i 2 has non-zero α j ’s, but not all of them non-zero, the sum:
j I i 2 α j T 0 [ j , · ]
is non constant. The latter holds since all the rows indexed by this orbit are independent by Lemma A1, and z = a ( 1 , , 1 ) lead to constant z T 0 [ I i 2 , · ] . We thus conclude that only such z’s lead to constant z T 0 [ I i 2 , · ] . As at least one α j in this orbit is zero, and at least one is not. z cannot be of this form, and thus, the z T 0 [ I i 2 , 0 ] is not constant. On the other hand, by the structure of z T 0 [ I i 2 , · ] , every block of size p 2 starting at i 2 + j p 2 is of the form a ( 1 , , 1 ) . In particular, there must exist two consecutive blocks starting at i 2 + j p 2 , i 2 + ( j + 1 ) p 2 respectively with different values a 1 ( 1 , , 1 ) a 2 ( 1 , , 1 ) respectively. In this pair of blocks, each intersects the block B 0 starting at ( j + 1 ) p 2 from orbit I 0 . Thus, on the right-hand side, this block has the same value a 1 at indices { ( j + 1 ) p 2 , , ( j + 1 ) p 2 + i 2 1 } (a non-empty set, as i 2 0 ) and a different value a 2 at indices { ( j + 1 ) p 2 + i 2 , , ( j + 2 ) p 2 1 } . Going over the following i g ’s, a similar situation results. Spelling it out, i 3 (if it exists) will perhaps create one or more additional “imbalanced” blocks ( j + 1 ) p 2 and maybe affect the original block we singled out, ( j + 1 ) p 2 affected by i 2 . In the latter case, it will not fix the original imbalance. To see that, let us consider the sequence of orbits 0 < i 1 < i 2 < < i t affecting the block B 0 in the way described above. As we add the contribution of the i j ’s from left to right, we consider the sequence going from the end of the block to the left up to entry ( j + 1 ) p 2 + i j included. It is not hard to show by induction on j that this sequence consists of the same value. When adding the contribution of i t , this sequence (of length at least two at this point, as t p 1 1 ) is broken into two, where the first entry in the sequence now differs from the last. The delta equal between these entries is a 2 a 1 , where a 1 , a 2 are the constants corresponding to i t , as explained for i 2 above. We conclude that the right-hand side is not a multiple of ( 1 , , 1 ) (as the block B 0 is not constant) and in particular may not equal zero. □

Appendix A.2. Proof of Lemma 3

Proof of Lemma 3.
We prove the claim in two steps. First, we observe that S is the right kernel of T 0 . Then, by recalling transpose ( T 0 ) = T 0 , the claim follows. To prove the first observation, we note that indeed, S is a subset of the right kernel of T 0 , by calculating the products T 0 · v for each v S , essentially following from the observation that the sum over all rows indexed by any single orbit I i (as defined in the previous section) is the same. Next, it is easy to see that the set S is independent; for instance, focus on the first block I 2 of p 2 columns, and observe that the rank of T 0 [ · , I 2 ] is by itself p 2 1 = | S | . Finally, r a n k ( T 0 [ I , · ] ) defined in Lemma 2 is | I | = ( p 1 1 ) p 2 + 1 . As R o w s ( T 0 [ I , · ] ) span T 0 [ I , · ] , then by the Cayley–Hamilton theorem, the rank of the right kernel of T 0 is m ( p 1 1 ) p 2 1 = p 2 1 . We conclude that S is a basis of the (right) kernel of T 0 , which concludes the proof. □

References

  1. Chor, B.; Kushilevitz, E.; Goldreich, O.; Sudan, M. Private Information Retrieval. J. ACM 1998, 45, 965–981. [Google Scholar] [CrossRef]
  2. Kushilevitz, E.; Ostrovsky, R. Replication is NOT Needed: SINGLE Database, Computationally-Private Information Retrieval. In Proceedings of the 38th Annual Symposium on Foundations of Computer Science, FOCS ’97, Miami Beach, FL, USA, 19–22 October 1997; pp. 364–373. [Google Scholar]
  3. Gentry, C.; Ramzan, Z. Single-Database Private Information Retrieval with Constant Communication Rate. In Proceedings of the Automata, Languages and Programming, 32nd International Colloquium, ICALP 2005, Lisbon, Portugal, 11–15 July 2005; pp. 803–815. [Google Scholar]
  4. Beimel, A.; Ishai, Y.; Kushilevitz, E.; Orlov, I. Share Conversion and Private Information Retrieval. In Proceedings of the 27th Conference on Computational Complexity, CCC 2012, Porto, Portugal, 26–29 June 2012; pp. 258–268. [Google Scholar]
  5. Ben-Or, M.; Goldwasser, S.; Wigderson, A. Completeness Theorems for Non-Cryptographic Fault-Tolerant Distributed Computation (Extended Abstract). In Proceedings of the 20th Annual ACM Symposium on Theory of Computing, Chicago, IL, USA, 2–4 May 1988; pp. 1–10. [Google Scholar]
  6. Goldreich, O.; Micali, S.; Wigderson, A. How to Play any Mental Game or A Completeness Theorem for Protocols with Honest Majority. In Proceedings of the 19th Annual ACM Symposium on Theory of Computing, New York, NY, USA, 25–27 May 1987; pp. 218–229. [Google Scholar] [CrossRef]
  7. Cramer, R.; Damgård, I.; Ishai, Y. Share Conversion, Pseudorandom Secret-Sharing and Applications to Secure Computation. In Theory of Cryptography Conference; Springer: Berlin/ Heidelberg, Germany, 2005; pp. 342–362. [Google Scholar] [Green Version]
  8. Grolmusz, V. Constructing set systems with prescribed intersection sizes. J. Algorithms 2002, 44, 321–337. [Google Scholar] [CrossRef]
  9. Beimel, A.; Ishai, Y.; Kushilevitz, E.; Raymond, J. Breaking the O(n1/(2k−1)) Barrier for Information-Theoretic Private Information Retrieval. In Proceedings of the 43rd Symposium on Foundations of Computer Science (FOCS 2002), Vancouver, BC, Canada, 16–19 November 2002; pp. 261–270. [Google Scholar]
  10. Efremenko, K. 3-Query Locally Decodable Codes of Subexponential Length. SIAM J. Comput. 2012, 41, 1694–1703. [Google Scholar] [CrossRef]
  11. Yekhanin, S. Towards 3-query locally decodable codes of subexponential length. J. ACM 2008, 55. [Google Scholar] [CrossRef]
  12. Dvir, Z.; Gopalan, P.; Yekhanin, S. Matching Vector Codes. SIAM J. Comput. 2011, 40, 1154–1178. [Google Scholar] [CrossRef]
  13. Dvir, Z.; Gopi, S. 2-Server PIR with Subpolynomial Communication. J. ACM 2016, 63, 39. [Google Scholar] [CrossRef]
  14. Beimel, A. Secret-Sharing Schemes: A Survey. In International Conference on Coding and Cryptology; Springer: Berlin/Heidelberg, Germany, 2011; pp. 11–46. [Google Scholar] [Green Version]
  15. Wehner, S.; de Wolf, R. Improved Lower Bounds for Locally Decodable Codes and Private Information Retrieval. In International Colloquium on Automata, Languages, and Programming; Springer: Berlin/Heidelberg, Germany, 2005. [Google Scholar]

Share and Cite

MDPI and ACS Style

Paskin-Cherniavsky, A.; Schmerler, L. On Share Conversions for Private Information Retrieval. Entropy 2019, 21, 826. https://doi.org/10.3390/e21090826

AMA Style

Paskin-Cherniavsky A, Schmerler L. On Share Conversions for Private Information Retrieval. Entropy. 2019; 21(9):826. https://doi.org/10.3390/e21090826

Chicago/Turabian Style

Paskin-Cherniavsky, Anat, and Leora Schmerler. 2019. "On Share Conversions for Private Information Retrieval" Entropy 21, no. 9: 826. https://doi.org/10.3390/e21090826

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

Article Metrics

Back to TopTop