LOCO Codes: Lexicographically-Ordered Constrained Codes

TL;DR

LOCO codes are a new family of capacity-achieving, lexicographically-ordered constrained codes for bipolar signaling, offering simple encoding/decoding, ease of balancing, and improved rate performance in magnetic and optical recording systems.

Contribution

This paper introduces LOCO codes, a novel class of fixed-length, binary constrained codes with practical encoding/decoding and minimized rate loss, applicable to magnetic and Flash storage systems.

Findings

LOCO codes achieve up to 10% higher rate than existing codes.

LOCO codes enable about 20% channel density gain in magnetic recording.

LOCO codes simplify encoding and decoding processes.

Abstract

Line codes make it possible to mitigate interference, to prevent short pulses, and to generate streams of bipolar signals with no direct-current (DC) power content through balancing. They find application in magnetic recording (MR) devices, in Flash devices, in optical recording devices, and in some computer standards. This paper introduces a new family of fixed-length, binary constrained codes, named lexicographically-ordered constrained codes (LOCO codes), for bipolar non-return-to-zero signaling. LOCO codes are capacity-achieving, the lexicographic indexing enables simple, practical encoding and decoding, and this simplicity is demonstrated through analysis of circuit complexity. LOCO codes are easy to balance, and their inherent symmetry minimizes the rate loss with respect to unbalanced codes having the same constraints. Furthermore, LOCO codes that forbid certain patterns can be used to alleviate inter-symbol interference in MR systems and inter-cell interference in Flash systems. Numerical results demonstrate a gain of up to 10% in rate achieved by LOCO codes with respect to other practical constrained codes, including run-length-limited codes, designed for the same purpose. Simulation results suggest that it is possible to achieve a channel density gain of about 20% in MR systems by using a LOCO code to encode only the parity bits, limiting the rate loss, of a low-density parity-check code before writing.

Tables

Table 1. TABLE I: All the codewords of six LOCO codes, 𝒞 m , 1 subscript 𝒞 𝑚 1 \mathcal{C}_{m,1} , m ∈ { 1 , 2 , … , 6 } 𝑚 1 2 … 6 m\in\{1,2,\dots,6\} . The four different groups of codewords are explicitly illustrated for the code 𝒞 6 , 1 subscript 𝒞 6 1 \mathcal{C}_{6,1} .

Codeword index $g\left(𝕔\right)$	Codewords of the code ${𝒞}_{m,1}$
	$m=1$	$m=2$	$m=3$	$m=4$	$m=5$	$m=6$
$0$	$0$	$00$	$000$	$0000$	$00000$	$000000$	Group 1
$1$	$1$	$01$	$001$	$0001$	$00001$	$000001$
$2$		$10$	$011$	$0011$	$00011$	$000011$
$3$		$11$	$100$	$0110$	$00110$	$000110$
$4$			$110$	$0111$	$00111$	$000111$
$5$			$111$	$1000$	$01100$	$001100$
$6$				$1001$	$01110$	$001110$
$7$				$1100$	$01111$	$001111$
$8$				$1110$	$10000$	$011000$	Group 4
$9$				$1111$	$10001$	$011001$
$10$					$10011$	$011100$
$11$					$11000$	$011110$
$12$					$11001$	$011111$
$13$					$11100$	$100000$	Group 3
$14$					$11110$	$100001$
$15$					$11111$	$100011$
$16$						$100110$
$17$						$100111$
$18$						$110000$	Group 2
$19$						$110001$
$20$						$110011$
$21$						$111000$
$22$						$111001$
$23$						$111100$
$24$						$111110$
$25$						$111111$
Code cardinality	$N(1,1)\triangleq 2$	$N(2,1)=4$	$N(3,1)=6$	$N(4,1)=10$	$N(5,1)=16$	$N(6,1)=26$

Table 2. TABLE II: Bridging patterns of the second method for LOCO codes with x = 1 𝑥 1 x=1 .

RMB(s) at instance $t$	Bridging pattern	LMB(s) at instance $t+1$
$0$	$0$	$0$
$0$	$0$	$11$
$00$	$1$	$10$
$01$	$z$	$01$
$10$	$z$	$10$
$11$	$0$	$01$
$1$	$1$	$00$
$1$	$1$	$1$

Table 3. TABLE III : The C-LOCO code 𝒞 6 , 1 c superscript subscript 𝒞 6 1 c \mathcal{C}_{6,1}^{\textup{c}} for all messages.

Message	$g\left(𝕔\right)$	Codeword $𝕔$
$0000$	$1$	$000001$
$0001$	$2$	$000011$
$0010$	$3$	$000110$
$0011$	$4$	$000111$
$0100$	$5$	$001100$
$0101$	$6$	$001110$
$0110$	$7$	$001111$
$0111$	$8$	$011000$
$1000$	$9$	$011001$
$1001$	$10$	$011100$
$1010$	$11$	$011110$
$1011$	$12$	$011111$
$1100$	$13$	$100000$
$1101$	$14$	$100001$
$1110$	$15$	$100011$
$1111$	$16$	$100110$

Table 4. TABLE IV: Rates and adder sizes of C-LOCO codes 𝒞 m , x c superscript subscript 𝒞 𝑚 𝑥 c \mathcal{C}_{m,x}^{\textup{c}} for different values of m 𝑚 m and x 𝑥 x . The capacity is 0.6942 0.6942 0.6942 for x = 1 𝑥 1 x=1 and 0.5515 0.5515 0.5515 for x = 2 𝑥 2 x=2 .

Values of $m$ and $x$	$R_{\text{LOCO}}^{\text{c}}$	Adder size
$m=8$, $x=1$	$0.6667$	$6$ bits
$m=18$, $x=1$	$0.6842$	$13$ bits
$m=31$, $x=1$	$0.6875$	$22$ bits
$m=44$, $x=1$	$0.6889$	$31$ bits
$m=54$, $x=1$	$0.6909$	$38$ bits
$m=90$, $x=1$	$0.6923$	$63$ bits
$m=6$, $x=2$	$0.5000$	$4$ bits
$m=13$, $x=2$	$0.5333$	$8$ bits
$m=24$, $x=2$	$0.5385$	$14$ bits
$m=33$, $x=2$	$0.5429$	$19$ bits
$m=42$, $x=2$	$0.5455$	$24$ bits
$m=91$, $x=2$	$0.5484$	$51$ bits

Table 5. TABLE V : The selection criterion for balancing in a B-LOCO code 𝒞 m , x b superscript subscript 𝒞 𝑚 𝑥 b \mathcal{C}_{m,x}^{\textup{b}} . If p r = 0 subscript 𝑝 r 0 p_{\textup{r}}=0 or/and p ​ ( 𝕔 0 ) = p ​ ( 𝕔 1 ) = 0 𝑝 superscript 𝕔 0 𝑝 superscript 𝕔 1 0 p(\mathbb{c}^{0})=p(\mathbb{c}^{1})=0 , select 𝕔 = 𝕔 0 𝕔 superscript 𝕔 0 \mathbb{c}=\mathbb{c}^{0} .

$\text{sign}\left(p_{\text{r}}\right)$	Selected codeword $𝕔$
$+$	${𝕔}^0$ or ${𝕔}^1$ such that $\text{sign}\left(p\left(𝕔\right)\right)$ is $-$
$-$	${𝕔}^0$ or ${𝕔}^1$ such that $\text{sign}\left(p\left(𝕔\right)\right)$ is $+$

Table 6. TABLE VI : The B-LOCO code 𝒞 6 , 1 b superscript subscript 𝒞 6 1 b \mathcal{C}_{6,1}^{\textup{b}} . The CB-LOCO code 𝒞 6 , 1 cb superscript subscript 𝒞 6 1 cb \mathcal{C}_{6,1}^{\textup{cb}} for all messages is the rows having g b ​ ( 𝕔 ) ∈ { 1 , 2 , … , 8 } superscript 𝑔 b 𝕔 1 2 … 8 g^{\textup{b}}(\mathbb{c})\in\{1,2,\dots,8\} .

Message	$g^{\text{b}}\left(𝕔\right)$	${𝕔}^0$	$p\left({𝕔}^0\right)$	${𝕔}^1$	$p\left({𝕔}^1\right)$
	$0$	$000000$	$-6$	$111111$	$+6$
$000$	$1$	$000001$	$-4$	$111110$	$+4$
$001$	$2$	$000011$	$-2$	$111100$	$+2$
$010$	$3$	$000110$	$-2$	$111001$	$+2$
$011$	$4$	$000111$	$0$	$111000$	$0$
$100$	$5$	$001100$	$-2$	$110011$	$+2$
$101$	$6$	$001110$	$0$	$110001$	$0$
$110$	$7$	$001111$	$+2$	$110000$	$-2$
$111$	$8$	$011000$	$-2$	$100111$	$+2$
	$9$	$011001$	$0$	$100110$	$0$
	$10$	$011100$	$0$	$100011$	$0$
	$11$	$011110$	$+2$	$100001$	$-2$
	$12$	$011111$	$+4$	$100000$	$-4$

Table 7. TABLE VII: Rates and adder sizes of CB-LOCO codes 𝒞 m , x cb superscript subscript 𝒞 𝑚 𝑥 cb \mathcal{C}_{m,x}^{\textup{cb}} for different values of m 𝑚 m and x 𝑥 x . The unbalanced capacity is 0.6942 0.6942 0.6942 for x = 1 𝑥 1 x=1 and 0.5515 0.5515 0.5515 for x = 2 𝑥 2 x=2 .

Values of $m$ and $x$	$R_{\text{LOCO}}^{\text{cb}}$	Adder size
$m=14$, $x=1$	$0.6000$	$9$ bits
$m=24$, $x=1$	$0.6400$	$16$ bits
$m=44$, $x=1$	$0.6667$	$30$ bits
$m=54$, $x=1$	$0.6727$	$37$ bits
$m=80$, $x=1$	$0.6790$	$55$ bits
$m=116$, $x=1$	$0.6838$	$80$ bits
$m=8$, $x=2$	$0.4000$	$4$ bits
$m=15$, $x=2$	$0.4706$	$8$ bits
$m=24$, $x=2$	$0.5000$	$13$ bits
$m=42$, $x=2$	$0.5227$	$23$ bits
$m=73$, $x=2$	$0.5333$	$40$ bits
$m=120$, $x=2$	$0.5410$	$66$ bits

Equations

$${\mathcal{T}}_x\triangleq \{010,101,0110,1001,\dots ,01^{x}0,10^{x}1\};$$

$$\{$$

$$N(m,x)\triangleq 2,m\le 1.$$

$$N(m,x)=N(m-1,x)+N(m-x-1,x),m\ge 2.$$

$$N_1(m,x)=\frac{1}{2}N(m-1,x).$$

$$N_4(m,x)=\frac{1}{2}N(m-x-1,x).$$

$$N(m,x)$$

$$=N(m-1,x)+N(m-x-1,x),$$

$$N_2(m,x)=\frac{1}{2}N(m-1,x),$$

$$N_3(m,x)=\frac{1}{2}N(m-x-1,x).$$

$$N(m,1)=N(m-1,1)+N(m-2,1).$$

$$N(2,1)$$

$$N(3,1)$$

$$N(4,1)$$

$$N(5,1)$$

$$N(6,1)$$

$$N_1(6,1)$$

$$N_2(6,1)$$

$$N_3(6,1)$$

$$N_4(6,1)$$

$${\zeta }_{\ell }\triangleq g(m+1,x,c^{\prime })-g(m,x,c),\ell \in \{1,2\},$$

$${\zeta }_{\ell }=\{\begin{array}{cc}0,& \ell =1,\\ N(m-x,x),& \ell =2.\end{array}$$

$${\zeta }_1=g(m+1,x,c^{\prime })-g(m,x,c)=0.$$

$${\zeta }_2$$

$$=N_1(m+1,x)+N_4(m+1,x)$$

$$+N_3(m+1,1)-\frac{1}{2}N(m,x)$$

$$=\frac{1}{2}N(m,x)+\frac{1}{2}N(m-x,x)$$

$$+\frac{1}{2}N(m-x,x)-\frac{1}{2}N(m,x)$$

$$=N(m-x,x).$$

$${\zeta }_1$$

$${\zeta }_2$$

$$a_i\triangleq \{\begin{array}{cc}1,& c_i=1,\\ 0,& c_i=0.\end{array}$$

$$g(c)=\frac{1}{2}\left[a_{m-1}N(m,x)+\sum _{i=0}^{m-2}{a}_{i}N(i-x+1,x)\right].$$

$$g(c_0)$$

$$g(c_1)$$

$$=\frac{1}{2}N(-x+1,x)=1,$$

$$g(c_2)$$

$$=\frac{1}{2}\left[4+0\right]=2,$$

$$g(c_3)$$

$$=\frac{1}{2}\left[4+N(-x+1,x)\right]=\frac{1}{2}\left[4+2\right]=3.$$

Full text

I Introduction

From data storage to data transmission, line codes are employed in many systems to achieve a variety of goals. An important early example, introduced in [3], is the family of run-length-limited (RLL) codes used to mitigate inter-symbol interference (ISI) in magnetic recording (MR) systems by appropriately separating transitions. RLL codes are associated with bipolar non-return-to-zero inverted (NRZI) signaling, where a [math] is represented by no transition and a $1$ is represented by a transition, with the transitions being from $-A$ to $+A$, $A>0$, and vice versa. RLL codes are characterized by a pair of parameters, $(d,k)$, where $d$ (resp., $k$) is the minimum (resp., maximum) number of [math]’s between adjacent $1$’s. The parameter $d$ separates transitions, and the parameter $k$ supports self-clocking by ensuring frequent transitions. A variable-length fixed-rate $(2,7)$ RLL code appeared in the IBM 3370, 3375, and 3380 disk drives [4], and the issue of error propagation for $(2,7)$ RLL codes was studied in [5].

For simplicity, we abbreviate a run of $r$ consecutive [math]’s (resp., $1$’s) to $\mathbb{0}^{r}$ (resp., $\mathbb{1}^{r}$). A $\mathcal{T}_{x}$-constrained code is a code that forbids the patterns in $\mathcal{T}_{x}\triangleq\{0\mathbb{1}^{y}0,1\mathbb{0}^{y}1\text{ }|\text{ }1\leq y\leq x\}$ from appearing in any codeword. $\mathcal{T}_{x}$-constrained codes are associated with bipolar non-return-to-zero (NRZ) signaling, where a [math] is represented by level $-A$ and a $1$ is represented by level $+A$. The parameter $x$ separates transitions, which mitigates ISI, serving the same purpose as the parameter $d$ in RLL codes. For example, transitions separated by one bit duration can be prevented by a $\{010,101\}$-constrained code with NRZ signaling, or a $(1,\infty)$ RLL code with NRZI signaling. We focus in this paper on $\mathcal{T}_{x}$-constrained codes.

Constrained codes were used to extend the life of MR systems employing peak detection, and they continue to be used in modern MR systems [6, 7] to improve the performance of sequence detection on partial response (PR) channels such as extended PR4 (EPR4 and E2PR4) channels [8, 9]. PR channels with equalization targets that follow the channel impulse response [10] require forbidden patterns to be symmetric. Moreover, constrained codes improve the performance on low resolution media by preventing short pulses, which might be missed when reading [11]. As $x$ for a $\mathcal{T}_{x}$-constrained code or $d$ for an RLL code increases, the minimum width of a pulse in the stream to be written increases.

The requirement that the power spectrum of a line code vanishes at frequency zero, i.e., the code is direct-current-free (DC-free), is important in optical recording [12] and in digital communication over transmission lines. This requirement is typically accomplished by balancing signal signs in the stream of transmitted (written) codewords. The author in [13] developed a particularly elegant method of achieving balance, which requires the addition of more than $\log_{2}m$ bits, where $m$ is the code length, and this method was later tailored to RLL codes [14]. The null at DC can be widened by constraining the higher order statistics of line codewords (see [15] and [16] for a frequency domain approach).

Constrained codes also find application in Flash memories. Consider a single-level cell (SLC) Flash memory system (the SLC nomenclature is inaccurate; it is rather a single-bit cell with two levels). Given three adjacent cells, the pattern $101$ translates to programming the outer two cells but not the inner cell. This pattern can result in inter-cell interference (ICI) caused by an unintentional increase of the charge level in the inner cell. The pattern $010$ is typically less detrimental, but it can cause problems when erasure is not applied to the entire block and the outer cells are initially programmed. See [17] for a study of balanced constrained codes that alleviate ICI in Flash systems by eliminating the pattern $(q-1)0(q-1)$, where $q$ is the number of levels in the cell and also the Galois field (GF) order111We directly map the elements of the GF to the consecutive integers $\{0,1,\allowbreak\dots,q-1\}$ indexing $q$ distinct threshold voltage levels in order to follow the reference. In Flash systems, NRZ signaling is typically adopted.. Another related work is [18].

Furthermore, line codes find application in computer standards for data transmission, such as universal serial bus (USB) and peripheral component interconnect express (PCIe). Line codes for these applications are simpler than $\mathcal{T}_{x}$-constrained and RLL codes, since streams of codewords are only required to be balanced and to support self-clocking. Examples include the $8$b/$10$b code [19], the $64$b/$66$b code [20], and the $128$b/$132$b code [21]. We note that constrained codes preserving parity are studied in [22], and that constrained codes for deoxyribonucleic acid (DNA) storage are studied in [23]. We refer the reader to [9] for a comprehensive survey of constrained codes available until 1998.

The idea of lexicographic indexing can be traced back to [3] and to [24]. The latter independently introduced the idea in the context of source coding. The RLL codes and balanced RLL codes constructed in [25] and [26], respectively, are based on [24], and the rates achieved improve upon those of earlier RLL codes. However, these gains are only realized at relatively large code lengths, and therefore at a significant cost in terms of complexity, storage overhead, and error performance. Moreover, the technique in [24] does not readily generalize to $\mathcal{T}_{x}$-constrained codes. While techniques based on lookup tables, e.g., [27], offer a better rate-length trade-off, they incur significant encoding and decoding complexity.

In this paper, we return to the presentation of lexicographic indexing in [3], and develop the idea in the context of a new family of $\mathcal{T}_{x}$-constrained codes. We call the new codes lexicographically-ordered $\mathcal{T}_{x}$-constrained codes, or simply LOCO codes. Our three most significant contributions are:

We develop a simple rule for encoding and decoding LOCO codes based on lexicographic indexing. This rule reduces the encoding-decoding of LOCO codes to low-complexity mapping-demapping between the index of a codeword and the codeword itself. We demonstrate that LOCO codes are capacity-achieving codes, and that at moderate lengths, they provide a rate gain of up to $10\%$ compared with practical RLL and other $\mathcal{T}_{x}$-constrained codes that are used to achieve the same goals. 2. 2.

We demonstrate a density gain of about $20\%$ in modern MR systems by using a LOCO code to protect only the parity bits of a low-density parity-check (LDPC) code via alleviating ISI. The density gain of LDPC-LOCO coding compared with same-rate LDPC coding is about $16\%$. It is of course possible to protect all the bits of the LDPC code, but our method limits the rate loss. Our demonstration uses a modified version of the PR system described in [10], and a spatially-coupled (SC) LDPC code constructed as in [28]. 3. 3.

We prove that the inherent symmetry of LOCO codes makes balancing easy. Each message in a balanced LOCO code is represented by two codewords that are the complements of each other. Moreover, we show that the rate loss in balancing LOCO codes is minimal, and that this loss tends to zero in the limit, so that balanced LOCO codes achieve the same asymptotic rates as their unbalanced counterparts.

We also describe how to modify LOCO codes to achieve self-clocking with NRZ signaling.

The rest of the paper is organized as follows. In Section II, LOCO codes are formally defined and analyzed. The mapping-demapping between the index of a codeword and the codeword itself is introduced in Section III. Next, the rates of LOCO codes in addition to the practical encoding and decoding algorithms are presented in Section IV. LOCO codes are applied to MR systems in Section V. Balanced LOCO codes and their rates are discussed in Section VI. Finally, the paper is concluded in Section VII.

II Analysis of LOCO Codes

We start with the formal definition of the proposed fixed-length LOCO codes. In the next two sections, we will propose simple, practical encoding and decoding schemes for these codes.

Definition 1**.**

A LOCO code $\mathcal{C}_{m,x}$, with parameters $m\geq 1$ and $x\geq 1$, is defined by the following properties:

Each codeword $\mathbb{c}\in\mathcal{C}_{m,x}$ is binary and of length $m$. 2. 2.

Codewords in $\mathcal{C}_{m,x}$ are ordered lexicographically. 3. 3.

Each codeword $\mathbb{c}\in\mathcal{C}_{m,x}$ does not contain any pattern in the set $\mathcal{T}_{x}$, where:

[TABLE]

therefore, $|\mathcal{T}_{x}|=2x$. 4. 4.

Codewords in $\mathcal{C}_{m,x}$ are all the codewords satisfying the previous three conditions.

Lexicographic ordering of codewords means that the codewords are ordered in an ascending manner following the rule $0<1$ for any bit, and the bit significance reduces from left to right. In particular, starting from the left, we say $\mathbb{c}_{u_{1}}<\mathbb{c}_{u_{2}}$ if and only if for the first bit position the two codewords differ at, $\mathbb{c}_{u_{1}}$ has [math] while $\mathbb{c}_{u_{2}}$ has $1$.

Since $\mathcal{T}_{x}$-constrained codes are used with NRZ signaling, the constrained set of patterns can also be written as:

[TABLE]

where the notation $\boldsymbol{-}^{r}$ (resp., $\boldsymbol{+}^{r}$) is defined the same way as $\mathbb{0}^{r}$ (resp., $\mathbb{1}^{r}$). Throughout the paper, NRZ (resp., NRZI) signaling is adopted for LOCO (resp., RLL) codes.

Remark 1**.**

In the case of Flash systems, the level $-A$ is replaced by the erasure level $E$, $E<A$.

Observe the connection between the forbidden patterns, i.e., the patterns in $\mathcal{T}_{x}$, and the physics of different data storage systems. As $x$ increases, ISI (resp., ICI) is more alleviated in MR (resp., Flash) systems, and the minimum width of a pulse increases. However, increasing $x$ reduces the rate of the LOCO code.

Table I presents the LOCO codes $\mathcal{C}_{m,1}$, $m\in\{1,2,\dots,6\}$. These LOCO codes have $x=1$ and $\mathcal{T}_{1}=\{010,101\}$.

For $m\geq 2$, we partition the codewords in $\mathcal{C}_{m,x}$ into four distinct groups as follows:

Group 1: Codewords in this group start with $00$ from the left, i.e., at the left-most bits (LMBs).

Group 2: Codewords in this group start with $11$ from the left, i.e., at the LMBs.

Group 3: Codewords in this group start with $1\mathbb{0}^{x+1}$ from the left, i.e., at the LMBs.

Group 4: Codewords in this group start with $0\mathbb{1}^{x+1}$ from the left, i.e., at the LMBs222In Groups 3 and 4 and with $2\leq m\leq x+1$, there exists only a single codeword, which has fewer bits than these LMBs, in each group. The following analysis also applies for such codewords..

The four groups are shown in Table I for the code $\mathcal{C}_{6,1}$.

We will see that this partitioning into groups enables enumeration in addition to low complexity encoding and decoding of LOCO codewords.

Remark 2**.**

In order to satisfy Condition 3 in Definition 1 for a stream of codewords of a LOCO code $\mathcal{C}_{m,x}$, a bridging pattern needs to be added between any two consecutively transmitted (written) codewords in this stream. Bridging patterns will be discussed later in this paper.

First, we determine the cardinality of $\mathcal{C}_{m,x}$.

Theorem 1**.**

Let $N(m,x)$ be the cardinality (size) of the LOCO code $\mathcal{C}_{m,x}$, i.e., $N(m,x)=|\mathcal{C}_{m,x}|$. Define:

[TABLE]

Then, the following recursive formula gives $N(m,x)$:

[TABLE]

Proof:

Observe first that symmetry of forbidden patterns implies that in $\mathcal{C}_{m,x}$, the number of codewords starting with [math] from the left, i.e., at the LMB, equals the number of codewords starting with $1$ from the left. Thus, to prove our recursive formula (3), we calculate the cardinalities of Group 1 and Group 4 in $\mathcal{C}_{m,x}$, $m\geq 2$, then add these cardinalities and multiply the result by $2$.

Group 1: Each codeword in Group 1 in $\mathcal{C}_{m,x}$ corresponds to a codeword in $\mathcal{C}_{m-1,x}$ that starts with [math] from the left and shares the remaining $m-2$ right-most bits (RMBs) with the codeword in $\mathcal{C}_{m,x}$. This correspondence is bijective. Thus, the cardinality of Group 1 is:

[TABLE]

Group 4: Each codeword in Group 4 in $\mathcal{C}_{m,x}$ corresponds to a codeword in $\mathcal{C}_{m-x-1,x}$ that starts with $1$ from the left and shares the remaining $m-x-2$ RMBs with the codeword in $\mathcal{C}_{m,x}$. This correspondence is bijective. Thus, the cardinality of Group 4 is:

[TABLE]

From (4) and (5), we get:

[TABLE]

which completes the proof. ∎

In a similar way, it can be shown that the cardinality of Group 2 is:

[TABLE]

and the cardinality of Group 3 is:

[TABLE]

The value of Theorem 1 is the insight it provides into the structure of $\mathcal{C}_{m,x}$. Not only does Theorem 1 perform enumeration via simple recursion, it also significantly contributes to the low-complexity encoding and decoding schemes, which are based on the lexicographic ordering. Note that $N(m,x)$ is always even.

For $x=1$, the cardinalities form a Fibonacci sequence as (3) becomes:

[TABLE]

The cardinalities $N(m,1)$ for $m\in\{1,2,\dots,6\}$ are given in the last row of Table I.

Example 1**.**

Consider the LOCO codes $\mathcal{C}_{m,1}$, $m\in\{1,2,\allowbreak\dots,6\}$, illustrated in Table I. From (2), $N(0,1)\triangleq 2$ and $N(1,1)\triangleq 2$. From (3), which is (8) for $x=1$, the cardinalities of $\mathcal{C}_{m,1}$, $m\in\{2,3,\dots,6\}$, are:

[TABLE]

The cardinality of $\mathcal{C}_{6,1}$, for example, can also be obtained from the cardinalities of its groups that are:

[TABLE]

We now use the group structure of LOCO codes to define a lexicographic indexing of codewords.

Define $g(m,x,\mathbb{c})\in\{0,1,\dots,N(m,x)-1\}$ as the index of a codeword $\mathbb{c}$ in $\mathcal{C}_{m,x}$, which we also abbreviate to $g(\mathbb{c})$ when the context is clear. In particular, $g(m,x,\mathbb{c})$ is the index of the codeword $\mathbb{c}$ in $\mathcal{C}_{m,x}$ when all the codewords of $\mathcal{C}_{m,x}$ are ordered lexicographically. Since the four groups can be defined for a LOCO code of any length, we define them for $\mathcal{C}_{m+1,x}$. Let $\mathbb{c}^{\prime}$ be a codeword in $\mathcal{C}_{m+1,x}$. For Groups 1 and 2 in $\mathcal{C}_{m+1,x}$, let $\mathbb{c}\in\mathcal{C}_{m,x}$ be the corresponding codeword to $\mathbb{c}^{\prime}\in\mathcal{C}_{m+1,x}$ according to the proof of Theorem 1, i.e., the $m$ RMBs in $\mathbb{c}^{\prime}$ are $\mathbb{c}$.

We define the shift in codeword indices for Groups 1 and 2 in $\mathcal{C}_{m+1,x}$ as follows:

[TABLE]

where $\ell$ is the group index. Observe that this shift is fixed for all the codewords in the same group in $\mathcal{C}_{m+1,x}$.

The following lemma gives the values of the shift for Groups 1 and 2.

Lemma 1**.**

The shift in codeword indices defined in (9) for Groups 1 and 2 in a LOCO code $\mathcal{C}_{m+1,x}$ is given by:

[TABLE]

Proof:

We prove (10) by deriving $\zeta_{\ell}$ for each of the two groups of codewords in $\mathcal{C}_{m+1,x}$ as follows.

Group 1: Since corresponding codewords in $\mathcal{C}_{m+1,x}$ and in $\mathcal{C}_{m,x}$ have the same index for that group, we get:

[TABLE]

Group 2: Group 2 in $\mathcal{C}_{m+1,x}$ comes right after Groups 1, 4, and 3 (see Table I). On the other hand, the codewords in $\mathcal{C}_{m,x}$ that correspond to the codewords in Group 2 in $\mathcal{C}_{m+1,x}$ come right after all the codewords that start with [math] from the left. Consequently, and using (4), (5), and (7):

[TABLE]

Noting that (11) and (II) combined are (10) completes the proof. ∎

Example 2**.**

From (10), the values of $\zeta_{\ell}$, $\ell\in\{1,2\}$, for the LOCO code $\mathcal{C}_{6,1}$ given in the last column of Table I are:

[TABLE]

Note that here $m+1=6$, i.e., $m=5$, and $x=1$.

III Practical Encoding and Decoding

of LOCO Codes

In this section, we describe how lexicographic indexing supports simple, practical encoding and decoding of LOCO codes. The following theorem is fundamental to the encoding and decoding algorithms presented in Section IV.

In the following, we define a codeword $\mathbb{c}\in\mathcal{C}_{m,x}$ as $\mathbb{c}\triangleq\left[c_{m-1}\textup{ }c_{m-2}\textup{ }\dots\textup{ }c_{0}\right]$, where $c_{i}\in\{0,1\}$, for all $i$. We also define an integer variable $a_{i}$ for each $c_{i}$ such that:

[TABLE]

The same notation applies for $\mathbb{c}^{\prime}\in\mathcal{C}_{m+1,x}$. Note that codeword indexing is trivial for the case of $m=1$.

Theorem 2**.**

Consider a LOCO code $\mathcal{C}_{m,x}$ with $m\geq 2$. The index $g(\mathbb{c})$ of a codeword $\mathbb{c}\in\mathcal{C}_{m,x}$ is derived from $\mathbb{c}$ itself according to the following equation:

[TABLE]

Here, we use the abbreviated notation $g(\mathbb{c})$ for simplicity.

Proof:

We prove Theorem 2 by induction as follows.

Base: The base case here is the case of $m=2$. Let the four available codewords in $\mathcal{C}_{2,x}$ be $\mathbb{c}_{0}$, $\mathbb{c}_{1}$, $\mathbb{c}_{2}$, and $\mathbb{c}_{3}$, with the subscript of $\mathbb{c}$ being its index. The four codewords are shown in Table I. The bits of codeword $\mathbb{c}_{u}$ are $c_{u,i}$, $i\in\{0,1\}$, and $a_{u,i}$ is defined for each $c_{u,i}$ as in (13). We need to prove that (14) yields $g(\mathbb{c}_{u})=u$, $u\in\{0,1,2,3\}$.

[TABLE]

Note that $N(-x+1,x)=2$, for all $x\in\{1,2,\dots\}$, follows directly from (2). Note also that $N(2,x)=4$, for all $x\in\{1,2,\dots\}$.

Assumption: We assume that (14) holds for the case of $\overline{m}\in\{2,3,\dots,m\}$, i.e., for all the LOCO codes $\mathcal{C}_{\overline{m},x}$ of length $\overline{m}\in\{2,3,\dots,m\}$. In particular,

[TABLE]

Note that $\overline{\mathbb{c}}$ with bits $\overline{c}_{i}$ and variables $\overline{a}_{i}$, $i\in\{0,1,\dots,\overline{m}-1\}$, is a codeword in the LOCO code $\mathcal{C}_{\overline{m},x}$.

To be proved: We prove that (14) holds for the case of $m+1$, i.e., for the LOCO code $\mathcal{C}_{m+1,x}$ of length $m+1$. In particular,

[TABLE]

We prove (III) for the four groups of codewords in $\mathcal{C}_{m+1,x}$, making use of the inductive assumption and Lemma 1.

Group 1: From (11), we know that for Group 1:

[TABLE]

Note that here $\mathbb{c}$ starts with [math] from the left. Consequently, and using the assumption in (16):

[TABLE]

Since $\mathbb{c}^{\prime}$ and $\mathbb{c}$ share the $m-1$ RMBs, and since $\mathbb{c}^{\prime}$ starts with $00$ from the left, i.e., $a^{\prime}_{m}=a^{\prime}_{m-1}=0$, (18) can be written as:

[TABLE]

Group 2: From (II), we know that for Group 2:

[TABLE]

Note that here $\mathbb{c}$ starts with $1$ from the left. Consequently, and using the assumption in (16):

[TABLE]

Observe that using (3), we have:

[TABLE]

Substituting (III) in (III) gives:

[TABLE]

Since $\mathbb{c}^{\prime}$ and $\mathbb{c}$ share the $m-1$ RMBs, and since $\mathbb{c}^{\prime}$ starts with $11$ from the left, i.e., $a^{\prime}_{m}=a^{\prime}_{m-1}=1$, (III) can be written as:

[TABLE]

Group 3: Observe that the codewords in Group 3 in $\mathcal{C}_{m+1,x}$ are the first $N_{3}(m+1,x)$ codewords in Group 1 in $\mathcal{C}_{m+1,x}$ after replacing the [math] at the LMB with $1$ for each (with the same order). Therefore, to get the index $g(m+1,x,\mathbb{c}^{\prime})$ for a codeword in Group 3, we need to add $\frac{1}{2}N(m+1,x)$ to the index of the corresponding codeword in Group 1. Thus, and using (III), for Group 3:

[TABLE]

Since $\mathbb{c}^{\prime}$ starts with $1$ from the left, i.e., $a^{\prime}_{m}=1$, (III) can be written as:

[TABLE]

Group 4: Observe that the codewords in Group 4 in $\mathcal{C}_{m+1,x}$ are the last $N_{4}(m+1,x)$ codewords in Group 2 in $\mathcal{C}_{m+1,x}$ after replacing the $1$ at the LMB with [math] for each (with the same order). Therefore, to get the index $g(m+1,x,\mathbb{c}^{\prime})$ for a codeword in Group 4, we need to subtract $\frac{1}{2}N(m+1,x)$ from the index of the corresponding codeword in Group 2. Thus, and using (III), for Group 4:

[TABLE]

Since $\mathbb{c}^{\prime}$ starts with [math] from the left, i.e., $a^{\prime}_{m}=0$, (III) can be written as:

[TABLE]

As a result of the above analysis for the four groups, (III) is proved, i.e., the induction is proved. Therefore, Theorem 2 is proved for any LOCO code $\mathcal{C}_{m,x}$, for all $m\geq 2$ and for all $x\geq 1$. ∎

Observe that from Theorem 2, two LOCO codewords that differ only in the bit $c_{i}$, $0\leq i\leq m-2$, satisfy the following:

[TABLE]

For simplicity, consider the case of $x\leq i\leq m-2$. In order that these two LOCO codewords exist, if $c_{i+1}=0$, $\left[c_{i-1}\textup{ }c_{i-2}\textup{ }\dots\textup{ }c_{i-x}\right]$ is guaranteed to be $\mathbb{1}^{x}$, and if $c_{i+1}=1$, $\left[c_{i-1}\textup{ }c_{i-2}\textup{ }\dots\textup{ }c_{i-x}\right]$ is guaranteed to be $\mathbb{0}^{x}$. Consequently, the interpretation of (III) is that this difference in indices equals exactly the number of LOCO codewords of length $i-x+1$ that start with $1$ (resp., [math]) from the left if $c_{i+1}=0$ (resp., $c_{i+1}=1$). In both cases, this number is $\frac{1}{2}N(i-x+1,x)$.

The value of Theorem 2 is that it provides the mathematical foundation for the practical encoding and decoding algorithms of our LOCO codes via lexicographic indexing. In particular, this theorem introduces a simple one-to-one mapping from $g(\mathbb{c})$ to $\mathbb{c}$, which is actually the encoding, and a simple one-to-one demapping from $\mathbb{c}$ to $g(\mathbb{c})$, which is actually the decoding. The value of this theorem is exemplified in the practical algorithms in the following section. In summary, Theorem 2 provides the encoding-decoding rule for LOCO codes.

Example 3**.**

We illustrate Theorem 2 by applying (14) to two codewords in $\mathcal{C}_{6,1}$ given in Table I. The first codeword is the one with the index $9$, which is $011001$. This codeword has $c_{m-1}=0$; thus,

[TABLE]

The second codeword is the one with the index $24$, which is $111110$. This codeword has $c_{m-1}=1$; thus,

[TABLE]

Example 3 shows how the index, which implies the original message, can be recovered from the LOCO codeword.

Remark 3**.**

Lexicographically-ordered RLL (LO-RLL) codes can be constructed as shown in [3]. Define the binary difference vector $\mathbb{v}$ of a codeword $\mathbb{c}$ in a LOCO code $\mathcal{C}_{m,x}$, $m\geq 2$, as $\mathbb{v}\triangleq\left[v_{m-2}\textup{ }v_{m-3}\textup{ }\dots\textup{ }v_{0}\right]$, with $v_{i}\triangleq c_{i+1}+c_{i}$ over GF($2$), for all $i\in\{0,1,\dots,m-2\}$. Observe that any codeword $\mathbb{c}$ of length $m$ in $\mathcal{C}_{m,x}$ has its difference vector $\mathbb{v}$ of length $m-1$ satisfying the $(d,\infty)$, $d=x$, RLL constraint. Thus, all the codewords of a $(d,\infty)$ LO-RLL code with $d=x$ and length $m-1$ can also be derived from the LOCO code $\mathcal{C}_{m,x}$ by computing the difference vectors for all the codewords in $\mathcal{C}_{m,x}$ starting with [math] from the left (the remaining difference vectors will be repeated because of symmetry)333Even though codewords here are not ordered lexicographically, we still call this code a LO-RLL code since all the codewords satisfying the constraint are included and the generating codewords are ordered lexicographically.. Consequently, the cardinality of a $(d,\infty)$ LO-RLL code with $d=x$ and length $m-1$ is given by:

[TABLE]

From [3], the cardinality of a $(d,\infty)$ LO-RLL code of length $m$ is given by:

[TABLE]

[TABLE]

Comparing (30) and (31) to (2) and (3) results in (29). For example, for $x=1$, $N(1,1)\triangleq 2$, $N(2,1)=4$, $N(3,1)=6$, $N(4,1)=10$, $N(5,1)=16$, $N(6,1)=26$, …. On the other hand, for $d=x=1$, $N_{\textup{RLL}}(1,1)=2$, $N_{\textup{RLL}}(2,1)=3$, $N_{\textup{RLL}}(3,1)=5$, $N_{\textup{RLL}}(4,1)=8$, $N_{\textup{RLL}}(5,1)=13$, …, which demonstrates (29). This observation leads to a simple way of constructing and indexing $(d,\infty)$ RLL codes.

IV Rate Discussion and Algorithms

We first discuss bridging patterns. Consider the following scenario. The codeword at transmission (writing) instance $t$ is ending with $00$ from the right, while the codeword at instance $t+1$ is starting with $10$ from the left. The stream containing the two codewords will then have the pattern $010$, which is a forbidden pattern for any LOCO code. This is the motivation behind adding bridging patterns. In particular, bridging patterns prevent forbidden patterns from appearing across two consecutive codewords. If the patterns in $\mathcal{T}_{x}$ are prevented (Condition 3 in Definition 1 is satisfied), any two consecutive transitions will be separated by at least $x+1$ successive bit durations. For $\mathcal{T}_{x}$-constrained codes, since they are associated with NRZ signaling, transitions are either from [math] to $1$, i.e, $-A$ to $+A$, or from $1$ to [math], i.e., $+A$ to $-A$.

Define the symbol $z$ as the no transmission (no writing) symbol. For example, in magnetic recording, $z$ represents the state when the magnetic grain is unmagnetized. As done before, we also define the notation $\mathbb{z}^{r}$ to represent a run of $r$ consecutive $z$ symbols. We propose two methods for adding bridging patterns that prevent forbidden patterns from appearing in streams of LOCO codewords. The first method is simply to add the bridging pattern $\mathbb{z}^{x}$ between each two consecutive LOCO codewords. The second method is to make a run-time decision on the bridging pattern of length $x$ based on the $x+1$ RMBs in the codeword at instance $t$ and the $x+1$ LMBs in the codeword at instance $t+1$.

In the first method, adding a run of $x$ consecutive $z$ symbols, i.e., not transmitting (not writing) for $x$ successive bit durations, guarantees that no pattern in $\mathcal{T}_{x}$ appears across consecutive LOCO codewords in $\mathcal{C}_{m,x}$. This method is quite simple, and does not require any knowledge of the codewords being transmitted (written). However, it is not optimal in the sense that it does not provide the maximum achievable protection, e.g., from ISI in MR systems, for the bits at the two ends of the codeword. For example, in the scenario at the start of this section, it is best to use $1$ for bridging if $x=1$.

While the second method provides better protection for the bits at the two ends of the codeword, it introduces additional complexity and latency. However, it is still feasible for small values of $x$. For example, Table II provides the bridging patterns of the second method for LOCO codes with $x=1$.

Whether the first or the second method is used for bridging, the number of added bits/symbols for each codeword is $x$. Moreover, bridging patterns are ignored at the decoding.

Remark 4**.**

In the case of Flash systems, transitions are either from [math] to $1$, i.e, $E$ to $+A$, or from $1$ to [math], i.e., $+A$ to $E$. Moreover, the no writing symbol $z$ represents the state when the cell is programmed to a charge level about the mid-point between $E$ and $+A$.

Remark 5**.**

For LOCO codes with parameter $x$, the optimal bridging, in terms of bits protection, is different from the second bridging method. In particular, if the RMB of the codeword at instance $t$ is [math] (resp., $1$), $\mathbb{0}^{x}$ (resp., $\mathbb{1}^{x}$) is added for bridging after that [math] (resp., $1$). Moreover, if the LMB of the codeword at instance $t+1$ is [math] (resp., $1$), $\mathbb{0}^{x}$ (resp., $\mathbb{1}^{x}$) is added for bridging before that [math] (resp., $1$). Thus, for this optimal bridging, $2x$ bridging bits are needed, which also keeps the code length fixed. However, such bridging is not efficient in terms of the added redundancy, in addition to its higher complexity compared with the first bridging method. Furthermore, our simulations demonstrate that the other two bridging methods described above are already guaranteeing a more than satisfactory performance.

One of the important requirements not only in constrained codes, but also in all types of line codes is self-clocking [4, 9]. In particular, the receiver should be capable of retrieving the clock of the transmitter from the signal itself. This requires avoiding long runs of [math]’s ($-A$’s) and long runs of $1$’s ($+A$’s). To achieve this goal, we construct the following code.

Definition 2**.**

A self-clocked LOCO (C-LOCO) code $\mathcal{C}_{m,x}^{\textup{c}}$ is the code resulting from removing the all [math]’s and the all $1$’s codewords from the LOCO code $\mathcal{C}_{m,x}$. In particular,

[TABLE]

where $m\geq 2$. The cardinality of $\mathcal{C}_{m,x}^{\textup{c}}$ is given by:

[TABLE]

Now, there exists at least one transition in each codeword in $\mathcal{C}_{m,x}^{\textup{c}}$. Define $k_{\textup{eff}}^{\textup{c}}$ as the maximum number of successive bit durations between two consecutive transitions in a stream of C-LOCO codewords that belong to $\mathcal{C}_{m,x}^{\textup{c}}$, with each two consecutive codewords separated by a bridging pattern. For the sake of abbreviation, we here use the format “codeword at $t$ $-$ bridging pattern $-$ codeword at $t+1$”. The scenarios under which $k_{\textup{eff}}^{\textup{c}}$ is achieved, using the first bridging method, are:

[TABLE]

The scenarios under which $k_{\textup{eff}}^{\textup{c}}$ is achieved, using the second bridging method, are:

[TABLE]

Observe that a transition is only from [math] to $1$ or from $1$ to [math]. Consequently, regardless of the chosen method, we get:

[TABLE]

We are now ready to discuss the rate of C-LOCO codes. A C-LOCO code $\mathcal{C}_{m,x}^{\textup{c}}$, with $x$ bridging bits/symbols associated to each codeword, has rate:

[TABLE]

where $N(m,x)$ is obtained from the recursive relation (3). The numerator, which is $\left\lfloor\log_{2}\left(N(m,x)-2\right)\right\rfloor$, is the length of the messages $\mathcal{C}_{m,x}^{\textup{c}}$ encodes.

Observe that a C-LOCO code $\mathcal{C}_{m,x}^{\textup{c}}$ consists of all codewords of length $m$, with the exception of the two codewords $\mathbb{0}^{m}$ and $\mathbb{1}^{m}$, that do not contain any of the forbidden patterns in $\mathcal{T}_{x}$. Moreover, the number of added bits/symbols for bridging is function of $x$ only, and thus does not grow with $m$. Consequently, it follows that C-LOCO codes are capacity-achieving constrained codes.

Example 4**.**

Consider again the LOCO code $\mathcal{C}_{6,1}$ in Table I. From (34), the C-LOCO code $\mathcal{C}_{6,1}^{\textup{c}}$ derived from $\mathcal{C}_{6,1}$ has:

[TABLE]

The length of the messages $\mathcal{C}_{6,1}^{\textup{c}}$ encodes is:

[TABLE]

The C-LOCO code $\mathcal{C}_{6,1}^{\textup{c}}$ is shown in Table III for all messages. From (IV), the rate of $\mathcal{C}_{6,1}^{\textup{c}}$ is:

[TABLE]

Note that the rate of $\mathcal{C}_{6,1}^{\textup{c}}$ is relatively low because of the small code length, $m=6$, and because of the relatively high number of unused codewords. Table IV shows the rates of C-LOCO codes $\mathcal{C}_{m,x}^{\textup{c}}$ for different values of $m$ and for $x\in\{1,2\}$. The rates in Table IV for C-LOCO codes with $x=1$ are significantly higher than $0.5714$.

Table IV demonstrates that C-LOCO codes have rates up to $0.6923$ (resp., $0.5484$) for the case of $x=1$ (resp., $x=2$) with moderate code lengths. From the literature, the capacity of a $\mathcal{T}_{x}$-constrained code with $x=1$ (resp., $x=2$) is $0.6942$ (resp., $0.5515$) [8, 9]. The table shows that the rate of the C-LOCO code $\mathcal{C}_{90,1}^{\textup{c}}$ (resp., $\mathcal{C}_{91,2}^{\textup{c}}$) is within only $0.3\%$ (resp., $0.6\%$) from the capacity. In fact, these rates even increase with an informed increase in the value of $m$ until they reach the capacity. For example, the rate of $\mathcal{C}_{489,1}^{\textup{c}}$ is $0.6939$, which is only $0.04\%$ from the capacity. Additionally, the rate of $\mathcal{C}_{450,2}^{\textup{c}}$ is $0.5509$, which is only $0.1\%$ from the capacity.

For the sake of comparison with other line codes having similar performance, we focus on constrained codes generated via finite-state machines (FSMs) and decoded via sliding window decoders [4, 8, 9, 29] because of their practicality. The FSM-based constrained codes we compare with include both RLL and $\mathcal{T}_{x}$-constrained codes.

We briefly discuss $(d,k)$ RLL codes. An RLL code with parameter $d$ constrains each codeword to have at least $d$ [math]’s between each two consecutive $1$’s. RLL codes are used with NRZI signaling. Thus, an RLL code with parameter $d$ has any two consecutive transitions separated by at least $d+1$ successive bit durations444The maximum number of successive bit durations between two consecutive transitions for a $(d,k)$ RLL code with NRZI signaling is $k+1$. This maximum number is $k_{\textup{eff}}^{\textup{c}}$ for a C-LOCO code with NRZ signaling.. Therefore, and from the definition of a LOCO code, an RLL code with parameter $d$ has similar performance to a LOCO code with parameter $x$.

Consider FSM-based RLL codes with $d=x$ and FSM-based $\mathcal{T}_{x}$-constrained codes. There are three main advantages of LOCO codes over FSM-based constrained codes used for the same purpose, which are:

LOCO codes achieve higher rates. 2. 2.

LOCO codes are immune against error propagation from a codeword into another. 3. 3.

Balancing LOCO codes is not only simple, but also incurs a very limited rate loss.

The second and third advantages will be discussed later in this paper. As for the rate advantage, a practical FSM-based RLL code with $d=1$ typically has a rate of $0.6667$, which is the same rate a practical FSM-based $\mathcal{T}_{1}$-constrained code has [4, 8]. This rate is lower than the rates of all C-LOCO codes with $x=1$ in Table IV except the code with $m=8$. Moreover, a practical FSM-based RLL code with $d=2$ typically has a rate of $0.5000$, which is the same rate a practical FSM-based $\mathcal{T}_{2}$-constrained code has [4, 9]. This rate is lower than the rates of all C-LOCO codes with $x=2$ in Table IV except the code with $m=6$. The rate gain of moderate-length C-LOCO codes over practical FSM-based constrained codes, where $d=x$, is up to $10\%$. In particular, $\mathcal{C}_{91,2}^{\textup{c}}$ achieves a rate of $0.5484$ at a moderate complexity, which is about $10\%$ higher than the typical rate of a practical FSM-based constrained code, where $d=x=2$, that is $0.5000$ (see also [4] and [9]).

The observation that constrained codes based on lexicographic indexing offer significant rate gains compared with FSM-based constrained codes was presented in [25] and [26]. However, the techniques proposed in both papers require the code length to be significantly large ($m>250$) in order to achieve such gains, which is not needed for LOCO codes. This observation will be demonstrated even more upon introducing balanced LOCO codes.

We introduce now the encoding and decoding algorithms of our C-LOCO codes, which are based on Theorem 2. Algorithm 1 is the encoding algorithm, and Algorithm 2 is the decoding algorithm.

Consider the C-LOCO code $\mathcal{C}_{m,x}^{\textup{c}}$. It is possible that there exists a binary vector of length $m$, $\mathbb{e}\triangleq\left[e_{m-1}\textup{ }e_{m-2}\textup{ }\dots\textup{ }e_{0}\right]$, which is not a C-LOCO codeword, and a C-LOCO codeword of length $m$, $\mathbb{c}\triangleq\left[c_{m-1}\textup{ }c_{m-2}\textup{ }\dots\textup{ }c_{0}\right]$, such that:

[TABLE]

where $a^{\textup{e}}_{i}$ is defined for each $e_{i}$ the same way $a_{i}$ is defined for each $c_{i}$ in (13). To prevent encoding a vector like $\mathbb{e}$, which is not a C-LOCO codeword, we need to prevent forbidden patterns from appearing while encoding via Algorithm 1.

The steps from 18 to 31 in Algorithm 1 are to make sure forbidden patterns of the form $0\mathbb{1}^{j}0$, $1\leq j\leq x$, in $\mathcal{T}_{x}$ do not appear in any codeword. As for forbidden patterns of the form $1\mathbb{0}^{j}1$, $1\leq j\leq x$, they will never appear if forbidden patterns of the form $0\mathbb{1}^{j}0$, $1\leq j\leq x$, are guaranteed to be eliminated. The justification goes as follows. Suppose we are encoding $c_{i}$, $2x\leq i\leq m-2$, and $c_{i+1}=1$. Since patterns of the form $0\mathbb{1}^{j}0$, $1\leq j\leq x$, do not appear in any codeword, it suffices to show that $1\mathbb{0}^{j}\mathbb{1}^{x+1}$, $1\leq j\leq x$, cannot appear either. In other words, we want to show that if the variable residual is not enough to encode $c_{i}=1$, it is not enough to encode $\left[c_{i-1}\textup{ }c_{i-2}\textup{ }\dots\textup{ }c_{i-2x}\right]=\mathbb{0}^{x-1}\mathbb{1}^{x+1}$, which implies that it is not enough to encode $\left[c_{i-1}\textup{ }c_{i-2}\textup{ }\dots\textup{ }c_{i-x-j}\right]=\mathbb{0}^{j-1}\mathbb{1}^{x+1}$, $1\leq j\leq x$. This property for residual is satisfied if:

[TABLE]

Let $\sigma\triangleq i-x+1$. From (3), we get:

[TABLE]

From (IV), we conclude that (37) is true, and it is an equality, which means the residual property is satisfied. Note also that the conclusion is correct for $1\leq i\leq 2x-1$, which completes the justification.

Example 5**.**

We illustrate Algorithm 1 by showing how to encode a message using the C-LOCO code $\mathcal{C}_{6,1}^{\textup{c}}$ given in Table III. Here, $N(0,1)\triangleq 2$, $N(1,1)\triangleq 2$, $N(2,1)=4$, $N(3,1)=6$, $N(4,1)=10$, $N(5,1)=16$, and $N(6,1)=26$. Moreover, $s^{\textup{c}}=\left\lfloor\log_{2}24\right\rfloor=4$. Consider the message $1110$. From Step 6, $g(\mathbb{c})=\textup{decimal}(1110)+1=15$, which is the initial value of the variable residual. Since $\textup{residual}>\frac{1}{2}N(6,1)=13$, from Step 11, $c_{5}$ is encoded as $1$. At Step 12, residual becomes $15-13=2$. Then, the algorithm enters the for loop from Step 14 to Step 39. The remaining $5$ bits of the codeword are encoded as follows:

• •

At $i=4$, $\textup{residual}<\frac{1}{2}N(4,1)=5$. Consequently, $c_{4}$ is encoded as [math] at Step 16.

• •

At $i=3$, $\textup{residual}<\frac{1}{2}N(3,1)=3$. Consequently, $c_{3}$ is encoded as [math] at Step 16.

• •

At $i=2$, $\textup{residual}=\frac{1}{2}N(2,1)=2$. Here, $c_{3}=0$. From Steps 20 and 25, $\beta_{0}=\frac{1}{2}N(2,1)=2$ and $\beta_{1}=\frac{1}{2}N(2,1)+\frac{1}{2}N(1,1)=3$, respectively. Since $\beta_{0}=\textup{residual}<\beta_{1}$, the condition in Step 26 is satisfied, leading to $f_{1}=1$, which means that if $c_{2}$ is encoded as $1$, a forbidden pattern of the form $010$ will be created on $c_{3}$, $c_{2}$, and $c_{1}$. Consequently, $c_{2}$ is encoded as [math] at Step 36 to prevent this scenario.

• •

At $i=1$, $\textup{residual}>\frac{1}{2}N(1,1)=1$. Here, $c_{2}=0$. From Steps 20 and 25, $\beta_{0}=\frac{1}{2}N(1,1)=1$ and $\beta_{1}=\frac{1}{2}N(1,1)+\frac{1}{2}N(0,1)=2$, respectively. Since $\beta_{0}<\textup{residual}=\beta_{1}$, the condition in Step 26 is not satisfied, leading to $f_{1}=0$. Consequently, $c_{1}$ is encoded as $1$ at Step 33, and residual becomes $2-1=1$.

• •

At $i=0$, $\textup{residual}=\frac{1}{2}N(0,1)=1$. Here, $c_{1}=1$. Consequently, $c_{0}$ is encoded as $1$ at Step 33.

As a result, the codeword generated is $100011$, which is codeword indexed by $g(\mathbb{c})=15$ in Table III.

Example 3 in Section III already showed how the decoding algorithm works.

As demonstrated by Algorithm 1 and Algorithm 2 in addition to Theorem 2, the encoding procedure of C-LOCO codes is mainly comparisons and subtractions, while the decoding procedure of C-LOCO codes is mainly additions. The size of the adders used to perform these tasks, referred to in Tables IV and VII as “Adder size”, is $\log_{2}$ the maximum value $g(\mathbb{c})$ can take that corresponds to a message, and it is given by:

[TABLE]

which is the message length. Table IV links the rate of a C-LOCO code with its encoding and decoding complexity through the size of the adders to be used. For example, for a C-LOCO code with $x=1$, if a rate of $0.6667$ is satisfactory, small adders of size just $6$ bits are all what is needed. However, in case the rate needs to be about $0.6842$, adders of size $13$ bits should be used. Moreover, for a C-LOCO code with $x=2$, if a rate of $0.5000$ is satisfactory, small adders of size just $4$ bits are all what is needed. However, in case the rate needs to be about $0.5333$, adders of size $8$ bits should be used. Note that the cardinalities $N(i,x)$, $-x+1\leq i\leq m$, should be stored in the memory offline. Note also that the multiplication by $\frac{1}{2}$ is just a right shift by one unit in binary, and it can be done only once at the beginning of the encoding-decoding.

From Table IV, the C-LOCO code $\mathcal{C}_{90,1}^{\textup{c}}$ has rate $0.6923$ and adder size $63$ bits. The same rate is achieved in [27] for an RLL code with $d=1$ at code (resp., message) length $13$ (resp., $9$) bits. However, the technique in [27] is based on lookup tables; thus, the complexity of the encoding and decoding is governed by lookup tables of size $2^{9}\times 13=6656$ bits. Note that in the case of $d=2$, the size of these lookup tables governing the complexity can reach $40960$ bits. This complexity is significantly higher than what we offer.

LOCO codes are also reconfigurable. In particular, if the size of the adders is appropriate, the same set of adders used to encode-decode a specific LOCO code can be reconfigured to encode-decode another LOCO code just by changing their inputs (the cardinalities) through multiplexers.

Remark 6**.**

Observe that (29) in Remark 3 shows that the capacity of a $\mathcal{T}_{x}$-constrained code is the same as the capacity of a $(d,\infty)$ RLL code with $d=x$ since:

[TABLE]

In other words, $(d,\infty)$ LO-RLL codes achieve similar rates to the rates of LOCO codes asymptotically. This fact can also be reached from the finite-state transition diagrams of the constraints [8, 9]. However, (29) also shows that LOCO codes are more efficient compared with LO-RLL codes in the finite-length regime. The reason is that from (29) and (3), the difference between the cardinalities of a LOCO code $\mathcal{C}_{m,x}$ and a $(d,\infty)$ LO-RLL code with $d=x$ and length $m$ is:

[TABLE]

Thus, if the same number of bits is used for bridging, the LOCO code can achieve higher rates at the same code length or lower complexities at the same rate555Another way to understand why this is the case is that for $d=x$ and at the same length, the $(d,\infty)$ RLL constraint results in forbidding more prospective codewords compared with the $\mathcal{T}_{x}$ constraint.. This is also true when the two codes are self-clocked. For example, for $d=x=1$ and using $1$ bit/symbol for bridging in both codes, a self-clocked LOCO code of length $m=8$ and adder size of $6$ bits is enough to achieve a rate of $0.6667$ (see Table IV), while to achieve the same rate using a self-clocked $(d,\infty)$ LO-RLL code, the length has to be increased to $m=17$ and the adder size to $12$ bits, which means roughly double the complexity of the LOCO encoding-decoding.

We end this section by discussing two more aspects in the proposed LOCO codes: error propagation in addition to parallel encoding and decoding. The fixed length of LOCO codes makes them immune against error propagation from a codeword into the following ones. In particular, multiple errors occurring in one codeword do not affect the decoding of the following codewords. However, for large code lengths, few bit errors in a LOCO codeword can affect many bits in the message, which is the reason why we recommend LOCO codes with moderate lengths. On the contrary, FSM-based constrained codes with sliding window decoders suffer from error propagation among different codewords that is exacerbated with long codeword lengths (and also with long streams of codewords) [5]. Furthermore, because of their fixed length, LOCO codes enable parallel encoding and decoding of different codewords if the complexity constraints of the system allow that. This advantage can be of significant value in data storage systems, where codewords are already written upon receiving (reading) them. On the other hand, FSM-based constrained codes with sliding window decoders do not enable efficient parallel encoding and decoding. The properties stated here for LOCO codes also apply to the balanced LOCO codes discussed in Section VI.

V Density Gains in MR Systems

Our MR system model is shown in Fig. 1, and it consists of the following modules.

LDPC encoder: This is a binary spatially-coupled (SC) LDPC encoder, which takes $w$ bits of input data and generates an SC codeword of length $n$ bits. The adopted SC codes will be described shortly.

LOCO encoder: It takes the SC codeword as input, and using Algorithm 1, it encodes only $n-w$ parity bits via a C-LOCO code $\mathcal{C}^{\textup{c}}_{m,x}$ to significantly increase their reliability by mitigating ISI for them as previously illustrated. The parameters of the C-LOCO code will be described shortly, but it has a much smaller length compared with $n-w$. Thus, there is a stream of C-LOCO codewords, with each consecutive two of them separated by a bridging pattern $\mathbb{z}^{x}$. The output of the LOCO encoder is of length $n_{\textup{ov}}$.

NRZ signal generator: It generates an NRZ stream of $n_{\textup{ov}}$ symbols, each of which is in $\{-A,+A\}$, except for the bridging symbols. Symbol $z$ for bridging corresponds to no transmission (no writing).

Interleaver: A pseudo-random interleaver is applied only on the $w$ bits that are not encoded via the C-LOCO code.

PR channel: We use the PR channel described in [10]. The MR channel effects are inter-symbol interference (intrinsic memory), jitter, and electronic noise. The channel density [10, 30], which is the ratio of the read-head pulse duration at half the amplitudes to the bit duration, is swept to generate the plots. The signal-to-noise ratio (SNR) is $13.00$ dB. A continuous-time filter (CTF) followed by a digital finite-impulse-response (DFIR) filter are applied to achieve the PR equalization target $[8$ $14$ $2]$. Observe that this PR target, which is recommended by the industry, behaves in a way similar to the channel impulse response [10, 30]. This observation is an important reason why we are here adopting the set $\mathcal{T}_{x}$ of symmetric forbidden patterns, which is closed under taking pattern complements.

BCJR detector: A Bahl Cocke Jelinek Raviv (BCJR) detector [31], which is based on pattern-dependent noise prediction (PDNP) [32], is then applied to the received stream to calculate $n_{\textup{ov}}$ likelihood ratios (LRs). There is a feedback loop incorporating the detector and the decoders.

Deinterleaver: It rearranges the LRs of the $w$ bits that were not encoded via the C-LOCO code, i.e., the ones that were originally interleaved.

LOCO decoder: Initially, this decoder makes a hard decision on the $n_{\textup{ov}}-w$ bits that were encoded via the C-LOCO code using their LRs. If the $\mathcal{T}_{x}$ constraint is violated for the received word or the received word is in $\{\mathbb{0}^{m},\mathbb{1}^{m}\}$, the LOCO decoder tries to fix that by flipping the bit with the closest LR to $1$ (the smallest $\log_{e}$ LR in magnitude). In other words, the LOCO decoder performs some sort of error correction here. Next, it decodes the original $n-w$ parity bits using Algorithm 2. Finally, the LOCO decoder sends $n$ LRs to the LDPC decoder; $w$ LRs left as they are, and $n-w$ highly reliable LRs.

LDPC decoder: This is a fast Fourier transform based $q$-ary sum-product algorithm (FFT-QSPA) LDPC decoder [33], with $q$, the GF order, being set to $2$ here. The number of global (detector-decoders) iterations is $10$, and the number of local (LDPC decoder only) iterations is $20$. Unless a codeword is reached, the LDPC decoder performs its prescribed number of local iterations for each global iteration. At the end of each global iteration, except the last one, the LDPC decoder, sends its updated $n$ LRs in the feedback loop.

LR expander: The BCJR detector operates on $n_{\textup{ov}}$ symbols. Thus, an LR expander is used to expand the LR vector from $n$ to $n_{\textup{ov}}$ via the information it receives from the LOCO and the LDPC decoders.

Interleaver: The interleaver in the feedback branch of the detector-decoders loop is a pseudo-random interleaver, which is applied only on the $w$ LRs of the bits that were not encoded via the C-LOCO code.

At the last global iteration, looping stops, and the LDPC decoder generates the data read ($w$ bits). More details about some of these modules can be found in [10].

Remark 7**.**

If the C-LOCO message length, $s^{\textup{c}}$, does not divide $n-w$, we pad with few, say $\delta$, zeros.

One of the two reasons why we do not apply the C-LOCO code on the entire LDPC codeword here is to limit the rate loss resulting from integrating the C-LOCO code in the MR system, which is a critical requirement in all data storage systems. The other reason will be introduced upon discussing the simulation plots. Lemma 2 gives the overall rate of the LDPC-LOCO coding scheme applied in our system.

Lemma 2**.**

Consider the following LDPC-LOCO coding scheme. A C-LOCO code of rate $R_{\textup{LOCO}}^{\textup{c}}$ is used to encode only the parity bits of an LDPC code of rate $R_{\textup{LDPC}}$. The overall rate of this scheme is:

[TABLE]

Proof:

The length of the LDPC codeword can be written as:

[TABLE]

Only those $n-w$ bits are going to be encoded via the C-LOCO code. Consequently,

[TABLE]

As a result, the overall rate is:

[TABLE]

Note that $\delta$ is very small compared with $n$. ∎

Lemma 2 demonstrates that the rate loss due to integrating a C-LOCO code in the MR system the way we do it is limited. In fact, from the expression in (42), as $R_{\textup{LDPC}}$ approaches $1$, $R_{\textup{ov}}$ approaches $R_{\textup{LDPC}}$. The reason is that when $R_{\textup{LDPC}}$ approaches $1$, $R_{\textup{ov}}$ becomes $h/(h+\epsilon)$, where $\epsilon=1-R_{\textup{LDPC}}<<h=R_{\textup{LDPC}}R^{\textup{c}}_{\textup{LOCO}}$. Thus, $R_{\textup{ov}}$ also approaches $1$ like $R_{\textup{LDPC}}$. Numerical examples are: for $R_{\textup{LDPC}}=0.7000$ and $R^{\textup{c}}_{\textup{LOCO}}=0.6667$, $R_{\textup{ov}}=0.6087$, while for $R_{\textup{LDPC}}=0.9500$ and $R^{\textup{c}}_{\textup{LOCO}}=0.6667$, $R_{\textup{ov}}=0.9268$, which is only $2.4\%$ lower than $R_{\textup{LDPC}}$.

There are two binary SC codes used in our simulations. The two codes are constructed according to [28], which provides a method to design high performance SC codes particularly for MR systems. This method is based on the optimal overlap, circulant power optimizer (OO-CPO) approach. SC Code 1 has column weight $=4$, maximum row weight $=17$, circulant size $=37$, memory $=1$, and coupling length $=6$. Thus, SC Code 1 has block length $=3774$ bits and rate $\approx 0.725$. SC Code 2 has column weight $=4$, maximum row weight $=13$, circulant size $=47$, memory $=1$, and coupling length $=7$. Thus, SC Code 2 has block length $=4277$ bits and rate $\approx 0.648$. The differences in length and rate between the two SC codes will be illustrated shortly. Only SC Code 1 will be combined with a C-LOCO code.

The C-LOCO code we use in the simulations is the code $\mathcal{C}_{18,1}^{\textup{c}}$. This code has $m=18$ and $x=1$. Thus, from (34), $\mathcal{C}_{18,1}^{\textup{c}}$ has $k_{\textup{eff}}^{\textup{c}}=2\times 17+1=35$. Moreover, $\mathcal{C}_{18,1}^{\textup{c}}$ has $N^{\textup{c}}(18,1)=8362$, which means the message length is $s^{\textup{c}}=\left\lfloor\log_{2}8360\right\rfloor=13$. Thus, from (IV), the rate of $\mathcal{C}_{18,1}^{\textup{c}}$ is $\frac{13}{18+1}=0.6842$ since one symbol $z$ is used for bridging.

We generate three plots, as shown in Fig. 2, for the following three simulation setups:

SC Code 1 (original SC code) is used for error correction, and no C-LOCO code is applied. 2. 2.

SC Code 2 (lower rate SC code) is used for error correction, and no C-LOCO code is applied. 3. 3.

SC Code 1 is combined with the C-LOCO code $\mathcal{C}_{18,1}^{\textup{c}}$ such that only the parity bits of SC Code 1 are encoded via $\mathcal{C}_{18,1}^{\textup{c}}$.

The energy per input data bit in all three setups is the same.

For Setup 3, we have the following parameters: $w=2738$ (see [28]), $n=3774$, $R_{\textup{LDPC}}=0.725$, $R_{\textup{LOCO}}^{\textup{c}}=0.6842$, and $\delta=4$. From (44), the overall length after applying the C-LOCO code in Setup 3 is:

[TABLE]

Furthermore, from (42), the overall rate is $R_{\textup{ov}}\approx 0.643$. Thus, the overall length and rate in Setup 3 are similar to the length and rate of SC Code 2 in Setup 2.

The frame error rate (FER) versus density plots for the three setups are shown in Fig. 2. The figure demonstrates the gains of Setup 3, in which a C-LOCO code is applied in the MR system, over the other two setups. In particular, the density gain of Setup 3 over Setup 1 (resp., Setup 2) is about $20\%$ (resp., $16\%$) at FER $\approx 10^{-6}$. The density gain achieved in Setup 3 over Setup 2 implies that exploiting the additional redundancy by applying a C-LOCO code is significantly more helpful compared with exploiting this redundancy by adding more parity bits. An intriguing observation from Fig. 2 is that the error floor slope in Setup 3 is sharper than the error floor slope in the other two setups.

While applying the C-LOCO code to the entire LDPC codeword provides higher density gains, the overall rate loss becomes very high since the rate in this case becomes $R_{\textup{ov}}\approx R_{\textup{LDPC}}R_{\textup{LOCO}}^{\textup{c}}$. For example, if $\mathcal{C}_{18,1}^{\textup{c}}$ is applied to the entire codeword of SC Code 1, the overall rate becomes $R_{\textup{ov}}\approx 0.496$, which is a lot lower than $R_{\textup{ov}}$ in Setup 3, which is $0.643$. Additionally, the density gains achieved diminish gradually with more bits being encoded via the C-LOCO code. In summary, the proposed idea in Setup 3 offers a better rate-density gain trade-off.

Setup 3 is motivated by a particular understanding of graph-based codes. Even though only a group of bits in the LDPC codeword, which are the bits encoded via the LOCO code, have highly reliable LRs while decoding, the information in these highly reliable LRs will be spread to all bits during the message passing procedure. Therefore, the LDPC decoder experiences a version of the channel with a higher effective SNR, which results in the decoder, aided by the detector and the LOCO decoder, kicking-off its operation at higher densities.

The contribution in Section V is the idea that investing the additional redundancy in protecting the parity bits only of an LDPC code from ISI is significantly more effective than investing this redundancy in adding more parity bits. Observe that if we apply the same setup but replace the LOCO code with an RLL code having $d=x$ and the same rate, the performance gains would be comparable. However, there will be an additional complexity associated with using an RLL code that has the same rate as the LOCO code, which is discussed in Sections IV and VI in the paper.

Remark 8**.**

In this paper, we use the word “moderate” to describe lengths of LOCO codes. The context of this usage may not be generalized to include LDPC codes since what is moderate for LOCO codes is very small for LDPC codes.

VI Balanced LOCO Codes

A critical additional requirement in line codes, which appears in applications like optical recording, Flash memories, in addition to USB and PCIe standards, is balancing [13, 17, 26]. Examples of balanced line codes are the $8$b/$10$b [19] and the $64$b/$66$b [20] codes (the latter is not strictly DC-free). Balanced line codes have zero average power at frequency zero, i.e., no DC power component, when the signal levels are $-A$ and $+A$. This is achieved by constraining the running disparity $p_{\textup{r}}$ of any stream of codewords from the line code. The work in [15] relates the running disparity to the width of the power spectral null. The running disparity $p_{\textup{r}}$ is measured before each new codeword in the stream, and $p_{\textup{r}}$ equals the sum of disparities of all the previous codewords and their bridging patterns. The disparity of a codeword $\mathbb{c}$, $p(\mathbb{c})$, is defined as the difference between the number of $+A$ and $-A$ ($+A$ and $E$ in Flash) symbols in the transmitted (written) codeword after the signaling scheme is applied. When NRZ signaling is applied, this disparity is directly the difference between the number of $1$’s and [math]’s in the codeword.

A standard way of balancing line codes is to encode each message to one of two codewords having the same magnitude but opposite signs for their disparities. Then, depending on the sign of the running disparity, one of these two codewords is picked for the incoming message. Codewords having zero disparity can be used to uniquely encode messages. For example, the $8$b/$10$b code adopts this way of balancing. This simple code is constructed to achieve balancing and self-clocking only, which is why it has a high rate. More advanced line codes, e.g., $\mathcal{T}_{x}$-constrained or RLL codes, have more requirements, e.g., improving the performance in data storage systems, making their rates less compared with the above simple line code. Thus, balancing these constrained codes via the approach mentioned in this paragraph incurs a penalty. This penalty is either rate loss (rate reduction) for the same complexity or additional complexity for the same rate.

In this section, we demonstrate another advantage of LOCO codes, which is that they can be balanced with the minimum penalty. We start with the following lemma.

Lemma 3**.**

Define codeword $\mathbb{c}^{0}$ as a LOCO codeword in $\mathcal{C}_{m,x}$ that starts with [math] from the left. Define codeword $\mathbb{c}^{1}$ as the LOCO codeword indexed by $N(m,x)-1-g(\mathbb{c}^{0})$ in $\mathcal{C}_{m,x}$, where $g(\mathbb{c}^{0})$ is the index of $\mathbb{c}^{0}$. The two codewords $\mathbb{c}^{0}$ and $\mathbb{c}^{1}$ are the complements of each other.

Proof:

We first define $a^{0}_{i}$ (resp., $a^{1}_{i}$) for each bit $c^{0}_{i}$ in $\mathbb{c}^{0}$ (resp., $c^{1}_{i}$ in $\mathbb{c}^{1}$) as in (13).

Since $\mathbb{c}^{0}$ starts with [math] from the left, using (14) gives:

[TABLE]

From the definition of $\mathbb{c}^{1}$, it has to start with $1$ from the left. Thus, using (14) gives:

[TABLE]

Furthermore, we also have:

[TABLE]

Consequently, using (46) and (47), we get:

[TABLE]

which means:

[TABLE]

The last equality in (VI) follows from that $\frac{1}{2}N(m,x)-1$ is the index of the LOCO codeword $0\mathbb{1}^{m-1}$.

For a given codeword $\mathbb{c}^{0}$ starting with [math] from the left in $\mathcal{C}_{m,x}$, the codeword $\mathbb{c}^{1}$ starting with $1$ from the left in $\mathcal{C}_{m,x}$, and having the $m-1$ RMBs being the complements of the $m-1$ RMBs in $\mathbb{c}^{0}$, makes (VI) satisfied. Because the mapping from $g(\mathbb{c}^{1})$ to $\mathbb{c}^{1}$ is one-to-one, such a codeword has to be the only codeword with that property. Since $c^{0}_{m-1}=0$ and $c^{1}_{m-1}=1$ are already complements, $\mathbb{c}^{0}$ and $\mathbb{c}^{1}$ are then the complements of each other. ∎

Note that since we adopt NRZ signaling,

[TABLE]

Thus, and based on Lemma 3, we now define the proposed balanced LOCO (B-LOCO) codes.

Definition 3**.**

A balanced LOCO (B-LOCO) code $\mathcal{C}_{m,x}^{\textup{b}}$, with $m\geq 2$, is a LOCO code in which, each pair of codewords $\mathbb{c}^{0}$ and $\mathbb{c}^{1}$, having indices $g(\mathbb{c}^{0})$ and $g(\mathbb{c}^{1})\triangleq N(m,x)-1-g(\mathbb{c}^{0})$ in $\mathcal{C}_{m,x}$, respectively, are used to encode a single message. The selected codeword $\mathbb{c}$ is either $\mathbb{c}^{0}$ or $\mathbb{c}^{1}$ depending on the sign of the running disparity $p_{\textup{r}}$ as shown in Table V. Consequently, the cardinality of $\mathcal{C}_{m,x}^{\textup{b}}$ is:

[TABLE]

However, only a maximum of $\frac{1}{2}N^{\textup{b}}(m,x)$ codewords in $\mathcal{C}_{m,x}^{\textup{b}}$ correspond to distinct messages666That is why the minimum length we adopt for a B-LOCO code, and later a self-clocked B-LOCO code, is the length at which the cardinality $=4$..

Remark 9**.**

If the second bridging method is adopted and $p_{\textup{r}}=0$ or/and $p(\mathbb{c}^{0})=p(\mathbb{c}^{1})=0$, it is also possible to select the codeword that enhances self-clocking taking into account the previous codeword.

Example 6**.**

The B-LOCO code $\mathcal{C}_{6,1}^{\textup{b}}$ is shown in Table VI with the codeword disparities. Observe that (51) is always satisfied, i.e., $p(\mathbb{c}^{0})=-p(\mathbb{c}^{1})$. The cardinality of $\mathcal{C}_{6,1}^{\textup{b}}$ is:

[TABLE]

However, only a maximum of $13$ codewords in $\mathcal{C}_{6,1}^{\textup{b}}$ correspond to distinct messages.

The running disparity in the case of B-LOCO codes satisfies $-m\leq p_{\textup{r}}<+m$ (see also Example 6). In particular, $-m\leq p_{\textup{r}}\leq+m-2$ if $m$ is even, and $-m\leq p_{\textup{r}}\leq+m-1$ if $m$ is odd. Moreover, because of the way codewords are chosen, as shown in Table V, this running disparity is around [math] most of the time for long streams of codewords.

The following theorem is the key theorem for encoding and decoding B-LOCO codes.

Theorem 3**.**

Consider a B-LOCO code $\mathcal{C}_{m,x}^{\textup{b}}$ with $m\geq 2$. The index $g^{\textup{b}}(\mathbb{c})$ of a codeword $\mathbb{c}\in\mathcal{C}_{m,x}^{\textup{b}}$ is derived from $\mathbb{c}$ itself according to the following two equations:

If the LMB $c_{m-1}=0$:

[TABLE]

If the LMB $c_{m-1}=1$:

[TABLE]

Here, we use the abbreviated notation $g^{\textup{b}}(\mathbb{c})$ for simplicity.

Proof:

For the case of $c_{m-1}=0$, it is clear that:

[TABLE]

where $g(\mathbb{c}^{0})$ is the index of $\mathbb{c}^{0}$ in $\mathcal{C}_{m,x}$. Thus, using (14):

[TABLE]

For the case of $c_{m-1}=1$, $g^{\textup{b}}(\mathbb{c})$ must equal that of the corresponding codeword in $\mathcal{C}_{m,x}^{\textup{b}}$ that starts with [math] from the left. From Lemma 3, $\mathbb{c}$ in $\mathcal{C}_{m,x}^{\textup{b}}$ that has $c_{m-1}=1$, which is $\mathbb{c}^{1}$ in $\mathcal{C}_{m,x}$, and its corresponding codeword in $\mathcal{C}_{m,x}^{\textup{b}}$ that starts with [math] from the left, which is $\mathbb{c}^{0}$ in $\mathcal{C}_{m,x}$, are the complements of each other. Consequently, we conclude:

[TABLE]

which completes the proof. ∎

Example 7**.**

We illustrate Theorem 3 via an example. Consider $\mathcal{C}_{6,1}^{\textup{b}}$ given in Table VI. We check the two codewords indexed by $6$, which are $001110$ and $110001$. From (53), the codeword starting with [math] from the left has:

[TABLE]

From (54), the codeword starting with $1$ from the left has:

[TABLE]

Bridging in B-LOCO codes is performed the same way as described in Section IV for LOCO codes. Define the disparity change resulting from adding a $z$ symbol after a B-LOCO codeword to be [math], which makes sense as $z$ is the no transmission (no writing) symbol. Observe that whether the first method or the second method is used for bridging, the above analysis does not change. This statement is clear for the first method. As for the second method, note that the complement rule in Lemma 3 applies also for bridging patterns (see Table II), which justifies the statement. We use the first bridging method in this section since, in addition to its simplicity, it results in no disparity change, and thus no increase in the maximum magnitude of the running disparity.

Definition 4**.**

A self-clocked B-LOCO (CB-LOCO) code $\mathcal{C}_{m,x}^{\textup{cb}}$ is the code resulting from removing the all [math]’s and the all $1$’s codewords from the B-LOCO code $\mathcal{C}_{m,x}^{\textup{b}}$. In particular,

[TABLE]

where $m\geq 3$. The cardinality of $\mathcal{C}_{m,x}^{\textup{cb}}$ is given by:

[TABLE]

However, only a maximum of $\frac{1}{2}N^{\textup{cb}}(m,x)$ codewords in $\mathcal{C}_{m,x}^{\textup{cb}}$ correspond to distinct messages.

Define $k_{\textup{eff}}^{\textup{cb}}$ as the maximum number of successive bit durations between two consecutive transitions in a stream of CB-LOCO codewords that belong to $\mathcal{C}_{m,x}^{\textup{cb}}$, with each two consecutive codewords separated by $\mathbb{z}^{x}$. Recall that a transition is only from [math] to $1$ or from $1$ to [math]. Consequently, we get:

[TABLE]

Remark 10**.**

A stream of B-LOCO codewords that belong to $\mathcal{C}_{m,x}^{\textup{b}}$, each having $g^{\textup{b}}(\mathbb{c})=0$ and using the first bridging method, is encoded as follows:

[TABLE]

If the system can make use of the $0-z$ (resp., $z-1$) followed by the $z-1$ (resp., $0-z$) changes for self-clocking, the two codewords $\mathbb{0}^{m}$ and $\mathbb{1}^{m}$ can be kept in the code. Here, we assume that the system cannot use these changes for self-clocking, and that is why our definition for a transition is exclusively from [math] to $1$ or from $1$ to [math].

Note that the maximum magnitude of the running disparity in the case of CB-LOCO codes is $m-2$, not $m$, because of the removal of the two codewords $\mathbb{0}^{m}$ and $\mathbb{1}^{m}$. Thus, CB-LOCO codes are better than B-LOCO codes in that regard.

Remark 11**.**

If the second bridging method is used instead, the two codewords $\mathbb{0}^{m}$ and $\mathbb{1}^{m}$ can be kept in the code, and $k_{\textup{eff}}^{\textup{b}}$ becomes $\lfloor 5(m+x)/2\rfloor-1$. We do not adopt this method here since it increases $k_{\textup{eff}}^{\textup{b}}$, increases the maximum magnitude of the running disparity to $m+x$, in addition to its complexity.

We are now ready to discuss the rate of CB-LOCO codes. A CB-LOCO code $\mathcal{C}_{m,x}^{\textup{cb}}$, with $x$ bridging bits/symbols associated to each codeword, has rate:

[TABLE]

where $N(m,x)$ is obtained from the recursive relation (3). The numerator, which is $\left\lfloor\log_{2}\left(N(m,x)-2\right)\right\rfloor-1$, is the length of the messages $\mathcal{C}_{m,x}^{\textup{cb}}$ encodes.

Comparing the rate of the CB-LOCO code $\mathcal{C}_{m,x}^{\textup{cb}}$ to the C-LOCO code $\mathcal{C}_{m,x}^{\textup{c}}$ via subtracting (VI) from (IV) gives:

[TABLE]

Consequently,

[TABLE]

Under the balancing approach of having two codewords to encode each message, the maximum number of codewords corresponding to distinct messages drops to at most half the cardinality of the unbalanced code. Thus, a balanced code achieves the minimum rate loss if the code has a rate loss of only ${1}/{(\textup{code length})}$ with respect to its unbalanced code; since this means the balanced code contains all the codewords of the unbalanced code. In other words, for each codeword in the unbalanced code, there exists another codeword to be paired with, such that the two codewords have their disparities with the same magnitude but opposite signs. Consequently, no codewords are skipped from the unbalanced code in order to achieve balancing. We refer to this rate loss as the one-bit minimum penalty because it can be viewed as a reduction of one bit from the message length. From the above discussion and (62), our CB-LOCO codes achieve the minimum rate loss, i.e., they achieve the one-bit minimum penalty.

Observe that asymptotically, i.e., as $m\rightarrow\infty$, the rate loss resulting from balancing LOCO codes tends to zero from (62). Thus, CB-LOCO codes asymptotically achieve the same rates as C-LOCO codes. Moreover, the penalty of (rate loss due to) balancing LOCO codes has the highest possible vanishing rate with $m$. As shown in Table VII, the rate of the moderate-length CB-LOCO code $\mathcal{C}_{116,1}^{\textup{cb}}$ (resp., $\mathcal{C}_{120,2}^{\textup{cb}}$) is within only $1.5\%$ (resp., $2\%$) from the capacity of an unbalanced $\mathcal{T}_{x}$-constrained code having $x=1$ (resp., $x=2$). As far as we know, balancing other constrained codes in the literature always incurs a notable rate loss, even asymptotically, with respect to the unbalanced codes [13, 26, 17], which is not the case for LOCO codes. For example, the balancing penalty in [13] is an added redundancy of more than $\log_{2}m$ (see also [14]), which is a costly penalty. Moreover, in order to reduce the rate loss due to balancing, the authors of [26] are adopting large code lengths, which is not needed for LOCO codes. In the finite-length regime, we achieve a higher rate at the same code length or the same rate at a smaller code length in comparison with [26].

Example 8**.**

Consider again the B-LOCO code $\mathcal{C}_{6,1}^{\textup{b}}$ in Table VI. From (60), the CB-LOCO code $\mathcal{C}_{6,1}^{\textup{cb}}$ derived from $\mathcal{C}_{6,1}^{\textup{b}}$ has:

[TABLE]

The length of the messages $\mathcal{C}_{6,1}^{\textup{cb}}$ encodes is:

[TABLE]

The CB-LOCO code $\mathcal{C}_{6,1}^{\textup{cb}}$ is also shown in Table VI for all messages. From (VI), the rate of $\mathcal{C}_{6,1}^{\textup{cb}}$ is:

[TABLE]

For bigger values of $m$, the rate of a CB-LOCO code $\mathcal{C}_{m,x}^{\textup{cb}}$ exceeds $0.6667$ (resp., $0.5000$) for $x=1$ (resp., $x=2$) as shown in Table VII and discussed before Example 8. These rates cannot be achieved for practical balanced FSM-based RLL codes having $d=x$. Moreover, even to approach these rates, the encoding-decoding complexity of the balanced FSM-based RLL code will be significantly larger than that of the CB-LOCO code. CB-LOCO codes also offer a better rate-complexity trade-off compared with balanced FSM-based $\mathcal{T}_{x}$-constrained codes. Recall that the rate of a practical FSM-based unbalanced constrained code is typically $0.6667$ (resp., $0.5000$) for $d=x=1$ (resp., $d=x=2$) [4, 8].

Algorithms 1 and 2 can be modified to encode and decode CB-LOCO codes. The major changes are:

For both algorithms, the message length (adder size) is changed to $s^{\textup{cb}}=\left\lfloor\log_{2}\left(N(m,x)-2\right)\right\rfloor-1$. 2. 2.

For Algorithm 1, the message here is encoded to $\mathbb{c}=\mathbb{c}^{0}$ initially. After Step 40, $p(\mathbb{c}^{0})$ is calculated. Then, a check is made on the disparities $p_{\textup{r}}$ and $p(\mathbb{c}^{0})$. If $p_{\textup{r}}$ and $p(\mathbb{c}^{0})$ have the same sign, the codeword complement of $\mathbb{c}^{0}$ is transmitted (written), i.e., $\mathbb{c}=\mathbb{c}^{1}$, and $p(\mathbb{c})=p(\mathbb{c}^{1})=-p(\mathbb{c}^{0})$. Otherwise, $\mathbb{c}=\mathbb{c}^{0}$ is transmitted (written), and $p(\mathbb{c})=p(\mathbb{c}^{0})$. The updated running disparity $p_{\textup{r}}$ is then calculated for the next codeword using $p_{\textup{r}}\leftarrow p_{\textup{r}}+p(\mathbb{c})$. Only $p(\mathbb{c})$ is needed because we use the first bridging method. 3. 3.

Let $o(\mathbb{c})$ be the number of $1$’s in codeword $\mathbb{c}$ in $\mathcal{C}_{m,x}^{\textup{cb}}$. For Algorithm 1, $p(\mathbb{c})$ can be easily computed from:

[TABLE] 4. 4.

For Algorithm 2, Steps 5, 6, and 7 are removed. Moreover, if $c_{m-1}=0$, the condition under which $g^{\textup{b}}(\mathbb{c})$ is increased by $\frac{1}{2}N(i-x+1,x)$ remains “if $c_{i}=1$” from (53) in Theorem 3. However, if $c_{m-1}=1$, the condition under which $g^{\textup{b}}(\mathbb{c})$ is increased by $\frac{1}{2}N(i-x+1,x)$ becomes “if $c_{i}=0$” from (54) in Theorem 3.

Table VII also links the rate of a CB-LOCO code with its encoding and decoding complexity through the size of the adders to be used.

Remark 12**.**

Observe that $(d,\infty)$ LO-RLL codes constructed as shown in [3] or via the ideas in Remark 3 do not have the balancing advantage of LOCO codes, which is the complement rule in Lemma 3. In other words, given a LO-RLL codeword, there does not necessarily exist another LO-RLL codeword such that their disparities have the same magnitude but opposite signs after NRZI signaling. Therefore, balancing these codes is associated with a higher penalty compared with balancing LOCO codes as a result of the many unused codewords. This is another advantage of LOCO codes over $(d,\infty)$ LO-RLL codes in addition to the rate-complexity trade-off advantage illustrated in Remark 3 and Remark 6.

VII Conclusion

We introduced LOCO codes, a new family of constrained codes, where the combination of recursive structure and lexicographic indexing of codewords enables simple mapping-demapping between the index and the codeword itself. We showed that this mapping-demapping enables low complexity encoding and decoding algorithms. We also showed that LOCO codes are capacity-achieving, and that at moderate lengths, they provide a rate gain of up to $10\%$ compared with other practical constrained codes that are used to achieve the same goals. Inherent symmetry of LOCO codes makes balancing easy. We demonstrated that the rate loss associated with balancing LOCO codes is minimal, and that this loss tends to zero in the limit, so that balanced LOCO codes achieve the same asymptotic rates as their unbalanced counterparts. Moreover, we demonstrated a density gain of about $20\%$ in modern MR systems by using a LOCO code to protect only the parity bits of an LDPC code via mitigating ISI. We suggest that LOCO codes provide a simple and effective practical method for improving the performance of a wide variety of data storage and computer systems. Ongoing work includes asymmetric and non-binary LOCO codes.

Acknowledgment

The authors would like to thank the associate editor Prof. Anxiao Jiang for handling the paper and for the constructive feedback. The authors would also like to thank the anonymous reviewers for their valuable and helpful comments (this extends to the ITW reviewers as well).