🔢 mathematics

Construction of codes over a commutative non-unital ring from simplicial complexes and their applications

This paper constructs linear codes over a finite commutative non-unital ring using defining sets derived from simplicial complexes, analyzes their parameters and Gray images to identify families of divisible, minimal, and optimal codes, and demonstrates their applications in secret sharing, locally recoverable codes, and the construction of strongly regular graphs.

Original authors: Vidya Sagar, Shikha Patel, Sanjay Kumar Singh

Published 2026-06-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vidya Sagar, Shikha Patel, Sanjay Kumar Singh

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to send a secret message across a noisy, chaotic city. Sometimes, parts of the message get scrambled or lost. To fix this, mathematicians use error-correcting codes. Think of these codes as a special "packing method" where you wrap your message in extra layers of redundancy. If a piece gets damaged, the receiver can use the extra layers to figure out what the original message was supposed to be.

This paper is about inventing new, smarter ways to pack these messages. The authors, Vidya Sagar, Shikha Patel, and Sanjay Kumar Singh, are building these packing methods using a very specific, unusual type of mathematical "box" called a commutative non-unital ring.

Here is a breakdown of their work using simple analogies:

1. The Strange Box (The Ring)

Most standard codes use familiar number systems (like the integers or finite fields). This paper uses a "non-unital ring."

The Analogy: Imagine a standard number system is like a toolbox with a hammer, screwdriver, and a "master key" (the number 1) that can open everything.
The Paper's Box: The authors are using a toolbox that has hammers and screwdrivers, but no master key. It's a bit more restrictive and tricky to work with. They are building codes inside this restrictive box, then translating the results back into a standard language that computers can understand.

2. The Blueprint (Simplicial Complexes)

To decide which messages to pack, the authors use simplicial complexes.

The Analogy: Think of a simplicial complex as a set of Lego instructions. You have a base plate (the "maximal elements"), and the rules say: "If you build a tower on this spot, you must also build smaller towers on the spots underneath it."
The Application: They use these Lego rules to create a specific list of "defining sets." These lists act as the blueprint for the code. By changing the shape of the Lego instructions, they can create different types of codes with different strengths.

3. The Translation (Gray Map and Subfield-like Codes)

Since the "non-unital ring" box is hard to use directly, the authors translate the codes into two different languages:

The Gray Image: This is like taking a complex, abstract sculpture and casting it in concrete so it becomes a solid, standard shape. They translate the code from the strange ring into a standard field ( $F_q$ ) using a "Gray map."
Subfield-like Codes: This is like taking that same sculpture and carving a smaller, simpler version of it out of a different material.
The Result: Both translations produce codes that are "divisible." Imagine a code where every single message has a weight that is perfectly divisible by a specific number (like every package weighing exactly 10kg, 20kg, or 30kg). This predictability is very useful for mathematicians.

4. The Superpowers (Minimal, Optimal, and Self-Orthogonal)

The authors check if their new codes have "superpowers":

Minimal Codes: These are the most efficient messengers. In a "minimal" code, no part of the message is redundant in a way that another part could cover. It's like a team where every single member is essential; if you remove one, the team breaks.
Optimal Codes: These are the best possible codes for their size. You can't make them shorter or stronger without breaking the rules of math (specifically the Griesmer bound).
Self-Orthogonal Codes: Imagine a code that is its own shadow. If you compare the code to itself in a specific mathematical way, it "cancels out." This property is crucial for certain advanced cryptographic tasks.

5. Real-World Applications (What they actually built)

The paper doesn't just stay in theory; they show how these codes can be used in four specific areas:

Locally Recoverable Codes (LRCs):
- The Problem: In a giant warehouse of data, if one shelf breaks, you usually have to check the whole warehouse to fix it.
- The Solution: These codes allow you to fix a broken shelf by only looking at 2 or 3 other nearby shelves. It's like having a backup plan that only requires checking your immediate neighbors, saving time and energy.
Secret-Sharing Schemes:
- The Problem: How do you split a secret (like a nuclear launch code) among a group of people so that only a specific team can unlock it?
- The Solution: The authors used their codes to design "access structures." They determined exactly which groups of people (combinations of participants) are the minimum required to unlock the secret. It's like designing a puzzle where only specific combinations of keys can open the lock.
Few-Weight Codes:
- These are codes where the "weight" (the amount of data) only takes on a few specific values. This simplicity makes them easier to analyze and use in specific combinatorial designs.
Strongly Regular Graphs:
- The Analogy: Imagine a party where everyone is a vertex (a person). A "strongly regular graph" is a party with very strict social rules:
  1. Everyone has the exact same number of friends.
  2. If two people are friends, they share the exact same number of mutual friends.
  3. If two people are not friends, they also share the exact same number of mutual friends.
- The authors used their codes to build these specific "social networks" and calculated exactly how many people and connections they have. They even showed that if you flip the rules (making friends into enemies and vice versa), the new "party" is still perfectly organized.

Summary

In short, the authors took a difficult, restrictive mathematical environment (a non-unital ring), used geometric Lego-like rules (simplicial complexes) to build new codes, and translated them into standard formats. They proved these new codes are highly efficient, predictable, and can be used to fix data errors quickly, share secrets securely, and build perfectly structured social networks (graphs).

Technical Summary: Construction of Codes over a Commutative Non-Unital Ring from Simplicial Complexes and Their Applications

Problem Statement and Context
The paper addresses the construction of linear codes over finite rings, specifically focusing on a commutative non-unital ring $I$ of order $p^2$ and its extension $S$ of degree $r$ . While linear codes over finite fields and unital rings are well-established, the study of codes over non-unital rings is a more recent development. Previous works have explored quasi self-dual and self-orthogonal codes over non-unital rings, including the non-commutative ring $E$ of order $p^2$ . This work extends the investigation to the commutative non-unital ring $I$ and its extension $S$ , aiming to construct codes with optimal parameters using defining sets derived from simplicial complexes. The primary goal is to determine the weight distributions, minimality, and optimality of these codes and to explore their applications in secret-sharing schemes, locally recoverable codes (LRCs), and the construction of strongly regular graphs.

Methodology
The authors employ the defining set method to construct linear codes over the ring $S$ .

Ring Structure: The ring $S$ is defined as an extension of the commutative non-unital ring $I = \langle a, b \mid pa=0, pb=0, a^2=b, ab=0 \rangle$ . Elements in $S$ are of the form $as + bt$ where $s, t \in \mathbb{F}_q$ ( $q=p^r$ ).
Code Construction: A linear code $C_D$ of length $|D|$ is defined over $S$ using an ordered multiset $D \subseteq S^m$ as the defining set:
$C_D = \{ (v \cdot d)_{d \in D} : v \in S^m \}$
where the product $v \cdot d$ is defined via the ring multiplication rules.
Simplicial Complexes: The defining sets $D$ are constructed using simplicial complexes $\Delta$ over $\mathbb{F}_q^m$ . Specifically, the authors consider sets of the form $D = a\Delta_1 + b\Delta_2$ , where $\Delta_1$ and $\Delta_2$ are simplicial complexes (potentially with multiple maximal elements) and their complements.
Weight Analysis:
- Lee Weight: The Lee weight of codewords is analyzed using the Gray map $\Phi: S \to \mathbb{F}_q^2$ defined by $\Phi(as+bt) = (t, s+t)$ . The Lee weight is calculated as the Hamming weight of the Gray image.
- Subfield-like Codes: A projection map $\tau: S \to \mathbb{F}_q$ defined by $\tau(as+bt) = t$ is used to construct subfield-like codes $\tau(C_D)$ over $\mathbb{F}_q$ .
Analytical Tools: The authors utilize character sums, the principle of inclusion-exclusion, and properties of simplicial complexes (specifically maximal elements and their intersections) to derive explicit weight distributions and parameters.

Key Contributions and Results

Explicit Weight Distributions and Parameters:
The paper determines the Lee weight distributions for $S$ -linear codes where the defining sets are formed by combinations of simplicial complexes and their complements. Five distinct cases of defining sets ( $D = a\Delta_1 + b\Delta_2$ , $a\Delta_1 + b\Delta_2^c$ , etc.) are analyzed.
- The parameters (length, size, and minimum Lee distance) of the $S$ -linear codes are established.
- The Gray images $\Phi(C_D)$ and the subfield-like codes $\tau(C_D)$ are shown to be linear codes over $\mathbb{F}_q$ .
- Explicit weight distributions are provided for cases where the simplicial complexes have single maximal elements, revealing that many resulting codes are few-weight (specifically 1-weight or 2-weight) and divisible.
Minimality and Optimality:
- Minimality: Sufficient conditions are established under which the Gray image codes and subfield-like codes are minimal. A code is minimal if every non-zero codeword covers only its scalar multiples. The authors derive inequalities involving the sizes of the maximal elements of the simplicial complexes and the field size $q$ that guarantee minimality.
- Optimality: The paper investigates the optimality of these codes with respect to the Griesmer bound. Several families of codes are shown to be optimal under specific conditions on the parameters $m, |M|, |N|$ , and $q$ .
Self-Orthogonality:
Conditions are provided for the Gray image codes and subfield-like codes to be Euclidean or Hermitian self-orthogonal. These conditions depend on the divisibility of the codeword weights and the specific values of $q$ (e.g., $q=2, 3, 4$ ).
Applications:
- Locally Recoverable Codes (LRCs): The authors construct families of LRCs with locality 2 and 3. These codes are derived from the subfield-like codes $\tau(C_D)$ by selecting specific defining sets related to the non-zero elements of simplicial complexes.
- Secret-Sharing Schemes (SSS): The minimal access structures of secret-sharing schemes based on the duals of the constructed minimal codes are determined. The paper specifies the number of minimal access sets and the participation frequency of each participant.
- Strongly Regular Graphs (SRGs): By leveraging the correspondence between projective two-weight codes and SRGs, the paper constructs several families of strongly regular Cayley graphs. The parameters $(N, K, \lambda, \mu)$ of these graphs are explicitly determined. Furthermore, it is shown that the complement graphs of these SRGs are also strongly regular, with their parameters explicitly calculated.

Significance and Claims
The paper claims to advance the theory of codes over non-unital rings by successfully applying the simplicial complex approach to the commutative non-unital ring $I$ and its extension $S$ . The significance lies in:

Generating new families of divisible, few-weight codes over finite fields via Gray images and subfield-like constructions.
Providing explicit criteria for these codes to be minimal, optimal, and self-orthogonal, which are crucial for applications in cryptography and combinatorics.
Demonstrating the versatility of the construction by yielding codes suitable for Locally Recoverable Codes (critical for distributed storage) and Secret-Sharing Schemes (critical for secure data distribution).
Establishing a direct link between these algebraic constructions and Strongly Regular Graphs, providing a method to generate SRGs with specific parameters from coding theoretic principles.

The work does not propose experimental implementations or future theoretical extensions beyond the scope of the constructed codes and their immediate applications. It focuses on the algebraic derivation of parameters and the verification of their properties within the established framework of coding theory.