Arman Fazeli

Codes for distributed PIR with low storage overhead

Private information retrieval (PIR) protocols allow a user to retrieve a data item from a database without revealing any information about the identity of the item being retrieved. Specifically, in information-theoretic k-server PIR, the database is replicated among k non-communicating servers, and each server learns nothing about the item retrieved by the user. The cost of PIR protocols is usually measured in terms of their communication complexity, which is the total number of bits exchanged between the user and the servers. However, another important cost parameter is the storage overhead, which is the ratio between the total number of bits stored on all the servers and the number of bits in the database. Since single-server information-theoretic PIR is impossible, the storage overhead of all existing PIR protocols is at least 2 (or k, in the case of k-server PIR). In this work, we show that information-theoretic PIR can be achieved with storage overhead arbitrarily close to the optimal value of 1, without sacrificing the communication complexity. Specifically, we prove that all known k-server PIR protocols can be efficiently emulated, while preserving both privacy and communication complexity but significantly reducing the storage overhead. To this end, we distribute the n bits of the database among s + r servers, each storing n/s coded bits (rather than replicas). Notably, our coding scheme remains the same, regardless of the specific k-server PIR protocol being emulated. For every fixed k, the resulting storage overhead (s +r)/s approaches 1 as s grows; explicitly we have equation. Moreover, in the special case k = 2, the storage overhead is only 1 + 1/s. In order to achieve these results, we introduce and study a new kind of binary linear codes, called here k-server PIR codes. Finally, we show how such codes can be constructed from multidimensional cubic, from Steiner systems, and from one-step majority-logic decodable codes.

Minimum storage regenerating codes for all parameters

Regenerating codes for distributed storage have attracted much research interest in the past decade. Such codes trade the bandwidth needed to repair a failed node with the overall amount of data stored in the network. Minimum storage regenerating (MSR) codes are an important class of optimal regenerating codes that minimize (first) the amount of data stored per node and (then) the repair bandwidth. Specifically, an [n, k, d]-(α) MSR code C over Fq is defined as follows. Using such a code C, a file F consisting of αk symbols over Fq can be distributed among n nodes, each storing α symbols, in such a way that: . the file F can be recovered by downloading the content of any k of the n nodes; and . the content of any failed node can be reconstructed by accessing any d of the remaining n -1 nodes and downloading α/(d-k+1) symbols from each of these nodes. A common practical requirement for regenerating codes is to have the original file F available in uncoded form on some k of the n nodes, known as systematic nodes. In this case, several authors relax the defining node-repair condition above, requiring the optimal repair bandwidth of dα/(d-k+1) symbols for systematic nodes only. We shall call such codes systematic-repair MSR codes. Unfortunately, explicit constructions of [n, k, d] MSR codes are known only for certain special cases: either low rate, namely k/n ≤ 0.5, or high repair connectivity, namely d = n -1. Although setting d = n - 1 minimizes the repair bandwidth, it may be impractical to connect to all the remaining nodes in order to repair a single failed node. Our main result in this paper is an explicit construction of systematic-repair [n, k, d] MSR codes for all possible values of parameters n, k, d. In particular, we construct systematic-repair MSR codes of high rate k/n > 0.5 and low repair connectivity k ≤ d ≤ n - 1. Such codes were not previously known to exist. In order to construct these codes, we solve simultaneously several repair scenarios, each of which is expressible as an interference alignment problem. Extension of our results beyond systematic repair remains an open problem.

Generalized Sphere Packing Bound

Kulkarni and Kiyavash recently introduced a new method to establish upper bounds on the size of deletion-correcting codes. This method is based upon tools from hypergraph theory. The deletion channel is represented by a hypergraph whose edges are the deletion balls (or spheres), so that a deletion-correcting code becomes a matching in this hypergraph. Consequently, a bound on the size of such a code can be obtained from bounds on the matching number of a hypergraph. Classical results in hypergraph theory are then invoked to compute an upper bound on the matching number as a solution to a linear-programming problem: the problem of finding fractional transversal. The method by Kulkarni and Kiyavash can be applied not only for the deletion channel but also for other error channels. This paper studies this method in its most general setup. First, it is shown that if the error channel is regular and symmetric then the upper bound by this method coincides with the well-known sphere packing bound and thus is called here the generalized sphere packing bound. Even though this bound is explicitly given by a linear programming problem, finding its exact value may still be a challenging task. The art of finding the exact upper bound (or slightly weaker ones) is the assignment of weights to the hypergraphs vertices in a way that they satisfy the constraints in the linear programming problem. In order to simplify the complexity of the linear programming, we present a technique based upon graph automorphisms that in many cases significantly reduces the number of variables and constraints in the problem. We then apply this method on specific examples of error channels. We start with the Z channel and show how to exactly find the generalized sphere packing bound for this setup. Next studied is the nonbinary limited magnitude channel both for symmetric and asymmetric errors, where we focus on the single-error case. We follow up on the deletion channel, which was the original motivation of the work by Kulkarni and Kiyavash, and show how to improve upon their upper bounds for single-deletion-correcting codes. Since the deletion and grain-error channels have a similar structure for a single error, we also improve upon the existing upper bounds on single-grain error-correcting codes. Finally, we apply this method for projective spaces and find its generalized sphere packing bound for the single-error case.

On the scaling exponent of binary polarization kernels

It is well known that polar coding achieves capacity, but it is so far unknown exactly how fast polar codes approach channel capacity as a function of their blocklength. More precisely, let us fix a binary-input memoryless symmetric channel W of capacity I(W) and a desired probability of error P_e. Given W and P_e, suppose we wish to communicate at rate I(W) - Δ using a polar code of length n. It has been recently shown that this value of n scales as O (Δ^-μ), where the constant μ is known as the scaling exponent. In particular, if W is the binary erasure channel (BEC), then μ = 3.627. This is somewhat disappointing, since random codes achieve the (optimal) scaling exponent μ* = 2. As shown by Arıkan, channel polarization can be induced via a simple linear transformation: iterated Kronecker product of a 2 × 2 binary matrix G, called the polarization kernel, with itself. Is it possible to improve the scaling exponent of polar codes (on the BEC) if G is replaced by an ℓ × ℓ binary kernel matrix K for some integer ℓ ≥ 3? This is the question we address in the present paper. It was conjectured by Hassani that as ℓ → ∞, a random choice of the polarization kernel K approaches the optimal scaling exponent μ* = 2. However, herein, we are primarily interested in small values of ℓ. We begin with the fact that a given ℓ × ℓ polarization kernel K transforms ℓ copies of the underlying channel W into ℓ bit-channels W₁, W2,..., W_ℓ Notably, if W is a BEC with erasure probability z, then each of W₁, W₂,..., W∞ is also a BEC. The erasure probabilities of W₁, W2,..., W∞ are polynomials in z with integer coefficients and degree at most ℓ. We refer to the corresponding set of polynomials {p₁(z), p₂(z),..., p_ℓ(z)} as the polarization behavior of K; the scaling exponent of K is completely determined by its polarization behavior. We show that the polarization behavior can be characterized in terms of a nested chain of linear codes: {0} = C₀ ⊂ C₁ ⊂ ... ⊂ C_ℓ-1 ⊂ C_ℓ{0,1}^ℓ and use this nested chain of codes to prove that computing the polarization behavior is NP-hard. We further prove that an arbitrary ℓ × ℓ polarization kernel K can be transformed into a lower-triangular form without altering its polarization behavior. We then use this result to answer the following question: what is the smallest value of ℓ for which Arıkans scaling exponent μ(G) = 3.627 can be improved? We show that μ(K) ≥ 3.627 for all ℓ × ℓ kernels with ℓ ≤ 7. On the other hand, we explicitly construct an 8 × 8 matrix Kg with μ(K_g) = 3.577 (and prove that it is optimal for ℓ ≤ 8). We extend our construction of Kg into a general heuristic design method. Guided by this design method, we employ the coset structure of Reed-Muller codes and bent functions in order to explicitly construct a 16 × 16 kernel K₁₆(, with μ(K₁₆) = 3.356. We conjecture that this is optimal for ℓ ≤ 16.

Nontrivial t-designs over finite fields exist for all t

Abstract A t - ( n , k , λ ) design over F q is a collection of k -dimensional subspaces of F q n , called blocks, such that each t -dimensional subspace of F q n is contained in exactly λ blocks. Such t -designs over F q are the q -analogs of conventional combinatorial designs. Nontrivial t - ( n , k , λ ) designs over F q are currently known to exist only for t ⩽ 3 . Herein, we prove that simple (meaning, without repeated blocks) nontrivial t - ( n , k , λ ) designs over F q exist for all t and q , provided that k > 12 ( t + 1 ) and n is sufficiently large. This may be regarded as a q -analog of the celebrated Teirlinck theorem for combinatorial designs.

Generalized sphere packing bound: Applications

In this paper we study a generalization of the sphere packing bound for channels that are not regular (the size of balls with a fixed radius is not necessarily the same). Our motivation to tackle this problem is originated by a recent work by Kulkarni and Kiyavash who introduced a method, based upon tools from hypergraph theory, to calculate explicit upper bounds on the cardinalities of deletion-correcting codes. Under their setup, the deletion channel is represented by a hypergraph such that every deletion ball is a hyperedge. Since every code is a matching in the hypergraph, an upper bound on the codes is given by an upper bound on the largest matching in a hypergraph. This bound, called here the generalized sphere packing bound, can be found by the solution of a linear programming problem. We similarly study and analyze specific examples of error channels. We start with the Z channel and show how to exactly find the generalized sphere packing bound for this setup. Next studied is the non-binary limited magnitude channel both for symmetric and asymmetric errors. We focus on the case of single error and derive upper bounds on the generalized sphere packing bound in this channel. We follow up on the deletion case, which was the original motivation of the work by Kulkarni and Kiyavash, and show how to improve upon their upper bounds for the single deletion case. Finally, we apply this method for projective spaces and find its generalized sphere packing bound for the single-error case.

Generalized sphere packing bound: Basic principles

Kulkarni and Kiyavash recently introduced a new method to establish upper bounds on the size of deletion-correcting codes. This method is based upon tools from hypergraph theory. The deletion channel is represented by a hypergraph whose edges are the deletion balls (or spheres), so that a deletion-correcting code becomes a matching in this hypergraph. Consequently, a bound on the size of such a code can be obtained from bounds on the matching number of a hypergraph. Classical results in hypergraph theory are then invoked to compute an upper bound on the matching number as a solution to a linear-programming problem: the problem of finding fractional transversals. The method by Kulkarni and Kiyavash can be applied not only for the deletion channel but also for other channels, and in particular for those where the error spheres sizes are not all the same. This paper studies this method in its most general setup. We first show that if the error channel is regular and symmetric then the upper bound by this method coincides with the well-known sphere packing bound and thus is called here the generalized sphere packing bound. Even though this bound is explicitly given by a linear programming problem, finding its exact value may still be a challenging task. The art of finding the exact upper bound or slightly weaker ones is the assignment of weights to the hypergraphs vertices in a way that the satisfy the constraints in the linear programming problem. Every valid assignment yields an upper bound and the goal is to find assignments that provide strong upper bounds. We show that for graphs which satisfy a monotonicity property it is possible to find a general formula for such an assignment. Lastly, in order to simplify the complexity of the linear programming, we present a technique based upon graph automorphisms that in many cases can significantly reduce the number of variables and constraints in the linear programming problem. All of our results will be demonstrated and calculated for the Z channel which will be a case study in our work.

On Efficient Decoding of Polar Codes with Large Kernels

Defined through a certain 2×2 matrix called Arikans kernel, polar codes are known to achieve the symmetric capacity of binary-input discrete memoryless channels under the successive cancellation (SC) decoder. Yet, for short blocklengths, polar codes fail to deliver a compelling performance under the low complexity SC decoding scheme. Recent studies provide evidence for improved performance when Arikans kernel is replaced with larger kernels that have smaller scaling exponents. However, for l×l kernels the time complexity of the SC decoding increases by a factor of 2^l. In this paper we study a special type of kernels called permuted kernels. The advantage of these kernels is that the SC decoder for the corresponding polar codes can be viewed as a permuted version of the SC decoder for the conventional polar codes that are defined through Arikans kernel. This permuted successive cancellation (PSC) decoder outputs its decisions on the input bits according to a permuted order of their indices. We introduce an efficient PSC decoding algorithm and show simulations for two 16×16 permuted kernels that have better scaling exponents than Arikans kernel.

Permuted successive cancellation decoding for polar codes

Defined through a certain 2 × 2 matrix called Arikans kernel, polar codes are known to achieve the symmetric capacity of binary-input discrete memoryless channels under the successive cancellation (SC) decoder. Yet, for short block-lengths, polar codes fail to deliver a compelling performance under the low complexity SC decoding scheme. Recent studies provide evidence for improved performance when Arikans kernel is replaced with larger kernels that have smaller scaling exponents. However, for ℓ×ℓ kernels the time complexity of the SC decoding increases by a factor of 2ℓ. In this paper we study a special type of kernels called permuted kernels. The advantage of these kernels is that the SC decoder for the corresponding polar codes can be viewed as a permuted version of the SC decoder for the conventional polar codes that are defined through Arikans kernel. This permuted successive cancellation (PSC) decoder outputs its decisions on the input bits according to a permuted order of their indices. We introduce an efficient PSC decoding algorithm and show simulations for two 16 × 16 permuted kernels that have better scaling exponents than Arikans kernel.