We consider a point-to-point communication scenario as shown in Fig. 1 where the receiver maintains a linear function of a message vector . The message is an -length column vector over a finite field , where is any prime power, and A is an matrix over with and rank. Suppose the value of the message vector is updated to , where represents a sparse update to the message, i.e., we assume that where denotes the Hamming weight of a vector and is a known constant. In other words at the most entries of the original message are updated to new values. We assume that the transmitter has access to the updated message , but is unaware of the original message or the sparse update . Note that the message update is modelled here as substitutions only and not as insertions or deletions. The objective is to design a linear encoder that uses an matrix to generate the codeword , with as small a codelength as possible, such that the receiver can decode using the transmitted codeword and the older version of its content .
The problem is motivated by distributed storage systems (DSS) where information is stored in linearly coded form across a number of nodes to provide resilience against storage node failures . In the scenario where multiple users can simultaneously edit a single file stored in a DSS, it is possible that a user who wishes to apply his update is unaware of the current version of the message stored in the DSS, for instance when another user has recently edited this file. Letting the user first learn the version stored in the DSS, and then apply his update will incur additional communication cost. As an alternative, if it is known that the update vector is sparse, it is possible to design schemes that do not require the knowledge of the value of at the transmitter [1, 2, 3].
The function update problem was considered in [2, 3] for DSS’s for updating one of the storage nodes with the help of the other nodes in the system. Note that each node in a DSS stores a linear function of the message. A node can become stale in such systems, for instance if the node goes offline while the message and the corresponding linear functions stored in the other nodes undergo an update. Once it is back online, the stale node connects to the other nodes in the distributed storage system to update its own linear function, and the stale data already stored in this node acts as side information. The authors of [2, 3] design both the code for distributed storage and the code for function update to minimize the amount of data downloaded by the stale node to update its contents. This is unlike the problem statement considered in  as well as this paper, where it is assumed that an arbitrary matrix A is given and a code for updating the function is to be designed.
The authors in  also consider a broadcast scenario where a codeword is broadcast to multiple nodes in order to update the (different) linear functions stored in each of the nodes. Problems related to updating linear functions have been considered in [4, 5, 6]. In , codes for updating linear functions are used in cache-aided networks to reduce the cost of multicasting a sequence of correlated data frames. The problem of efficiently storing multiple versions of a file in a DSS while ensuring a property called consistency is considered in [5, 6].
Note that, if , the lower bound on the codelength can be trivially achieved by transmitting . Hence, we will always assume that . The results in  show that codelength is achievable using maximally recoverable subcodes of , the subspace spanned by the rows of A, which are guaranteed to exist if the field size . Note that this requirement imposed on the field size can be large even for moderate values of and . The authors of  also consider the special case where the matrix A is striped, i.e.,
where is the identity matrix, and denotes the Kronecker product. Note that and . This structure frequently arises in distributed storage systems where the -length data is partitioned into subvectors , each of length , each subvector is encoded independently by multiplying with , and all the encoded vectors are stored in a single storage node, see Examples 1–3 of . In [1, Section IV], a code is constructed for the case that achieves the codelength using an MDS code, which is guaranteed to exist if the field size . In Remark 4 of  the authors consider a modified system model for the function update problem which we show in Section V-A3 of this paper to be equivalent to the case where A is striped with the number of stripes . Construction 1 and Remark 4 of  provide a code construction for this modified system model, and hence for the case , that achieves codelength of over any field.
In this paper we provide a field-size aware characterization of the point-to-point function update problem. In particular, we provide bounds on the achievable codelength that take into account the effect of the field size and we provide constructions that trade-off the codelength for a smaller field size requirement. This is unlike the point-to-point results in  which provide constructions only for the case but assume that the field size is sufficiently large. To the best of our knowledge, no prior analysis of this problem as a function of the field size is available in the literature except  which assumes that the field size is large enough for a maximally recoverable code to exist.
We characterize the family of point-to-point function update problems where linear coding scheme is useful to save at least one transmission, i.e., is achievable (Theorem 3, Section III). This characterization is analyzed in terms of the covering radius of , the dual of the code , in Section III-B. We provide a lower bound (Theorem 4, Section IV) and an upper bound (Theorem 5, Section V) on optimal codelength based on linear error correcting codes. Similar to  we also provide code constructions when A is striped (Section V-A1,V-A2) but our focus is on the general case where and . For the case when we provide a construction (Section V-A1) which achieves the optimal codelength for the respective operating field size , for any prime power . For the special case this code construction achieves codelength and this matches the achieved codelength in Construction 2 of  for which also requires . Section V-A2 provides code constructions for using subspace codes and error correcting codes over field extensions. All these code constructions yield a trade-off between the chosen field size and achieved codelength where operating over a smaller field size results in a larger codelength than operating over a larger field size (for instance, see Example 3). When restricted to the special case our construction provides a valid coding scheme for the modified function update problem mentioned in [1, Remark 4] that matches codelength over any field reported in  (Section V-A3). The performance comparison of the constructed codes are discussed in Section V-A4. Finally, we show that the point-to-point function update problem is equivalent a functional index coding or a generalized index coding problem [7, 8, 9]. Given a point-to-point function update problem we construct a functional index coding problem (Algorithm 1, Section VI-B) such that a coding scheme is valid for the function update problem if and only if it is valid for the constructed functional index coding problem (Theorem 9, Section VI-B). This paper starts with describing the system model and providing relevant preliminary results in Section II.
Notation: Matrices and column vectors are denoted by bold uppercase and lowercase letters, respectively. For any positive integer , the symbol denotes the set . The Hamming weight of a vector is denoted as . The symbol denotes the finite field of size and denotes a column vector of elements over where is a prime power. The identity matrix is denoted as .
Ii System Model and Preliminaries
We consider a noiseless communication scenario with single transmitter and single receiver. The transmitter knows a column vector of information symbols where each information symbol is an element over finite field . The receiver stores the coded message where () and rank(A) = . Now suppose the information symbol vector is updated to where is the update vector which is also a column vector of length over with , where denotes the Hamming weight of a vector. The objective is to generate a codeword with codelength as small as possible such that the receiver can update its content to using the transmitted codeword and the older version of its content . We assume the transmitter doesn’t know about original information symbol vector or update vector but only knows the updated information symbol vector . The problem of designing coding scheme to update the coded data available at the receiver to with will be called as function update problem.
A valid encoding function of codelength for the function update problem over the field is a function
such that there exists a decoding function satisfying the following property: for every and with .
The objective of the code construction is to design a pair of encoding and decoding functions that minimizes the codelength and to calculate the optimal codelength over which is the minimum codelength among all valid coding schemes.
A coding scheme is said to be linear if the encoding function is an
-linear transformation. For a linear coding scheme, the codeword, where . The matrix is the encoder matrix of the linear coding scheme. The minimum codelength among all valid linear coding schemes for the function update problem over the field will be denoted as .
The trivial coding scheme that transmits the updated coded information symbols i.e., is a valid coding scheme with codelength since the receiver can directly update its content using . We refer to this trivial coding scheme as naive scheme where . Thus, we have the following trivial upper bound on the optimum linear codelength
In  the authors provided a necessary and sufficient condition for a matrix to be a valid encoder matrix for function update problem. In Theorem 2 of  the proof is given only for necessary condition for a matrix to be a valid encoder matrix for function update problem. For the sake of completeness here we first prove that the criterion 1 in [1, Theorem 2] is a necessary and sufficient condition for a matrix to be a valid encoder matrix for function update problem and then state the relevant results which will be helpful to derive other results of this paper. Let and denote the linear codes generated by the rows of A and respectively. Also let and let be a generator matrix of .
Theorem 1 (Theorem 2, ).
A matrix is a valid encoder matrix for the function update problem if and only if for any with and .
A matrix is a valid encoder matrix for the function update problem if and only if the receiver can uniquely determine from the received codeword and the side information . Hence for two pairs of information symbol vectors and update vectors and such that the coded information symbol vectors available at the receiver are identical i.e., but updated coded information symbol vectors are distinct i.e., then the transmitted codeword must be distinct from to distinguish the two different updated coded information symbol vectors. Equivalently, the condition should hold for every choice of with satisfying and . Therefore is a valid encoder matrix if and only if
for all such that and . Now denoting and we have
for all and such that and . Now reformulating the condition given in (2) we obtain for all that satisfy , and . Therefore is a valid encoder matrix if and only if for all and if and then . Hence is a valid encoder matrix if and only if for all with if then . Now using the fact that we deduce that is a valid encoder matrix if and only if for all with such that also satisfies . Hence the statement of the theorem follows. ∎
Lemma 1 (Remark 2, ).
Let be a valid encoder matrix for the function update problem. Let be a generator matrix of the code . Then is also a valid encoder matrix for the function update problem.
If we consider a valid encoder matrix such that , then we can find another valid encoder matrix as the generator matrix of the code . Since is a subcode of , we have . Therefore the encoder matrix has sub-optimal codelength. So from now we only consider encoder matrices such that . Since we assume we can write for some matrix .
Now using we restate Theorem 1 as follows. A matrix such that is a valid encoder matrix for the function update problem if and only if for any with and satisfies . We define the collection as the set of all vectors with such that i.e.,
A matrix for some matrix is a valid encoder matrix for the function update problem if and only if
Now we define the collection as the set of all non-zero linear combinations of or fewer columns of A over i.e.,
Note that since .
is a valid encoder matrix for the function update problem if and only if
Iii Necessary and Sufficient Condition for
In this section we will characterize the family of point-to-point function update problems where linear coding is useful to save at least one transmission compared to the naive scheme i.e., . First we will derive some preliminary results which will be helpful to derive the main result of this section.
The collection is closed under non-zero scalar multiplication.
Suppose . There exists a with such that . For any , , where . Now as , it follows that . Again as and . Therefore for any , . Hence the lemma holds. ∎
Iii-a A coding scheme for a family of function update problems
Consider any function update problem where there exists a non-zero such that . Let be the subspace of generated by . Therefore dim. Note that dim. Let be a generator matrix of the code . The matrix S is a parity check matrix of the code .
The matrix S satisfies for all .
Proof by contradiction. Let there exist a such that . This implies that . Therefore there exists an such that . Now as , exists and hence . Now as and is closed under non-zero scalar multiplication (using Lemma 3), which is a contradiction. Hence the lemma holds. ∎
Now using Corollary 1, we obtain a valid encoder matrix for the function update problem over as with codelength , whenever there exists a non-zero vector in . We do not claim that this coding scheme yields the optimal codelength .
Consider the function update problem over binary field where , , and the matrix is given by
Note that rank over . The non-zero vector satisfies . The parity check matrix of the code , generated by is given by
Therefore we obtain a valid encoder matrix with codelength for the function update problem as
Now we derive a necessary and sufficient condition for any function update problem to save at least one transmission using linear coding scheme compared to the naive scheme.
For an function update problem, if and only if .
To prove the theorem we first show that for any function update problem if then . Next we show that if then .
Proof of first part i.e., if then :
Let be an optimal encoder matrix with . Then there exists a matrix such that . From Corollary 1 we obtain for all . Since contains all non-zero vectors from , the columns of S are linearly independent. Hence . Again from (1), we have . Hence .
Proof of second part i.e., if then :
If then there exists a non-zero vector such that . Therefore using the technique described in Section III-A we can construct a valid encoder matrix such that we save one transmission compared to the naive scheme, i.e., . Hence the lemma holds. ∎
Now we provide a sufficient condition on the field size to save at least one transmission compared to the naive scheme for any function update problem.
For any with rank where ,
Using the fact that if then , we have
Now for any with rank, the number of distinct non-zero linear combinations of or fewer columns of A is at the most . Therefore . Hence . Now using Theorem 3 we have . ∎
Iii-B Relation with covering radius
The covering radius of an linear code over , denoted by , is defined as the smallest integer such that the spheres of radius centered at each codeword of cover the whole space . We can determine covering radius of a linear code in terms of the cosets of the code. For any vector , the set is called a coset of the code and in any coset, a vector with minimum Hamming weight is called a coset leader. The covering radius of the code is the largest among the Hamming weight of all the coset leaders. Upon denoting as a parity check matrix of , is the syndrome of the vector . Two vectors have the same syndrome if and only if they belong to the same coset of . Hence there is an one-to-one correspondence between syndromes and cosets .
For the function update problem let be the linear code generated by A. Hence A is a parity check matrix of the code which is the dual code of . Now considering a vector , can be expressed as where with . Therefore the vector denotes the syndrome of a vector with that belongs to some coset of . Note that any vector that belongs to is non-zero, hence can not be the syndrome of the codewords of . Note that is the syndrome of the coset leader of the coset . Since is a vector that belongs to the coset and , the Hamming weight of the coset leader of the coset is at the most .
For an function update problem, if and only if .
From Theorem 3 we have if and only if . Hence to prove the corollary we prove that for any function update problem if and only if .
Proof of if : Since the collection contains all non-zero vectors over , each non-zero vector is the syndrome of some vector with that belongs to some coset of . Since there exists a one-to-one correspondence between the syndromes and cosets, for each vector there exists a coset of that contains a vector with . Hence the coset leader of each coset has Hamming weight at the most . Therefore the largest Hamming weight of the coset leaders among all cosets of is at the most . Hence .
Proof of if : Since , the largest Hamming weight of the coset leaders among all cosets of is at the most . Since there exists a one-to-one correspondence between the syndromes and cosets, each syndrome can be expressed as for some coset leader satisfies . We know that the syndromes of a particular linear code covers the whole space. Hence any vector can be expressed as for some with . Since consists only non-zero vectors that satisfies the above property, .
Hence if and only if . ∎
In this example we calculate the minimum number of rows of such that is guaranteed for , and . Now if and only if . From Table I of  we observe that for any binary code of length and dimension up to , covering radius is at least . Thus dim implies . Hence and . Therefore for any matrix with rank we can save one transmission compared to the naive scheme. One such example of A is given in Example 1. ∎
Iv Lower Bound on Optimal Codelength
In this section we derive a lower bound on the optimal codelength over . First we derive two preliminary lemmas which will help to derive the lower bound.
For any function update problem and for any invertible matrix
function update problem and for any invertible matrix, .
To prove the lemma we first show that and then .
Proof for : Suppose . Then from (3) we have . Now left multiplying both side by K we obtain since K is invertible. Hence .
Proof for : Suppose . Then from (3) we have . Since K is invertible, exists. Now left multiplying both side by we obtain . Hence .
Hence the lemma holds. ∎
For any function update problem with rank(A)=. Hence A contains linearly independent columns. Now consider a matrix which contains linearly independent columns of A. Note that is an full rank matrix and hence invertible. Denote and . From Lemma 4 we observe that and are equivalent function update problems and any matrix is a valid encoder matrix of function update problem if and only if is a valid encoder matrix of function update problem. Hence we conclude that the linear code generated by the rows of is a subcode of the linear code generated by the rows of i.e., . Hence there exists a matrix such that . Now using the equivalence between and function update problems and using Corollary 1 we say that is a valid encoder matrix of the function update problem if and only if for all .
Let be the set of all non-zero vectors in of Hamming weight at the most .
For any function update problem
For an function update problem, where and consists of linearly independent columns of A. Note that the sub-matrix of that contains the corresponding columns forms an identity matrix. Now if we consider any non-zero linear combination of of fewer columns of this sub-matrix we obtain all non-zero vectors over with Hamming weight at the most . Hence . The last equality holds due to Lemma 4. ∎
Let be the maximum dimension among all linear codes over with blocklength and minimum distance .
The optimal codelength of the function update problem over satisfies
Let be an optimal encoder matrix of function update problem with codelength . Then there exists a matrix such that . Now using Corollary 1 we have for all . Since , it follows that for all . Therefore any set of columns of S are linearly independent. Hence S is a parity check matrix of a linear code of block length and minimum distance at least . Thus the dimension of this code satisfies . Then . ∎
Theorem 4 provides a lower bound that is aware of the field size . This is tighter than the bound given in [2, 3, 1] since from Singleton bound we know that , and this combined with Theorem 4 yields . Hence, irrespective of the matrix A, a necessary condition for is that an MDS code over must exist.
V Code constructions
In this section we first derive an upper bound on the optimal codelength over and then provide code constructions for function update problem when A is in form given by (4). Define .
The optimal codelength of the function update problem over satisfies
From Corollary 1 we have that a matrix for some matrix , is a valid encoder matrix if and only if . To satisfy this condition it is sufficient that any set of columns of S are linearly independent. Now consider S as a parity check matrix of the largest linear code with blocklength and minimum distance . The resulting codelength . Hence the upper bound on the optimal codelength holds. ∎
V-a Code constructions for striped data
In this section we provide linear code construction of an function update problem where follows the structure given by
where and is a matrix over whose all elements are . Let be the number of repetitions of in the matrix . Hence we write and . First we consider the family of function update problems where and show that for this case the lower bound on optimal codelength given in Theorem 4 and the upper bound on optimal codelength given in Theorem 5 exactly matches with each other. Hence we characterize the optimal codelength for this family of function update problems. Our code construction is based on an appropriately chosen linear error correcting code. Note that in Section IV of  the authors provided a linear code construction based on maximally recoverable subcodes (MRSC) which requires field size and uses an MDS code. In comparison our code construction is suitable for any field size.
V-A1 Code Constructions for the family of function update problems with
In this sub-section we first calculate the optimal codelength for such family of function update problems and then provide a code construction based on an appropriately chosen linear error correcting code.
For the family of function update problems with the optimal codelength over