One-factorizations of complete multipartite graphs with distance constraints

The present paper considers multipartite graphs from the perspective of design theory and coding theory. A one-factor $F$ of the complete multipartite graph $K_{n\times g}$ (with $n$ parts of size $g$) gives rise to a $(g+1)$-ary code ${\cal C}$ of length $n$ and constant weight two. Furthermore, if the one-factor $F$ meets a certain constraint, then ${\cal C}$ becomes an optimal code with minimum distance three. We initiate the study of one-factorizations of complete multipartite graphs subject to distance constraints. The problem of decomposing $K_{n\times g}$ into the largest subgraphs with minimum distance three is investigated. It is proved that, for $n\le g$, the complete multipartite graph $K_{n\times g}$ can be decomposed into $g^2$ copies of the largest subgraphs with minimum distance three. For even $gn$ with $n>g$, it is proved that the complete multipartite graph $K_{n\times g}$ can be decomposed into $g(n-1)$ one-factors with minimum distance three, leaving a small gap of $n$ (in terms of $g$) to be resolved (If $gn$ is odd when $n>g$, no such decomposition of $K_{n\times g}$ exists).

💡 Research Summary

The paper investigates the interplay between one‑factorizations of the complete multipartite graph (K_{n\times g}) (with (n) parts each containing (g) vertices) and the construction of constant‑weight codes. A single one‑factor (F) of (K_{n\times g}) naturally yields a ((g+1))-ary code (\mathcal C) of length (n) and weight two: each edge of the matching connects two distinct parts, and the pair of parts where the edge lies is encoded as a non‑zero symbol while all other positions are zero. If the matching satisfies a specific “distance constraint” – namely that any two codewords differ in at least three positions – the resulting code attains minimum Hamming distance three, which is optimal for the given alphabet size and length.

The authors set out to decompose (K_{n\times g}) into as many subgraphs as possible that admit such distance‑3 one‑factors. Two regimes are treated:

1. (n\le g). In this case the part size dominates the number of parts. By employing Latin squares and suitable permutations, the authors construct (g^{2}) edge‑disjoint subgraphs, each of which contains a distance‑3 one‑factor. These subgraphs together partition the entire edge set of (K_{n\times g}). Consequently, the graph can be completely decomposed into the maximum possible number of distance‑3 substructures, and the associated codes achieve the theoretical bound on size.

2. (n>g) with even (gn). When there are more parts than vertices per part, a perfect matching that respects the distance constraint cannot cover all vertices. The paper shows that one can still obtain (g(n-1)) distance‑3 one‑factors, leaving exactly (n) vertices (one per part) uncovered. This “gap” is linear in (n) but negligible compared with the total number of vertices (gn). The authors prove that if (gn) is odd, no such decomposition exists at all, because a one‑factor requires an even number of vertices.

The technical core relies on combinatorial designs: Latin squares provide a systematic way to assign edges without conflict, while group‑theoretic arguments guarantee the existence of the required permutations. The notion of a “largest subgraph with minimum distance three” is introduced and its size is shown to be precisely (g^{2}) in the first regime and (g(n-1)) in the second.

From an application perspective, the results give a constructive method for generating optimal constant‑weight codes in settings where the underlying communication system naturally forms a multipartite structure (e.g., clustered sensor networks, multi‑cell wireless systems, or distributed storage with group‑wise locality). The distance‑3 property ensures that any two codewords differ in at least three symbols, providing single‑error detection and double‑error correction capabilities while keeping the code length and alphabet small.

The paper concludes with several open problems: eliminating the residual gap when (n>g) and (gn) is even, extending the constructions to other distance thresholds, and exploring alternative decompositions when (gn) is odd. Addressing these questions would further bridge graph‑theoretic factorization techniques with optimal code design, potentially leading to new families of codes with desirable error‑control properties.