Non-Existence of Some Function-Correcting Codes With Data Protection

Abstract: In this paper, we consider the recently introduced concept of \emph{function-correcting codes (FCCs) with data protection}, which provide a certain level of error protection for the data and a higher level of protection for a desired function on the data. These codes are denoted by $(f!:!d_d,d_f)$-FCC, where $d_d$ is the minimum distance of the code and $d_f$ denotes the minimum distance between those codewords that correspond to different function values of a function $f:\mathbb{F}_q^k \to \mathrm{Im}(f)$, with $d_f \geq d_d$. We use a distance graph on a code based on the pairwise distances of its codewords, and show conditions under which a code cannot work as a \emph{strict} $(f!:!d_d,d_f)$-FCC, that is, code for which $d_f > d_d$. We then consider some well-known classes of codes, such as perfect codes and maximum distance separable (MDS) codes, and show that they cannot be used as \emph{strict} $(f!:!d_d,d_f)$-FCCs.

• The paper demonstrates that optimal classical codes, such as perfect codes, MDS codes, and linear codes spanned by minimum-weight codewords, cannot provide strictly stronger protection for function values than for the data itself.
• The analysis relies on an $\alpha$-distance graph framework, leveraging the graph connectivity and combination structure to derive non-existence proofs of strict FCCs based on the covering radius of the linear code.
• The 'connectivity-obstruction' theorem is central, showing that if a code’s minimum-distance graph is connected, then it cannot be an $(f:d,d_f)$-FCC for any functions where $d_f > \alpha$.
• follow_up_questions
• Follow Up Questions
• How does the $\alpha$-distance graph framework apply to other types of error-correcting codes?
• What are the implications of these findings for the design of new function-correcting codes that do offer strict data protection?
• How does this analysis impact the study of function-correcting codes with symbols and pairs-h?
• What metrics are currently used to measure the efficiency and effectiveness of function-correcting codes?
• Find recent papers on function correctness of coding and total analysis.
• output_files
• save.title.txt
• save.meta_description.txt
• save.key_takeaways.txt
• save.follow_up_questions.txt

Background and motivation

Function-correcting codes (FCCs), introduced by Lenz et al. [(Singh et al., 17 Mar 2025) is unrelated; the foundational reference here is the IEEE TIT paper cited as LBWY2023], relax classical error-correction requirements by imposing distance constraints only between codewords whose associated function values differ. This permits lower redundancy when the image of the function $f:\mathbb{F}_q^k \to \mathrm{Im}(f)$ is much smaller than its domain, and a substantial literature has since developed bounds and constructions for specific channel models (symbol-pair and $b$-symbol read channels), metrics (Lee, homogeneous distance), and function classes (locally binary, locally bounded, Hamming weight).

A structural shortcoming of all prior FCC definitions is that they provide no guarantee for the data itself: pairs of messages mapping to the same function value may be encoded at arbitrarily small distance. The framework of FCCs with data protection, introduced in the companion work (Rajput et al., 23 Nov 2025), remedies this. An encoding $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$ is an $(f\!:\!d_d,d_f)$-FCC if every pair of distinct messages is at distance at least $d_d$, while every pair with different function values is at distance at least $d_f$, where $d_d \le d_f$. The case $d_f = d_d$ collapses to an ordinary error-correcting code; the interesting regime is that of strict $(f\!:\!d_d,d_f)$-FCCs, where $d_f > d_d$ and the function enjoys strictly stronger protection than the data.

The present paper addresses a natural feasibility question: can well-known optimal families of classical codes be repurposed as strict FCCs? The answer developed here is negative in broad generality, established through a graph-theoretic analysis of code distance structure.

The $b$0-distance graph framework

The central object is the $b$1-distance graph $b$2 of a code $b$3, whose vertices are the codewords and whose edges connect pairs at Hamming distance at most $b$4, for $b$5. The minimum-distance graph $b$6 corresponds to $b$7. Since $b$8 is monotone in $b$9, connectivity at smaller $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$0 yields stronger conclusions.

The key observation is elementary but consequential: if $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$1 were an $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$2-FCC with $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$3, then the partition of $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$4 into fibers $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$5 would place no edges of $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$6 between distinct fibers. Hence:

• Connectivity obstruction: if $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$7 is connected, then $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$8 cannot be an $$\mathfrak{C}_f:\mathbb{F}_q^k \to \mathbb{F}_q^{k+r}$$9-FCC for any nonconstant $(f\!:\!d_d,d_f)$0 with $(f\!:\!d_d,d_f)$1.
• Component-count refinement: if $(f\!:\!d_d,d_f)$2 has $(f\!:\!d_d,d_f)$3 connected components, no strict FCC exists for any $(f\!:\!d_d,d_f)$4 with $(f\!:\!d_d,d_f)$5 and $(f\!:\!d_d,d_f)$6.

The bridge from these combinatorial conditions to classical code parameters is a covering-radius lemma: any two disconnected components of $(f\!:\!d_d,d_f)$7 must lie at mutual distance exceeding $(f\!:\!d_d,d_f)$8, and a midpoint argument shows that the distance between any bipartition of $(f\!:\!d_d,d_f)$9 is at most $d_d$0, where $d_d$1 is the covering radius. Consequently $d_d$2 is connected whenever $d_d$3, yielding the general exclusion: a code with covering radius $d_d$4 cannot serve as a strict $d_d$5-FCC for any nontrivial $d_d$6 with $d_d$7.

Perfect codes

A perfect $d_d$8-error-correcting code attains the Hamming bound and has covering radius exactly $d_d$9. Applying the covering-radius lemma with $d_f$0, the minimum-distance graph of every perfect code is connected. The immediate corollary is a quantitative redundancy statement: any $d_f$1-FCC with $d_f$2 built on top of a perfect-code-length parameter must satisfy

$d_f$3

where $d_f$4 is determined by the Hamming bound equality $d_f$5. In other words, achieving even one unit of extra function protection costs at least the full redundancy of the underlying perfect code — such codes offer no "free" headroom for stricter function distances.

MDS codes

For maximum distance separable codes, connectivity of the minimum-distance graph is proved directly rather than via the covering radius. The proof rests on a projection argument exploiting the defining MDS property that every projection onto $d_f$6 coordinates is bijective. Given codewords $d_f$7, one constructs a neighbor $d_f$8 of $d_f$9 in $d_d \le d_f$0 (i.e., $d_d \le d_f$1) that agrees with $d_d \le d_f$2 on strictly more coordinates than $d_d \le d_f$3 does, so that $d_d \le d_f$4. Iterating this descent produces a path from any $d_d \le d_f$5 to any $d_d \le d_f$6, establishing connectivity of $d_d \le d_f$7 for every MDS code.

The consequence mirrors the perfect-code case: assuming an MDS $d_d \le d_f$8 code exists ($d_d \le d_f$9), any $d_f = d_d$0-FCC with $d_f = d_d$1 requires redundancy $d_f = d_d$2. Since $d_f = d_d$3 is already the full redundancy of the MDS code itself, MDS codes cannot provide strictly stronger function protection than data protection without additional redundancy beyond their Singleton-optimal allocation.

Linear codes spanned by minimum-weight codewords

The graph framework also admits a clean characterization for linear codes. For a linear $d_f = d_d$4 code over $d_f = d_d$5, adjacency in $d_f = d_d$6 corresponds to differences lying in $d_f = d_d$7, the set of minimum-weight codewords. It follows that $d_f = d_d$8 is connected if and only if $d_f = d_d$9: if the minimum-weight codewords span $(f\!:\!d_d,d_f)$0, every codeword is reachable from zero along minimum-weight steps; otherwise, the cosets of the proper subcode $(f\!:\!d_d,d_f)$1 form disconnected components. Many familiar linear codes satisfy the spanning condition, so Corollary col:LC excludes them wholesale as strict FCCs for any nontrivial function with $(f\!:\!d_d,d_f)$2.

Extensions via known covering radii

Because only an upper bound on the covering radius is needed, the non-existence criterion extends to further families:

• Quasi-perfect codes (one-coordinate extensions of perfect codes, e.g., extended Hamming and extended Golay codes) have covering radius $(f\!:\!d_d,d_f)$3, excluding strict FCCs with $(f\!:\!d_d,d_f)$4.
• First-order Reed–Muller codes $(f\!:\!d_d,d_f)$5 have exact covering radius $(f\!:\!d_d,d_f)$6, giving explicit thresholds.
• General linear codes are covered by the Janwa–Mattson bound $(f\!:\!d_d,d_f)$7 in terms of the dual distance $(f\!:\!d_d,d_f)$8, and higher-order Reed–Muller codes by the Cohen–Litsyn upper bounds.

These results convert any published covering-radius estimate into a concrete non-existence threshold for strict FCCs.

Limitations and open questions

The results are inherently negative and conditional on the structure of existing codes; they do not establish existence of strict $(f\!:\!d_d,d_f)$9-FCCs for any particular parameters, nor do they determine the optimal redundancy $d_f > d_d$0 in cases where strict codes do exist. The covering-radius route gives sufficient, not necessary, conditions for connectivity, so codes with large covering radius may still fail to be strict FCCs for finer reasons left unexplored here. The component-count theorem (Theorem aDG2) suggests that codes whose minimum-distance graphs have few components could still support functions with small images at modestly elevated $d_f > d_d$1; characterizing which codes admit such partial exclusions remains open. Finally, the analysis is confined to systematic encodings over the Hamming metric; extensions to other metrics or to the $d_f > d_d$2-symbol and symbol-pair settings studied elsewhere in the FCC literature are not addressed.

Conclusion

This paper develops an $d_f > d_d$3-distance-graph framework under which the feasibility of strict function-correcting codes with data protection reduces to connectivity properties of codes. The main conclusions are that perfect codes, MDS codes, and linear codes spanned by their minimum-weight codewords cannot provide strictly greater protection for function values than for data, and that any upper bound on a code's covering radius translates directly into a non-existence threshold $d_f > d_d$4. These findings delineate the structural limits of repurposing optimal classical codes for hierarchical data-and-function protection, and indicate that strict FCCs, where they exist, require code constructions beyond the standard optimal families.