IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 44, NO. 2, MARCH 1998 599
On a New Class of Codes for
Identifying Vertices in Graphs
Mark G. Karpovsky, Fellow, IEEE, Krishnendu Chakrabarty, Member, IEEE, and Lev B. Levitin,
Fellow, IEEE
Abstract—We investigate a new class of codes for the optimal
covering of vertices in an undirected graph
G
such that any vertex
in
G
can be uniquely identified by examining the vertices that
cover it. We define a ball of radius
t
centered on a vertex
v
to
be the set of vertices in
G
that are at distance at most
t
from
v:
The vertex
v
is then said to cover itself and every other vertex
in the ball with center
v:
Our formal problem statement is as
follows: Given an undirected graph
G
and an integer
t
1
, find
a (minimal) set
C
of vertices such that every vertex in
G
belongs
to a unique set of balls of radius
t
centered at the vertices in
C
:
The set of vertices thus obtained constitutes a code for vertex
identification. We first develop topology-independent bounds on
the size of
C
:
We then develop methods for constructing
C
for
several specific topologies such as binary cubes, nonbinary cubes,
and trees. We also describe the identification of sets of vertices
using covering codes that uniquely identify single vertices. We
develop methods for constructing optimal topologies that yield
identifying codes with a minimum number of codewords. Finally,
we describe an application of the theory developed in this paper
to fault diagnosis of multiprocessor systems.
Index Terms—Code construction, coding theory, covering ra-
dius, fault diagnosis, graph theory, multiprocessor systems.
I. INTRODUCTION
G
RAPHS find a wide range of applications in several
fields of engineering and information sciences. A graph
can be used to represent almost any physical situation and
the relationship between various entities. Graph models are
therefore often employed in solving a number of practical
problems [7].
In this paper, we investigate the problem of covering the
vertices of a graph
such that we can uniquely identify any
vertex in
by examining the vertices that cover it. We define
a ball of radius
centered on a vertex to be the set of
vertices of
that are at distance at most from (The
distance between vertices
and is the number of edges in
a shortest path between
and .) The vertex is then said to
cover itself and every other vertex in its ball. We are interested
in identifying the vertices of
using a minimum number of
balls of radius
This is formally stated as follows: Given an
undirected graph
and an integer , find a (minimal) set
of vertices such that every vertex of belongs to a unique set
Manuscript received November 5, 1996; revised August 7, 1997. This work
was supported in part by the National Science Foundation under Grant MIP
9630096, by NATO under Grant 910411, and by a start-up grant from Boston
University’s College of Engineering.
The authors are with Reliable Computing Laboratory, Department of
Electrical and Computer Engineering, Boston University, Boston, MA 02215
USA.
Publisher Item Identifier S 0018-9448(98)00841-4.
of balls of radius centered at the vertices in We view as
an identifying code such that all vertices in it are codewords.
An application of the theory developed in this paper lies in
fault diagnosis of multiprocessor systems. The purpose of fault
diagnosis is to test the system and locate faulty processors. A
multiprocessor system can be modeled as an undirected graph
, where is the set of processors and is the set
of links in the system. Specific software routines are executed
on certain selected processors to carry out diagnosis. The
selection of these processors is done by generating the code
that allows for unique identification of faulty processors. Every
processor corresponding to a codeword vertex tests itself and
all its neigbhoring processors. This corresponds to the use of
balls of radius one centered at the codewords, i.e.,
Hence an optimal code (minimum number of codewords)
minimizes the amount of overhead required to implement fault
diagnosis.
The organization of the paper is as follows. In Section II,
we develop topology-independent bounds on the size of
,
and present methods for constructing
for practical topologies
such as meshes, binary and nonbinary cubes, and trees. Section
III addresses the problem of constructing codes that identify
not just single vertices as in the previous sections, but sets of
vertices of up to a given size. Finally, in Section IV, we discuss
the construction of optimal graphs that yield identifying codes
with a minimum number of codewords.
II. C
ODE CONSTRUCTION
Let be the minimum number of codewords required
to identify every vertex uniquely when a ball of radius
is
used. We first obtain some lower bounds on
Let
be the volume of a ball of radius centered at vertex , i.e.,
the number of vertices that are at distance at most
from
Theorem 1: For a graph with vertices
1)
2) Let Then
, where is the smallest integer such that
where is the
binary entropy function.
3) Let
be the smallest integer such that for a certain
, the following conditions are
0018–9448/98$10.00 1998 IEEE
600 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 44, NO. 2, MARCH 1998
satisfied:
(1)
(2)
Then
Proof: The first lower bound follows from the fact that
there are
cases ( different vertices and the selection
of no vertex—no vertex is identified) to be distinguished.
Therefore, the information can be encoded in a minimum of
bits.
We prove the second bound as follows. We denote by
the result of the (identification) test
performed by the
th codeword. Each is a binary random
variable:
Denote by the random variable which
is equal to
when no vertex is to be identified and
if the th vertex is to be identified. In the absence
of any a priori knowledge, we assume that all
cases are
equiprobable. Thus the entropy
Now,
denote by
the information in about
given the outcomes of Then
(3)
On the other hand,
(4)
Since
(the value of is
uniquely determined by
), we obtain
(5)
However, the probability
, hence
(6)
It follows from (4)–(6) that the number of codewords is not
smaller than the smallest
such that
To prove the third bound, we consider a binary
matrix
where
if the th codeword covers the th vertex, and
otherwise. Denote by the weight (number of
nonzero components) of the
th row and by the weight
of the
th column. Obviously,
(7)
Our goal is to find the minimum
for a given and
provided that all columns of are
nonzero and distinct.
Consider the dual problem: for a given
, find the max-
imum number
of distinct and nonzero columns. Since,
obviously,
it follows that
(8)
To maximize the number of columns
under the constraint
(8), we have to choose the weights of the columns
as
small as possible, starting with columns of weight
, , etc.,
up to the point where the right-hand side of (8) is exceeded.
Let
be an integer such that
(9)
For the maximum possible number of columns
, (8)
should turn into an equality. Taking into account (9), let
(10)
where
Obviously,
(11)
We need to consider the following three cases.
1)
Then the largest number of columns and the equality in (8)
are achieved if we use all possible distinct columns of weights
columns of weight and
columns of weight
2)
To maximize and to achieve the equality in (8), we should
use all columns of weights
columns of
weight
all columns of weight and
columns of weight
3)
Then we should use all columns of weights
In all cases, the total number of columns in is
(12)
KARPOVSKY et al.: NEW CLASS OF CODES FOR IDENTIFYING VERTICES IN GRAPHS 601
In fact, because of (8), (12) gives an upper bound on the
number
of columns for a given number of rows (where
is defined by (9)). It follows that for a given , the minimum
number of rows
should satisfy (1). Thus (1) and (2) together
determine a lower bound on the number of codewords for a
given number
of vertices.
In the special case of a regular graph where
for all , (9) and (12) take simpler forms
(13)
(14)
A simpler lower bound in the case of a regular graph is
given by Theorem 2.
Theorem 2: The size of an identifying code for a regular
graph with
vertices is lower-bounded by
(15)
Proof: As in the proof of Theorem 1, consider the
binary matrix , where if and only if the th
codeword covers the
th vertex, and otherwise. The
number of nonzero elements in the matrix is obviously
On the other hand, since at most columns can have weight
and the remaining columns must be of weight at
least
, the number of nonzero elements should be at least
Hence,
Therefore,
The lower bound (15) is, in general, weaker than (13) and
(14). However, both bounds coincide if
It can be shown
in Theorem 1 (part 3), that
if and only if
The latter condition is satisfied for a broad class of graphs if
does not grow too fast with
We next examine some specific graph topologies.
A. Binary Cubes
A binary
-cube computer is a multiprocessor system with
processors interconnected as an -dimensional binary
cube. Each processor
constitutes a node of the cube and
is a self-contained computer with its own CPU and local
memory. Each
also has direct communication paths to
other neighbor processors through the edges of the cube.
An example of a commercial binary-cube computer is the
NCUBE/ten, which is a ten-dimensional system developed by
NCUBE Corporation [8], [14].
Let
be the minimum number of codewords required
for identifying the vertices in an
-dimensional binary cube
using balls of radius
We first consider the case The
specific topology of the
-dimensional cube imposes addi-
tional constraints which makes the lower bounds of Theorems
1 and 2 unattainable. A tighter lower bound is given by the
following theorem, a proof of which is given in the Appendix.
Theorem 3: For an
-dimensional binary cube, ,
(16)
where
is the volume of the ball of radius
two in the Hamming space
The lower bound (16) is achieved if there exists a perfect
covering of the
-dimensional cube by balls of radius two,
i.e., a perfect code
1
with distance five. The only such case is
for
Then all vertices of weight one and four can be
chosen as codewords, and the total number of codewords is
ten, which is given by (16).
Let
be the size of an optimal code
2
of length
with covering radius , i.e., every vertex is at Hamming
distance at most
from a codeword of [4], [5], [9],
[12], [17], [21]. An upper bound on
follows from the
theorem below.
Theorem 4: Let
be an optimal binary code of length
and covering radius , i.e., has codewords. Then,
for
, a code identifying vertices in the -dimensional
binary cube can be selected as
( is the Hamming distance between and ).
Proof: We show that every vertex in the cube
is
covered by a unique set of codewords.
Case 1:
Let
Every neighbor of belongs to and therefore
covers
We need to prove that there exists no vertex that is
covered by the same set of vertices. Let
The codewords covering are
where and Clearly, is the only
vertex that is a neighbor of all these codewords.
Case 2:
Let
and Now, is covered by itself and
every neighbor
We show that there exists such
that
but Note that because there
are no triangles in
, there does not exist a vertex such
that
Hence, we have only to prove the
existence of
for every Let be a neighbor of
Since , there exist exactly two vertices that are at
distance one from both
and One of these vertices (from
above) is
; the other is
Case 3:
Let
and Suppose is covered by codewords
in
Without loss of generality, let
and the codewords covering be
1
A binary
(
n
;k;
2
l
+1)
code is perfect if
6
l
i
=
1
K
l
=2
n
0
k
:
2
An optimal covering code is one that has a minimum number of code-
words.
602 IEEE TRANSACTIONS ON INFORMATION THEORY, VOL. 44, NO. 2, MARCH 1998
Clearly, there is no vertex other than that is at distance one
from all these codewords. Hence
is uniquely identified.
Next, suppose
Without loss of generality, let
and the only codeword covering be
There must exist at least one vertex in the
covering code
such that Thus
It can now be easily seen that each vertex in the above set
contributes codewords to
that cover , which contradicts the
assumption that
Finally, suppose Let the two codewords covering
be and Now,
is the only vertex other than that is at distance one from both
these codewords. If
then is uniquely identified. If
then there exists that generates
as a codeword of Once again, without loss of generality,
let
Then which
contradicts our assumption that
Hence and is
uniquely identified.
Corollary 1: The number of codewords in an optimal iden-
tifying code with
for a binary -cube is
upper-bounded by
(17)
Exact values for small
as well as bounds on are
available in the literature; see, e.g., [3]. In particular
Using this and (16), we get
For example, if , then
Therefore, for we have
The ratio of the upper bound to the lower bound
with
Another solution to the identifying code construction prob-
lem for an
-dimensional binary cube is obtained by se-
lecting codewords separately for its two constituent
-dimensional cubes. This “divide and conquer” approach,
which implies that
, often gives better
results for small
than the construction method using
(see Table I). Note that for and we achieved the
lower bound on
using ad hoc construction methods.
The construction of Theorem 4 can be extended in a
straightforward manner for
We now construct an
optimal
with covering radius ; the number of codewords
in
is The identifying code is generated by
selecting vertices that are at distance exactly
from the ver-
tices in
TABLE I
N
UMBER OF CODEWORDS REQUIRED FOR IDENTIFYING
VERTICES IN
BINARY CUBES
Theorem 5: For any given , a code for identifying
vertices in the
-dimensional binary cube can be
obtained by selecting as codewords all vertices at distance
exactly
from the codewords of an optimal code which
has covering radius
, i.e.,
Proof: We first make the following observation: if ver-
tices
and are such that there is at least one ball centered
at a vertex in
to which belongs but does not
belong, then
and can be distinguished using codewords
from
Therefore, we only need to prove that any two vertices
can be distinguished if they belong to the same ball of radius
centered at a vertex
Without loss of generality, let
All vertices of weight now belong to and serve as
codewords for identifying a vertex. Given two vertices
and
that are in the same ball centered at , we show that we
can always find a codeword
such that covers one of
them but not the other. We define
to be a vector
with components
. In addition, if ,
and
is the component-wise negation of Let
and , where is the weight of Assume,
without loss of generality, that
It follows therefore
that
because otherwise both and will be the same
vertex
Consider now three cases:
1)
We choose
such that Then and
2) Note that if then ,
otherwise,
and would be identical. Assume that at least
one of two conditions is fulfilled:
or is even. Choose
such that
and
Then and
On the other hand,
Thus in both cases, codeword covers but not
KARPOVSKY et al.: NEW CLASS OF CODES FOR IDENTIFYING VERTICES IN GRAPHS 603
TABLE II
B
OUNDS ON THE NUMBER OF CODEWORDS IN AN OPTIMAL
IDENTIFYING CODE WITH
t
=
2
FOR AN
n
-DIMENSIONAL BINARY CUBE
3) and is odd. Then and at least
one of two conditions is fulfilled:
is even or
Choose such that and
Then
and
Thus in this case, codeword covers but not
Corollary 2: For , the number of codewords
required for identifying vertices in a binary cube is upper-
bounded by
We next estimate the ratio between the upper bound and
the lower bound on the number of codewords
when
is an integer. We know from (15) and Corollary 2 that
Since [3], it follows
that
Using the following well-known upper bound on (see
e.g. [3]):
we obtain
If then using
for and constant ,weget
3
The ratio of the upper bound to the lower bound
is therefore given by
For , we have as before, while for ,
For the special case of , we have the
following corollary, which follows from the fact that
Corollary 3: The number of codewords required for a bi-
nary cube with
dimensions using balls of radius
is upper-bounded by
As special cases, for , we have and
for
we have
Table II shows the upper and lower bounds on For
the lower bounds, we used (15) for
since
for these cases, and (15) coincides with the bound given by
Theorem 1 (part 3). For
, we applied Theorem 1 (part 3)
directly and obtained tighter bounds than given by (15). For
, the covering radius approach cannot be applied with
The last column of the table is based on the following
result, which we prove later (see Corollary 7):
(18)
While it may be intuitively expected that the number of
codewords required for identification decreases as
increases,
this is not necessarily the case. For example,
but
3
a
(
n
)
b
(
n
)
$
lim
n
!1
a
(
n
)
=b
(
n
)=1
:
