Joint Coding for Flash Memory Storage

Abstract

Flash memory is an electronic non-volatile memory with wide applications. Due to the substantial impact of block erasure operations on the speed, reliability and longevity of flash memories, writing schemes that enable data to be modified numerous times without incurring the block erasure is desirable. This requirement is addressed by floating codes, a coding scheme that jointly stores and rewrites data and maximizes the rewriting capability of flash memories. In this paper, we present several new floating code constructions. They include both codes with specific parameters and general code constructions that are asymptotically optimal. We also present bounds to the performance of floating codes.

Full text

Joint Coding for Flash Memory Storage
Anxiao (Andrew) Jiang
Computer Science Department
Texas A&M University
College Station, TX 77843, U.S.A.
ajiang@cs.tamu.edu
Jehoshua Bruck
Electrical Engineering Department
California Institute of Technology
Pasadena, CA 91125, U.S.A.
bruck@paradise.caltech.edu
Abstract—Flash memory is an electronic non-volatile memory
with wide applications. Due to the substantial impact of block
erasure operations on the speed, reliability and longevity of
flash memories, writing schemes that enable data to be modified
numerous times without incurring the block erasure is desirable.
This requirement is addressed by floating codes, a coding scheme
that jointly stores and rewrites data and maximizes the rewriting
capability of flash memories. In this paper, we present several new
floating code constructions. They include both codes with specific
parameters and general code constructions that are asymptoti-
cally optimal. We also present bounds to the performance of
floating codes.
I. INTRODUCTION
Flash memory is a type of electronic non-volatile memory
(NVM) with wide applications. It stores data in floating-gate
cells, where each cell has qstates: 0, 1, ··· ,q−1. To increase
or decrease the state of a cell, charge is injected into or
extracted from the cell using the hot-electronic mechanism or
the Fowler-Nordheim tunneling mechanism [1]. An interesting
feature of flash memories is their block erasure operation.
Cells in a flash memory are organized into blocks, with each
block containing 105or so cells. The state of a cell can be
raised individually (called cell programming). But to decrease
the state of a cell, the flash memory needs to erase the whole
block (i.e., lowering the states of all the cells to the minimum
value) and then re-program all the cells. Such an operation is
called block erasure/programming. It is well known that block
erasures can substantially reduce the writing speed, reliability
and longevity of flash memories [1], with the benefit of a
lower circuitry complexity. For storage schemes, it is important
to minimize block erasures, especially for applications where
data are modified frequently.
Floating codes [3] address this requirement by maximizing
the number of times data can be rewritten (i.e., modified)
between two block erasures. A floating code jointly stores
multiple variables in ncells and with each rewrite, the cells’
states keep increasing. No block erasure is necessary until the
cell states reach the maximum state value. A floating code
maps the state of cells to the stored variables and, through the
joint coding approach, the ability to support rewrites can be
substantially improved.
The known results on floating codes are limited. Exist-
ing code constructions are mainly for two to three binary
variables [3]. In this paper, we present several new code
constructions based on varied approaches. They include both
codes with specific parameters and code constructions for
general parameters. We analyze their performance and bounds,
and show the asymptotic optimality of most of the presented
codes.
II. NOTATION
Let v1,v2,··· ,vkbe kvariables. Each variable vihas an
alphabet of size l:{0, 1, ··· ,l−1}.(v1,v2,···,vk)is called
the variable vector, and Vdenotes the set of all lkvariable
vectors. Let c1,c2,··· ,cnbe the states of ncells. Each
cell state cihas one of qpossible states: {0, 1, ··· ,q−1}.
(c1,c2,··· ,cn)is called the cell state vector, and Cdenotes
the set of all qncell state vectors. The weight of a cell state
vector is ∑n
i=1ci.
Definition 1.
[3] A floating code is a mapping
D:C→V∪
{⊥}
. Forα
∈C
and β
∈V
, if
D(
α
) =
β, it means that the cell
statesαrepresent the variable values β; if
D(
α
) = ⊥
, it means
that αdoes not represent any value of the variables.
2
Arewrite means to change the value of one of the k
variables. Initially, the cell state vector is (0, 0, · ·· , 0), and
they represent the variable vector (0, 0, ··· , 0). A floating
code is for rewriting data between two block erasures; so for
each rewrite, the state of a cell can only increase or remain
the same. A rewrite changes the cell states so that the new cell
state vector represents the new variable vector. Let tdenote the
number of rewrites that are guaranteed to be feasible by using
the floating code, regardless of what the sequence of rewrites
are. Clearly, tis a finite number. Given the parameters n,q,k,l,
a floating code that maximizes tis called optimal.
Example 2.
Three examples of a family of floating codes are
shown in Fig.
1
. This family of codes are for the parameters
n=k>3
,
l=2
and arbitrary
q
. They achieve
t=2(q−
1)
. The codes have a
cyclic property
: If the cell state vector
(c1=a1,c2=a2,··· ,cn=an)
represents the variable vector
(v1=b1,v2=b2,··· ,vk=bk)
, then the cell state vector
(c1=a2,c2=a3,··· ,cn−1=an,cn=a1)
represents the
variable vector
(v1=b2,v2=b3,··· ,vk−1=bk,vk=b1)
.
For simplicity, for every set of cell state vectors that are cyclic
shifts of each other, only one of them is shown in Fig.
1
as their
representative.
Take the code in Fig.
1
(c) as an instance, which is for
n=k=5, q=4, l=2
. If a sequence of rewrites
change the variables as
(0, 0, 0, 0, 0)→(1, 0, 0, 0, 0)→
(1, 0, 1, 0, 0)→(1, 0, 0, 0, 0)→(1, 0, 0, 0, 1)→
(1, 0, 1, 0, 1)→(1, 0, 1, 1, 1)
, the cell state vector can
change as
(0, 0, 0, 0, 0)→(1, 0, 0, 0, 0)→(1, 0, 1, 0, 0)→
(2, 1, 1, 1, 1)→(2, 1, 1, 1, 2)→(2, 1, 2, 1, 2)→

(2, 1, 2, 2, 2)
. A general code construction for
n=k,l=
2, t=2(q−1)
, including this code as a special example, is
shown in Section III.
2
We present an upper bound to tfor general floating codes.
Theorem 3.
For
i=1, 2, · ·· ,k
, define
si
as follows: (1) If
l=2
and
i
is even,
si=∑j=0,2,··· ,i(k
j)
; (2) if
l=2
and
i
is odd,
si=∑j=1,3,···,i(k
j)
; (3) if
l>2
,
si=∑i
j=0(k
j)(l−
1)j
. Also, define
wi
as the smallest positive integer such that
(n+wi
n)−(n+i−1
n)>si
. Let
m∈{1, 2, ···,k}
be the integer
such that
wm
m>wj
j
for
j=1, 2, ···,k
, .
For any floating code,
t6bn(q−1)
wmc · m+min{m−
1, n(q−1)
mod
wm}
.
Proof: siis the number of values that the variable vector
can possibly take after irewrites. (By symmetry, sidoes not
depend on the initial value of the variable vector.) Consider
mconsecutive rewrites. They increase the weight of the cell
state vector by at least m. For any x>m, the number of ways
to raise the states of ncells such that the weight of the cell
state vector increases by at least mand at most xis (n+x
n)−
(n+m−1
n). The mconsecutive rewrites can change the variable
into smpossible values, each of which corresponds to at least
one way of raising the cell states. So by the definition of wi,
there is a sequence of mconsecutive rewrites that increases
the weight of the cell state vector by at least wm. Choose
bn(q−1)
wmcsuch sequences of rewrites (one after another), and
they make the weight of the cell state vector be at least n(q−
1)−[n(q−1)mod wm]. After that, since the weight cannot
exceed n(q−1), there is a sequence of mrewrites that is
not feasible due to the lack of room for the weight increase.
Also, each rewrite increases the weight by at least one. So
after the initial bn(q−1)
wmcsequences of rewrites (which consist
of bn(q−1)
wmc·mrewrites in total), at most min{m−1, n(q−
1)mod wm}more rewrites are guaranteed to be feasible. So
t6bn(q−1)
wmc·m+min{m−1, n(q−1)mod wm}.
The bound in Theorem 3 compares favorably with the upper
bounds in [3] when kor lis relatively large. For example,
when n=4, q=8, k=4, l=4, Theorem 3 gives t611,
and the bounds in [3] show t614.
III. CODE CONSTRUCTION FOR n=k
In this section, we present a floating code for n=k>3,
l=2and arbitrary q. Codes for more general parameters will
be presented in the following sections. It will be proved that
when n=k=3, the code presented here is optimal. Several
examples of the code have been shown in Example 2 and
Fig. 1. We now present the general code construction. (Note
that the code has a cyclic property, as explained in Example 2.)
In the following, define smin =min{c1,c2,···,cn}and
smax =max{c1,c2,··· ,cn}.
Construction 4. (Code for n=k>3,l=2and arbitrary
q)
The cell state vectors
(c1,c2,··· ,cn)
are mapped to the
variable vectors
(v1,v2,··· ,vk)
in the following way:
2, 2, 1, 1, 1
(1, 1, 1, 1, 0)
1, 1, 1, 1, 0
(1, 0, 0, 0, 0)
3, 2, 2, 2, 2
(1, 1, 1, 0, 0)
2, 2, 2, 1, 1
(1, 1, 1, 1, 1)
0, 2, 1, 1, 1
(0, 0, 0, 0, 0)
3, 3, 3, 3, 3
(1, 1, 0, 0, 0)
3, 3, 2, 2, 2
(1, 1, 1, 1, 0)
2, 2, 2, 2, 1
(1, 1, 0, 0, 0)
(1, 0, 1, 0)
3, 2, 3, 2
(b) k=n=4, q=4
(1, 0, 0, 0, 0)
1, 0, 0, 0, 0
(0, 0, 0, 0, 0)
1, 1, 1, 1, 1
(1, 1, 0, 0, 0)
1, 1, 0, 0, 0
(1, 0, 0, 0, 0)
2, 1, 1, 1, 1
(1, 1, 1, 0, 0)
1, 1, 1, 0, 0
2, 2, 2, 2, 2
(0, 0, 0, 0, 0)
Layer 1
Layer 0
(c) k=n=5, q=4
(1, 0, 1, 1, 1)
0, 2, 2, 1, 1
(a) k=n=3, q=4
(0, 0, 0)
3, 3, 3 3, 3, 2
(1, 1, 0) (0, 1, 1)
3, 3, 1
Layer 0
Layer 1
Layer 2
Layer 3
Layer 4
Layer 5
Layer 6
Layer 2
(0, 0, 0, 0, 0)
0, 0, 0, 0, 0
(1, 0, 1, 0, 0)
1, 0, 1, 0, 0
(1, 1, 0, 1, 0)
1, 1, 0, 1, 0
(1, 0, 1, 0, 0)
2, 1, 2, 1, 1
(1, 1, 0, 1, 0)
2, 2, 1, 2, 1
(1, 0, 1, 0, 0)
3, 2, 3, 2, 2
Layer 6
Layer 5
Layer 4
Layer 3
2, 1, 2, 1
1, 3, 2
(0, 0, 0)
2, 2, 2 2, 2, 1
(1, 1, 0) (0, 1, 1)
2, 2, 0
(0, 0, 0, 0)
3, 3, 3, 3
(1, 0, 0, 0)
3, 2, 2, 2
(1, 1, 0, 0)
3, 3, 2, 2
(1, 1, 1, 0)
2, 2, 2, 1
(1, 1, 1)
0, 0, 0
(0, 0, 0)
(1, 0, 0)
1, 0, 0
(0, 0, 0)
1, 1, 1
(1, 1, 0)
1, 1, 0
(1, 0, 0)
2, 1, 1
(1, 1, 1)
0, 2, 1
(1, 0, 0)
3, 2, 2
0, 0, 0, 0
(0, 0, 0, 0)
(1, 1, 1, 1)
0, 2, 1, 1
(1, 1, 1, 1)
1, 3, 2, 2Layer 6
Layer 5
Layer 4
Layer 3
Layer 2
Layer 1
Layer 0
(1, 0, 1, 0)
1, 0, 1, 0
(1, 0, 1, 0)
1, 0, 0, 0
(1, 0, 1, 1)
0, 2, 2, 1
(0, 0, 0, 0)
2, 2, 2, 2 2, 2, 1, 1
(1, 1, 0, 0)
(1, 0, 0, 0)
2, 1, 1, 1
(1, 1, 1, 0)
1, 1, 1, 0
(0, 0, 0, 0)
1, 1, 1, 1
(1, 1, 0, 0)
1, 1, 0, 0
(1, 0, 0, 0)
Figure1. A family of floating codes with n=k>3,l=2and t=
2(q−1). The numbers inside (resp. beside) a node are the cell state vector
(resp., variable vector). The code has a cyclic property. The layer of a cell
state vector is the number of rewrites it takes for the cells to each that state.
(a) n=k=3,q=4. (b) n=k=4,q=4. (c) n=k=5,q=4.

•Type I:
If
c1=c2=···=cn
, then
vi=0
for
16i6k
.
•Type II:
If
smax =smi n +1
, then
vi=ci−smin
for
16
i6k
.
•Type III:
If
(c1,c2,··· ,cn)=(smin ,smin +2, smin +
1, smin +1, ·· · ,smin +1)
– that is, it starts with
smin ,smin +2
and is followed by
n−2smin +1
’s – then
vi=1
for
16i6k
.
•Type IV:
If
(c1,c2,··· ,cn)=(smin ,smin +2, smin +
2, smin +1, smin +1, ···,smin +1)
– that is, it starts
with
smin ,smin +2, smin +2
and is following by
n−3
smin +1
’s – then
v2=0
and
vi=1
for
i6=2
,
16i6k
.
•Cyclic law:
If we cyclically shift any cell state vector
mentioned above by
i
positions (
06i6n−1
), the
corresponding variable vector also cyclically shifts by
i
positions.
2
To explain how the code is used for rewriting, let’s first
define layer number. Every cell state vector has a layer
number (see Fig. 1 for examples), which is the number of
rewrites it takes for the cells to reach that state. For notational
convenience, if Cis a cell state vector of type I (resp., II, III
or IV), then we call a cyclic shift of Ctype I (resp., II, III
or IV) as well. For this code, the layer number of a cell state
vector
α
= (c1,c2,··· ,cn)is determined as follows:
•If
α
is of type I, it is in layer 2c1.
•If
α
is of type II, let xdenote the number of cells whose
states are smax , then it is in layer 2smin +x.
•If
α
is of type III, it is in layer 2smin +n.
•if
α
is of type IV, it is in layer 2smin +n+1.
For a cell state vector in layer i>0, a rewrite al-
ways changes it into a cell state vector in layer i+1.
For example, if n=k=5and the current cell
state vector is (0, 2, 1, 1, 1)(type III, layer 5, representing
(v1,v2,··· ,v5)=(1, 1, 1, 1, 1)), and we want to change the
variable vector to (1, 1, 1, 0, 1), we can change the variable
state vector to (2, 2, 2, 1, 2)(type II, layer 6). It is simple to
verify through case enumeration that for any cell state vector in
layer i<2(q−1), there are kcell state vectors in layer i+1
it can change into that correspond to the kpossible rewrite
requests. So we get:
Theorem 5.
The code in Construction
4
has
t=2(q−1)
.
Corollary 6.
When
k=3
, the code is optimal.
Proof: By the Theorem 2 of [3], for any floating code
with n>k(l−1)−1,t6[n−k(l−1) + 1](q−1) +
b[k(l−1)−1](q−1)
2c. So when n=k=3and l=2,t6
2(q−1). That matches the performance of this code.
IV. COMPOSITE CODES WITH 36k66
In this section, we present a family of codes for 36k66
and l=2. Due to their similarity, we present the code for
k=4in detail, and describe the codes for k=3, 5, 6 only
succinctly.
Construction 7. (Code for k=4,l=2,n>7and arbitrary
q)
We first show the construction for a simplified case:
q=2
.
Here every valid cell state vector (i.e., a cell state vector that
represents variables) has at least three cells at state 0. The seg-
ment of cells before (resp., behind) the second (resp., second-
last) cell at state 0 is called the
head
(resp.
tail
). (For example, if
the cell state vector is
(0, 1, 0, 0, 1, 1)
, then the head is
(0, 1)
,
the tail is
(0, 1, 1)
.) For simplicity of explanation, denote the
cell state vector by
(a1,a2,··· ,ai, 0, ·· · ,0,bj,·· · ,b2,b1)
.
Here the head and the tail have length
i
and
j
, respectively. Note
that both of them contain exactly one cell at state 0.
The two variables
v1,v2
are determined by the head as
follows: (1)
v1=v2=0
if
i
is odd and
ai=0
; (2)
v1=v2=1
if
i
is odd and
ai6=0
; (3)
v1=0, v2=1
if
i
is even and
ai6=0
; (4)
v1=1, v2=0
if
i
is even and
ai=0
.
The two variables
v3,v4
are determined by the tail in the
same way. Note that here
b1
replaces
a1
,
b2
replaces
a2
, and so
on; and
v3
(resp.
v4
) replaces
v1
(resp.,
v2
).
For a rewrite, if we need to modify the head (resp., tail), we
always change the leftmost (resp., rightmost) cell that gives the
desired result. A rewrite changes the state of exactly one cell.
The process ends when only three cells at state 0 are left.
If
q>2
, we use the cell states layer-by-layer: first use cell
states 0 and 1 as above; then use cell levels1 and 2 in the same
way; then use cell levels 2 and 3
···
Each rewrite raises only
one cell’s state except during the transition from one layer to
the next.
2
Example 8.
Let
k=4, l=2, n=7, q=4
. If the variable
vector changes as
(0, 0, 0, 0)→(1, 0, 0, 0)→(1, 1, 0, 0)→
(1, 1, 1, 0)→(0, 1, 1, 0)→(0, 1, 0, 0)→(0, 1, 0, 1)→
···
, the cell states change as
(0, 0, 0, 0, 0, 0, 0)→
(1, 0, 0, 0, 0, 0, 0)→(1, 0, 1, 0, 0, 0, 0)→
(1, 0, 1, 0, 0, 0, 1)→(1, 0, 1, 1, 0, 0, 1)→
(1, 2, 1, 1, 1, 1, 1)→(1, 2, 1, 1, 1, 2, 1)→ · ·· 2
Theorem 9.
For the code in Construction
7
, if
n
is even,
t=
(n−6)(q−1) + 3
; if
n
is odd,
t= (n−5)(q−1) + 2
.
Proof: It is not hard to see that every rewrite raises one
cell’s state by one, unless the rewrite causes the transition
from one layer to the next. During that transition, if nis even
(resp., odd), at most four (resp., three) cells need to be set to
the higher state of the new layer. So the first layer supports
n−3rewrites and every subsequent layer supports at least
n−6(if nis even) or n−5(if nis odd) rewrites.
The following results summarize the codes for k=3, 5 and
6. We present their constructions in the appendix.
•When k=3, l=2,n>5, if nis even, there is a code
with t= (n−4)(q−1) + 2; otherwise, there is a code
with t= (n−3)(q−1) + 1.
•When k=5, l=2,n>9, there is a code with t>
(n−10 −2 log2n)(q−1) + 3.
•When k=6, l=2,n>12, there is a code with t>
(n−17 −6 log2n)(q−1) + 5.
All the four codes presented here have t=n(q−1)−
o(nq). Since every rewrite raises the cell states (up to q−1),
the codes are all asymptotically optimal in n, the number of
cells, and in q, the number of cell levels.

V. INDEXED CODE
The codes introduced above are for the joint coding of a few
variables. In this section, we introduce a code construction,
indexed code, for general k.
Construction 10. (Indexed code)
Divide the
k
variables into
a
groups:
g1,g2,··· ,ga
. For the
n
cells, set aside a small number
of cells as
index cells
and divide the other cells into
b
groups:
h1,h2,··· ,hb
. Here
a
and
b
are chosen parameters, and
b>a
.
For
16i6a
, the variables of
gi
are coded using a floating
code and are stored in
hi
. Afterwards, every time a cell group
can no longer support any more rewriting (say it stores
gi
), store
gi
in the next unused cell group. The index cells are used to
remember which cell group stores which variable group. (The
details of the index cells is the topic of study in this section.)
2
We first show that the indexed code is asymptotically
optimal in nand q. Let there be √n−o(√n)cell groups,
each containing √n−o(√n)cells. At most logqaindex cells
are needed on average per cell group. Apply known floating
codes, such as those presented in Section IV, to each variable
group. Those codes can support √n(q−1)−o(√nq)rewrites
in each cell group. There can be at most apartially used cell
groups at any moment, so in the end, √n−o(√n)cell groups
are fully used. So the indexed code enables n(q−1)−o(nq)
rewrites.
The simplest way to use index cells is to use logqa
index cells for each cell group to remember which variable
group it stores. However, when nis sufficiently large, much
fewer index cells are necessary. The best coding strategy is
to remember the mapping between the apartially used cell
groups and the avariable groups, which is a permutation.
(The unused, partially used, and fully used cell group are
differentiated in the following way. Cells in unused groups
are at state 0. Make cells in a fully used group all have state
q−1. Ensure that in a partially used group, at least one cell is
not at state q−1. The last step costs the support for at most
one rewrite, depending on the used floating code.)
Example 11.
Let
a=3
and
b=6
. Initially, the cell group
hi
stores the variable group
gi
for
i=1, 2, 3
. Assume that as
rewriting continues, first
h4
is used to store
g2
, then
h5
is used
to store
g1
, then
h6
is used to store
g2
. We use a permutation
(
π
1,
π
2,
π
3)
to record the information that the
i
-th partially
used cell group stores the π
i
-th variable group, for
i=1, 2, 3
.
Then, the permutation changes as
(1, 2, 3)→(1, 3, 2)→
(3, 2, 1)→(3, 1, 2)
. The index cells are used to remember the
permutation. Note that the permutation changes at most
b−a
times.
We now show a coding strategy for the index cells. First,
build a mapping between the permutations and binary vectors
of length four as follows.
binary (0,0,0,0) (0,0,0,1) (0,0,1,0) (1,0,1,0) (1,0,0,0) (1,0,0,1)
vector (0,1,1,1) (0,1,1,0) (0,1,0,1) (1,1,0,1) (1,1,1,1) (1,1,1,0)
permutation (1,2,3) (3,1,2) (2,3,1) (2,1,3) (1,3,2) (3,2,1)
For every change of the permutation, only
one bit
in the
binary vector needs to change. (Note that every such change
shifts one number to the end of the permutation.) For in-
stance, if the permutation changes as
(1, 2, 3)→(1, 3, 2)→
(3, 2, 1)→(2, 1, 3)→(2, 3, 1)
, the binary vector can change
as
(0, 0, 0, 0)→(1, 0, 0, 0)→(1, 0, 0, 1)→(1, 1, 0, 1)→
(0, 1, 0, 1)
. Use a floating code that stores the four bits in the
binary vector (such as the code for four variables in Section IV),
and this code also records the permutation. By Theorem
9
, only
b
q−1+o(b)
index cells are needed, which is close to one index
cell on average for every
q−1
cell groups when
b
is large.
2
The design of general coding schemes for index cells is
beyond the scope of this paper. In the following, We present
a lower bound for the number of index cells that are needed
for remembering the permutation (i.e., the mapping between
partially used cell groups and the variable groups).
Theorem 12.
The number of cells needed for indexing is at
least
b−a
q−1+a
2−1
if
(a−2)(q−1)<2(b−a)
, and at least
2(b−a)
q−1
if
(a−2)(q−1)>2(b−a)
.
Proof: Assume that an indexing scheme that uses xcells
for indexing is given. We first prove that they can only guaran-
tee the recording of at most (x−a+2)(q−1) + (a−2)(q−1)
2
changes of the permutation if x>a−2, and at most x(q−1)
2
changes of the permutation if x6a−2.
Let’s consider the case x>a−2first. Let (s1,s2,···,sx)
denote the states of the xcells. Initially, (s1,s2,·· · ,sx) =
(0, 0, · ·· , 0)and the permutation is (1, 2, ··· ,a). Let A=
(s1,s2,··· ,sa−2)denote the first a−2cells’ states, and let
B= (sa−1,sa,···,sx)denote the last x−a+2cells’ states.
Define the weight of A(resp., B) as ∑a−2
i=1si(resp., ∑x
i=a−1si).
The permutation is a permutation of anumbers; and when
it changes, a number is moved to the back. So there are a−1
possible ways to change a permutation each time. When the
permutation changes, some cell states need to be raised. Since
there are only a−2cells in A, at any time, if all the a−1
ways to change the permutation increase only the weight of A
(not the weight of B), there must be one way of changing the
permutation that increases the weight of Aby at least two.
We now choose a sequence of changes to the permutation
as follows. Assume that i>0changes have been chosen.
For the (i+1)-th change, if all the a−1ways to change
the permutation increase only the weight of A(not the weight
of B), choose the (i+1)-th change as one that increases the
weight of Aby at least two (we call such a change type I);
otherwise, choose the (i+1)-th change as one that increases
the weight of Bby at least one (we call such a change type
II). Since the maximum weight of Ais (a−2)(q−1)and
the maximum weight of Bis (n−a+2)(q−1), there can
be at most (a−2)(q−1)
2changes of type I and at most (n−a+
2)(q−1)changes of type II. So the number of changes of
permutation that the indexing scheme guarantees to record is
at most (x−a+2)(q−1) + (a−2)(q−1)
2.
The case x6a−2is simpler. By the same argument, we
can choose a sequence of changes of the permutation such

that every change increases ∑x
i=1siby at least two. So the
number of changes of permutation that the indexing scheme
guarantees to record is at most x(q−1)
2.
Since there are avariable groups and bcell groups, there
can be b−achanges of permutation. So an indexing scheme
needs to have (x−a+2)(q−1) + (a−2)(q−1)
2>b−aif
x>a−2and have x(q−1)
2>b−aif x6a−2. Thus we get
x>b−a
q−1+a
2−1if x>a−2and x>2(b−a)
q−1if x6a−2.
So when (a−2)(q−1)
2<b−a, we must have x>a−2and
therefore have x>b−a
q−1+a
2−1. When (a−2)(q−1)
2>b−a,
we either have x>a−2>2(b−a)
q−1, or have x6a−2and
therefore have x>2(b−a)
q−1. So the conclusion holds.
VI. CONSTRUCTIONS BASED ON COVERING CODES
There have been no existing floating code constructions for
l>2(i.e., non-binary alphabets) [3]. In this section, we
present a new method that converts floating codes with large
alphabets to floating codes with small alphabets (including
the binary alphabet) by using covering codes. The idea is to
map a variable with a large alphabet to a vector of a small
alphabet such that when the variable changes its value (i.e.,
is rewritten), only a few (preferably one) entries in the vector
change their values. Based on this method, we can obtain a
series of bounds and code constructions for large alphabets.
Construction 13. (Mapping based on linear covering codes)
Let
v
be a variable of alphabet size
l
. Choose an
(n0,k0)
linear
covering code of alphabet size
l0
, which has length
n0
and
dimension
k0
. The requirement is
ln0−k0
0>l
. The code has
ln0−k0
0
cosets of the codewords. Among them, choose any
l
cosets, and map them to the
l
values of
v
.
2
Example 14.
Let
v
be a variable that takes its value from an
alphabet of size
l=4
:
{0, 1, 2, 3}
. Choose the simple
(3, 1)
repetition code. As a result, the mapping from
v
to bit vectors
of length 3 is as follows:
vector (0,0,0) (1,0,0) (0,1,0) (0,0,1)
(1,1,1) (0,1,1) (1,0,1) (1,1,0)
v
0 1 2 3
To design a floating code for variables
v1,v2,···,vk
of alphabet size 4, we first map them to binary vari-
ables
{wi,j|16i6k, 1 6j63}
, where
each binary vector
(wi,1,wi,2,wi,3)
represents
vi
. Then we
use a floating code for the
3k
binary variables. Every
rewrite for
(v1,v2,··· ,vk)
maps to exactly one rewrite for
(w1,1 ,w1,2 ,··· ,wk,3)
. (For instance, if
k=2
and
(v1,v2)
changes as
(0, 0)→(0, 3)→(0, 2)→(3, 2)→(3, 1)
,
the binary vector
(w1,1 ,w1,2 ,w1,3 ,w2,1 ,w2,2 ,w2,3)
will corre-
spondingly change as
(0, 0, 0, 0, 0, 0)→(0, 0, 0, 0, 0, 1)→
(0, 0, 0, 1, 0, 1)→(0, 0, 1, 1, 0, 1)→(0, 0, 1, 1, 0, 0)
.) So if
the floating code supports
t
rewrites for the binary variables, it
also supports
t
rewrites for the 4-ary variables
v1,v2,··· ,vk
.
2
It is important for the selected linear covering code to
have a small covering radius, because when the large-alphabet
variable changes, the covering radius of the code equals
the number of entries in the small-alphabet vector that may
change.
Let Rdenote the covering radius of the (n0,k0)covering
code in Construction 13. Let t(n,q,k,l)denote the greatest
number of rewrites that a floating code can guarantee to sup-
port, when k l-ary variables are stored in ncells with qstates.
(Namely, t(n,q,k,l)is the optimal value of tfor floating codes
with parameters n,q,k,l.) The following theorem compares
the coding performance for different alphabets.
Theorem 15.
t(n,q,k,l)>bt(n,q,kn0,l0)/Rc
Proof: Map the variables v1,v2,···,vkof alphabet size l
to kn0variables of alphabet size l0with Construction 13. Build
an optimal floating code Cfor the kn0variables of alphabet
size l0, which guarantees t(n,q,kn0,l0)rewrites.
For the (n0,k0)covering code, every vector of length n0is
within Hamming distance Rfrom a codeword. So by the sym-
metry of linear codes, for every vector and each of the ln0−k0
0
cosets, there is a vector in the coset that is within Hamming
distance Rfrom the former vector. So when we rewrite vi
(16i6k), we are correspondingly rewriting at most R l0-
ary variables. So Csupports bt(n,q,kn0,l0)/Rcrewrites for
v1,v2,··· ,vk. So t(n,q,k,l)>bt(n,q,kn0,l0)/Rc.
By using known results on covering codes [2], we can obtain
a number of bounds for floating codes with large alphabets
in terms of the performance of floating codes with binary
alphabets. We report some of the results in Fig. 2.
To show how to derive the results in Fig. 2, we first
need to define a few terms. Let l(m,R)denote the smallest
possible length of a binary linear code with codimension (i.e.,
redundancy) mand covering radius R. Let t(n,k)denote
the minimum possible covering radius of (n,k)binary linear
codes. (Note that some of the letters here have different
meanings from those used for floating codes. We use these
notations following the convention of the research on covering
codes [2].) A list of known results on binary linear covering
codes are shown in Fig. 3.
We show how to derive the inequalities in Fig. 2 by two
examples. The first example is the 3rd inequality in Fig. 2:
For a>b>1and l62a−b,
t(n,q,k,l)>bt(n,q,ka, 2)/da−b
2ec.
By the 3rd inequality in Fig. 3, when a>b>1,t[a,b]6
da−b
2e. So if l62a−b, we can map the variables of alphabet
size lto the cosets of a binary (a,b)linear covering code,
whose covering radius is at most da−b
2e. By Theorem 15, we
get the 3rd inequality of Fig. 2.
The second example is the 18th inequality in Fig. 2: For all
m>3and l622m+1,
t(n,q,k,l)>bt(n,q,k(2m+1+2m−4), 2)/2c.

1. For m>2,l62m,t(n,q,k,l)>t(n,q,k(2m−1), 2).
2. For l6211 ,t(n,q,k,l)>bt(n,q, 23k, 2)/3c.
3. For a>b>1and l62a−b,t(n,q,k,l)>bt(n,q,ka, 2)/da−b
2ec.
4. For b>4,a>2b−2and l62a−b,t(n,q,k,l)>bt(n,q,ka, 2)/(ba
2c−2(b−4)/2)c.
5. For l627,t(n,q,k,l)>bt(n,q, 23k, 2)/2c.
6. For l6219 ,t(n,q,k,l)>bt(n,q, 47k, 2)/5c.
7. For all a>1and l62a−1,t(n,q,k,l)>bt(n,q,ka, 2)/ba
2cc.
8. For all a>2and l62a−2,t(n,q,k,l)>bt(n,q,ka, 2)/ba−1
2cc.
9. For all a>3and l62a−3,t(n,q,k,l)>bt(n,q,ka, 2)/ba−2
2cc.
10. For a>6and l62a−4,t(n,q,k,l)>bt(n,q,ka, 2)/ba−4
2cc.
11. For a>7and l62a−5,t(n,q,k,l)>bt(n,q,ka, 2)/ba−5
2cc.
12. For a>14 and l62a−6,t(n,q,k,l)>bt(n,q,ka, 2)/ba−8
2cc
13. For a>19 and l62a−7,t(n,q,k,l)>bt(n,q,ka, 2)/ba−9
2cc.
14. For all b>2,a>22b−1and l62a−2b−1,t(n,q,k,l)>bt(n,q,ka, 2)/ba−2b
2cc.
15. For all b>2,aeven and l62a−2b,t(n,q,k,l)>bt(n,q,ka, 2)/ba−2(2b−1)/2
2cc.
16. For all b>2,aodd and l62a−2b,t(n,q,k,l)>bt(n,q,ka, 2)/ba−2(2b−1)/2−1
2cc.
17. For a>127 and l62a−8,t(n,q,k,l)>bt(n,q,ka, 2)/ba−16
2cc.
18. For all m>3and l622m+1,t(n,q,k,l)>bt(n,q,k(2m+1+2m−4), 2)/2c.
19. For all m>4and l622m,t(n,q,k,l)>bt(n,q,k(2m+1−4), 2)/2c.
20. For all m>1and l624m,t(n,q,k,l)>bt(n,q,k(22m+1−2m−1), 2)/2c.
21. For all m>2and l624m+1,t(n,q,k,l)>bt(n,q,k(22m+1+22m−2m−2), 2)/2c.
22. For all m>2and l624m+2,t(n,q,k,l)>bt(n,q,k(222m+2−2m−2), 2)/2c.
23. For all m>2and l624m+3,t(n,q,k,l)>bt(n,q,k(22m+2+22m+1−2m−2), 2)/2c.
24. For m>4and l622m,t(n,q,k,l)>bt(n,q,k(27 ·2m−4−1), 2)/2c.
25. For m>1and l622m+1,t(n,q,k,l)>bt(n,q,k(5·2m−1−1), 2)/2c.
26. For all m>4and l622m,t(n,q,k,l)6bt(n,q,k(27 ·2m−4−1), 2)/2c.
27. For all m>1and l622m+1,t(n,q,k,l)>bt(n,q,k(5·2m−1−1), 2)/2c.
28. For all m>6and l623m,t(n,q,k,l)>bt(n,q,k(155 ·2m−6−2), 2)/3c.
29. For all m>9and l623m,t(n,q,k,l)>bt(n,q,k(152 ·2m−6−1), 2)/3c.
30. For all m>7and l623m+1,t(n,q,k,l)>bt(n,q,k(3·2m−1), 2)/3c.
31. For all m>4and l623m+2,t(n,q,k,l)>bt(n,q,k(1024 ·2m−8−1), 2)/3c.
32. For all m>8and l623m+2,t(n,q,k,l)>bt(n,q,k(822 ·2m−8−2), 2)/3c.
33. For all m>13 and l623m+2,t(n,q,k,l)>bt(n,q,k(821 ·2m−8−1), 2)/3c.
34. For m=5or m>11 and l624m,t(n,q,k,l)>bt(n,q,k(47 ·2m−4−1), 2)/4c.
35. For all m>8and l624m+1,t(n,q,k,l)>bt(n,q,k(896 ·2m−8−2), 2)/4c.
36. For all m>10 and l624m+1,t(n,q,k,l)>bt(n,q,k(896 ·2m−8−3), 2)/4c.
37. For all m>15 and l624m+1,t(n,q,k,l)>bt(n,q,k(895 ·2m−8−1), 2)/4c.
38. For all m>8and l624m+2,t(n,q,k,l)>bt(n,q,k(992 ·2m−8−2), 2)/4c.
39. For all m>10 and l624m+2,t(n,q,k,l)>bt(n,q,k(992 ·2m−8−3), 2)/4c.
40. For all m>15 and l624m+2,t(n,q,k,l)>bt(n,q,k(991 ·2m−8−1), 2)/4c.
41. For all m>10 and l624m+3,t(n,q,k,l)>bt(n,q,k(1248 ·2m−8−3), 2)/4c.
42. For m=8or m>15 and l624m+3,t(n,q,k,l)>bt(n,q,k(1247 ·2m−8−1), 2)/4c.
Figure2. The relationship between floating codes with l>2and floating codes with l=2. Here t(n,q,k,l)denotes the optimal value of t(the number of
rewrites) for a floating code with the parameters n,q,k,l.
By the 18th inequality in Fig. 3, when m>3,l(2m+1, 2)6
2m+1+2m−4. So when m>3and l622m+1, we can
map variables of alphabet size lto the cosets of a binary
(x,x−2m−1)linear covering code with covering radius 2,
where x=l(2m+1, 2)62m+1+2m−4. By Theorem 15,
t(n,q,k,l)>bt(n,q,kx, 2)/2c. Since x62m+1+2m−4,
t(n,q,kx, 2)>t(n,q,k(2m+1+2m−4), 2). So we get the
18th inequality of Fig. 2.
The rest of the inequalities in Fig. 2 are derived in the same
ways.
Since there have been a number of floating code construc-
tions for binary variables (especially the codes presented in
this paper), floating codes with large alphabets can also be
built. The number of such results that can be obtained is large.
We show some example data of the obtainable floating codes
in Fig. 4.
VII. CONCLUSION
In this paper, several new constructions for floating codes
have been presented. New bounds for floating codes have
also been shown. Compared to the known results, the code

1. (Hamming code:) For m>2,l(m, 1) = 2m−1.
2. (Golay code:)l(11, 3) = 23.
3. For n>k>1,t[n,k]6dn−k
2e.
4. For k>4and n>2k−2,t[n,k]6bn
2c−2(k−4)/2.
5. t(23, 16)62.
6. t(47, 28)65.
7. For all n>1,t[n, 1] = bn
2c.
8. For all n>2,t[n, 2] = bn−1
2c.
9. For all n>3,t[n, 3] = bn−2
2c.
10. For n>4and n6=5,t[n, 4] = bn−4
2c.
11. For n>5and n6=6,t[n, 5] = bn−5
2c.
12. For n>14,t[n, 6]6bn−8
2c.
13. For n>19,t[n, 7]6bn−9
2c.
14. For all p>2and for n>22p−1,t[n, 2 p+1]6bn−2p
2c.
15. For all p>2and for neven, n>22p−1,t[n, 2p]6bn−2(2p−1)/2
2c.
16. For all p>2and for nodd, n>22p−1−1,t[n, 2 p]6bn−2(2p−1)/2−1
2c.
17. For n>127,t[n, 8]6bn−16
2c.
18. For all m>3,l(2m+1, 2)62m+1+2m−4.
19. For all m>4,l(2m, 2)62m+1−4.
20. For all m>1,l(4m, 2)622m+1−2m−1.
21. For all m>2,l(4m+1, 2)622m+1+22m−2m−2.
22. For all m>2,l(4m+2, 2)6222m+2−2m−2.
23. For all m>2,l(4m+3, 2)622m+2+22m+1−2m−2.
24. For m>4,l(2m, 2)627 ·2m−4−1.
25. For m>1,l(2m+1, 2)65·2m−1−1.
26. For all m>4,l(2m, 2)627 ·2m−4−1.
27. For all m>1,l(2m+1, 2)65·2m−1−1.
28. For all m>6,l(3m, 3)6155 ·2m−6−2.
29. For all m>9,l(3m, 3)6152 ·2m−6−1.
30. For all m>7,l(3m+1, 3)63·2m−1.
31. For all m>4,l(3m+2, 3)61024 ·2m−8−1.
32. For all m>8,l(3m+2, 3)6822 ·2m−8−2.
33. For all m>13,l(3m+2, 3)6821 ·2m−8−1.
34. For m=5and for all m>11,l(4m, 4)647 ·2m−4−1.
35. For all m>8,l(4m+1, 4)6896 ·2m−8−2.
36. For all m>10,l(4m+1, 4)6896 ·2m−8−3.
37. For all m>15,l(4m+1, 4)6895 ·2m−8−1.
38. For all m>8,l(4m+2, 4)6992 ·2m−8−2.
39. For all m>10,l(4m+2, 4)6992 ·2m−8−3.
40. For all m>15,l(4m+2, 4)6991 ·2m−8−1.
41. For all m>10,l(4m+3, 4)61248 ·2m−8−3.
42. For m=8and for all m>15,l(4m+3, 4)61247 ·2m−8−1.
Figure3. Existing bounds for binary linear covering codes [2].
constructions presented in this paper are considerably broader,
covering general parameters. Several novel coding techniques
– including indexes based on permutations, code mapping
based on covering codes, etc. – have been presented. As future
research, the authors will study the further optimization of
these coding techniques.
APPENDIX
In this appendix, we present the constructions of the com-
posite codes for k=3, 5 and 6.
The composite code in Construction 7 – a code that encodes
four binary variables – uses the head and the tail of the cell
array to encode two variables, respectively. In the same way,
we get the following floating code for k=3.
Construction 16. (Code for k=3,l=2,n>5and arbitrary
q)
We first show the construction for a simplified case:
q=
2
. Here every valid cell state vector has at least two cells at
state 0. The segment of cells before (resp., behind) the second
(resp., the last) cell at state 0 is called the
head
(resp.,
tail
).
(For example, if the cell state vector is
(0, 1, 0, 0, 1, 1, 1)
, then
the
head
is
(0, 1)
, the
tail
is
(1, 1, 1)
. The
head
encodes the
variables
v1,v2
in the same way as Construction
7
. The
tail
encodes the variable
v3
as follows: if the number of cells in the
tail is even (including zero),
v3=0
; otherwise,
v3=1
.

n q k l t tup
α
20 8 5 2 49 126 0.39
60 8 5 2 223 406 0.55
100 8 5 2 465 686 0.68
20 8 2 4 49 122 0.40
60 8 2 4 223 402 0.55
100 8 2 4 465 682 0.68
20 8 2 8 16 94 0.17
60 8 2 8 121 374 0.32
100 8 2 8 265 654 0.41
20 8 5 4 14 91 0.15
60 8 5 4 85 371 0.23
100 8 5 4 248 651 0.38
Figure4. Some typical data on obtained floating codes. Here tis the number
of rewrites guaranteed by the obtained code, tup is an upper bound for t
(computed using known results), and
α
=t/tup .
If
q>2
, we use the cell states layer-by-layer, the same way
as Construction
7
.
Example 17.
Let
k=3, l=2, n=7, q=4
. If the
variables change as
(0, 0, 0)→(0, 1, 0)→(0, 1, 1)→
(1, 1, 1)→(1, 1, 0)→(0, 1, 0)→(0, 1, 1)→(1, 1, 1)→
(1, 0, 1)→(0, 0, 1)→(1, 0, 1)···
, the cell states
change as
(0, 0, 0, 0, 0, 0, 0)→(0, 1, 0, 0, 0, 0, 0)→
(0, 1, 0, 0, 0, 0, 1)→(0, 1, 1, 0, 0, 0, 1)→
(0, 1, 1, 0, 0, 1, 1)→(0, 1, 1, 1, 0, 1, 1)→
(1, 2, 1, 1, 1, 1, 2)→(1, 2, 2, 1, 1, 1, 2)→
(2, 2, 2, 1, 1, 1, 2)→(2, 2, 2, 2, 1, 1, 2)→
(3, 2, 2, 2, 2, 2, 3)→ ··· 2
Theorem 18.
For the code in Construction
16
, if
n
is even,
t=
(n−4)(q−1) + 2
; if
n
is odd,
t= (n−3)(q−1) + 1
.
Proof: It is not difficult to see that every rewrite only
raises one cell state by one, unless the rewrite causes the
transition from one layer to the next. During that transition,
if nis even (resp., odd), at most three (resp., two) cells need
to be set to the higher state of the new layer. The conclusion
follows.
We now present the code constructions for k=5and 6.
In these two constructions, we use three segments – the head,
tail, and middle part – of the cell array to separately encode
variables.
Construction 19. (Code for k=5,l=2,n>9and arbitrary
q)
We first show the simplified case:
q=2
. A valid cell state
vector has at least four cells at state 0. The second and second-
last cells at state
0
splits the
n
cells into three parts: the
head
, the
tail
and the
middle part
. The head encodes
v1,v2
and the tail
encodes
v4,v5
. The middle part contains a consecutive segment
of cells at state 1. If the length of the segment is odd,
v3=1
;
otherwise,
v3=0
. (The length can be zero.) We always try to
make the segment stay evenly between the head and the tail; if
the segment gets too close to the head (or tail), we merge it with
the head (or tail) and then create a new middle part.
When
q>2
, the layer-by-layer method is used.
2
Example 20.
Let
k=5, l=2, n=15, q=4
.
If the variables change as
(0, 0, 0, 0, 0)→
(0, 0, 1, 0, 0)→(1, 0, 1, 0, 0)→(1, 0, 1, 0, 1)→
(1, 0, 0, 0, 1)→(1, 1, 0, 0, 1)→(0, 1, 0, 0, 1)→
(1, 1, 0, 0, 1)→(1, 0, 0, 0, 1)→(1, 0, 1, 0, 1)→
(1, 0, 1, 0, 0)→(0, 0, 1, 0, 0)→ ···
, the cell
states change as
(
0
, 0,
0,0,0,0,0,0,0,0,0,0,0
, 0,
0
)
→(
0
, 0,
0,0,0,0,0,1,0,0,0,0,0
, 0,
0
)
→(
1,0
, 0,
0,0,0,0,1,0,0,0,0,0
, 0,
0
)
→(
1,0
, 0,
0,0,0,0,1,0,0,0,0
, 0,
1,0
)
→(
1,0
, 0,
0,0,0,1,1,0,0,0,0
, 0,
1,0
)
→(
1,0,1
, 0,
0,0,1,1,0,0,0,0
, 0,
1,0
)
→(
1,0,1,1
, 0,
0,1,1,0,0,0,0
, 0,
1,0
)
→(
1,0,1,1,1
, 0,
1,1,0,0,0,0
, 0,
1,0
)
→(
1,1,1,1,1,1,1,1,1,0
, 0,
0
, 0,
1,0
)
→(
1,1,1,1,1,1,1,1,1,0
, 0,
1
, 0,
1,0
)
→(
2,1
, 1,
1,1,1,1,1,2,1,1,1,1
, 1,
1
)→
(
2,2,1
, 1,
1,1,1,1,2,1,1,1,1
, 1,
1
)→ ··· 2
Theorem 21.
The code in Construction
19
has
t>(n−10 −
2 log2n)(q−1) + 4
.
Proof: There are two cases where a rewrite can increase
the weight of the cell state vector by more than one: (1) The
case where the head (or tail) and the middle part meet, in
which case we need to increase the weight by at most three;
(2) the case where the code transits from one layer to the next
layer, in which case we need to increase the weight by at most
eleven (including six cells at the lower level and five cells at
the upper level). The first case happens at most (q−1)log2n
times. The second case happens at most q−1times. So we
get t>(n−10 −2 log2n)(q−1) + 4.
Construction 22. (Code for k=6,l=2,n>12 and
arbitrary q)
First, consider the simplified case:
q=2
. Same as
the code in Construction
19
, this code also has the head, tail and
middle part. In the same way as Construction
7
, the
head
stores
two variables
v1,v2
, the
tail
stores another two variables
v5,v6
.
The
middle part
stores the two variables
v3,v4
as follows: In
the middle part, (1) if there is no cell at state 1, or if the cells
at state 1 are consecutive and the number of cells at state 1 is
even,
v3=0, v4=0
; (2) if the number of cells at state 1 is
even and there is exactly one cell at state 0 between the cells at
state 1,
v3=1, v4=1
; (3) if the number of cells at state 1 is
odd and those cells at state 1 are consecutive,
v3=1, v4=0
;
(4) if the number of cells at state 1 is odd and there is exactly
one cell at state 0 between the cells at state 1,
v3=0, v4=1
.
The layer-by-layer method is used if
q>2
.
2
Example 23.
Let
k=6, l=2, n=20, q=4
. If
the variables change as
(000000)→(000100)→
(100100)→(100110)→(100010)→(110010)→
(010010)→(110010)→(100010)→(110010)→
(100010)→(100011)→(101011)→ ···
, the cell states
change as
(
0
, 0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
, 0, 0)→
(
0
, 0,
0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0
, 0,
0
)→
(
1,0
, 0,
0,0,0,0,0,1,0,1,1,0,0,0,0,0,0
, 0,
0
)→
(
1,0
, 0,
0,0,0,0,0,1,0,1,1,0,0,0,0,0
, 0,
0,1
)→
(
1,0
, 0,
0,0,0,0,0,1,1,1,1,0,0,0,0,0
, 0,
0,1
)→

(
1,0,1
, 0,
0,0,0,0,1,1,1,1,0,0,0,0,0
, 0,
0,1
)→
(
1,0,1,1
, 0,
0,0,0,1,1,1,1,0,0,0,0,0
, 0,
0,1
)→
(
1,0,1,1,1
, 0,
0,0,1,1,1,1,0,0,0,0,0
, 0,
0,1
)→
(
1,1,1,1,1,0
, 0,
0,1,1,1,1,0,0,0,0,0
, 0,
0,1
)→
(
1,1,1,1,1,0,1
, 0,
1,1,1,1,0,0,0,0,0
, 0,
0,1
)→
(
1,1,1,1,1,1,1,1,1,1,1,1,1,0
, 0,
0,0
, 0,
0,1
)→
(
1,1,1,1,1,1,1,1,1,1,1,1,1,0
, 0,
0
, 0,
1,0,1
)→
(
2,1
, 1,
1,1,1,1,1,1,2,1,1,1,1,1,1
, 1,
2,2,1
)→ ··· 2
Theorem 24.
The code in Construction
22
has
t>(n−17 −
6 log2n)(q−1) + 6
.
Proof: There are three cases where a rewrite can increase
the weight of the cell state vector by more than one: (1) The
case where the head (or tail) and the middle part meet, in
which case we increase the weight by at most seven (a weight
increase of at most four for the new head or tail, and a weight
of at most three for the new middle part); (2) the case where
the code transits from one layer to the next layer, in which
case we increase the weight by at most eighteen (including
eleven cells at the lower level and seven cells at the upper
level); (3) the case where we rewrite the middle part for the
first time for a layer, in which case we increase the weight by
at most three. The first case and third case together happen at
most (q−1)log2ntimes. The second case happens at most
q−1times. So we get t>(n−17 −6 log2n)(q−1) + 6.
REFERENCES
[1] P. Cappelletti, C. Golla, P. Olivo and E. Zanoni (Ed.), Flash memories,
Kluwer Academic Publishers, 1st Edition, 1999.
[2] G. Cohen, I. Honkala, S. Litsyn and A. Lobstein. Covering codes, North-
Holland, 1997.
[3] A. Jiang, V. Bohossian and J. Bruck, “Floating codes for joint informa-
tion storage in write asymmetric memories,” Proc. IEEE International
Symposium on Information Theory (ISIT), Nice, France, June 2007.
[4] A. V. Kuznetsov and A. J. H. Vinck, “On the general defective channel
with informed encoder and capacities of some constrained memories,”
IEEE Trans. Inform. Theory, vol. 40, no. 6, pp. 1866-1871, Nov. 1994.
[5] R. L. Rivest and A. Shamir, “How to reuse a ‘write-once’ memory,”
Information and Control, vol. 55, pp. 1-19, 1982.