Download 3. Generation of the Quantum Fault Table

Principles of Quantum Fault Diagnostics
J. Biamonte, J. Allen, M. Lukac, M. Perkowski
Submitted to: McNair Research Journal 8/8/2004
Portland Quantum Logic
Department of Electrical Engineering, Portland State University,
Portland, Oregon, 97207-0751, USA
Keywords: Quantum Computing, Quantum Fault Localization, Quantum Test, Quantum error – correction, Quantum error - detection
Abstract: The diagnostic problem of fault localization for quantum circuits is considered for the first time.
In this study we introduce an algorithm used to identify and localize errors in quantum circuits; we apply
our algorithm to example circuits using known errors that occur in quantum circuits [ 3, 4, 5], and we
define the quantum fault model. An overview is presented contrasting classical test theory with the new
quantum test theory presented here. Two new types of faults having no parallel in other types of circuit
technology are presented, named and formalized in this work. We introduce and define the quantum fault
table, and categorize its entries; a method is presented illustrating how to construct a class of statistical
decision diagrams from entries in a quantum fault table.
This study has been motivated for the following reasons: (1) various quantum error-correcting codes have
been developed, but no research has been done on the problem of formulating a general approach for
minimizing the number of tests needed to identify errors in the quantum circuit itself, (2) such research may
lead to the development of improved error-correcting codes, (3) physicists currently resort to exhaustively
testing quantum circuits, where all possible inputs and outputs are compared; based on the current trends
in quantum computing technology, quantum circuits will soon be larger than what is feasible to test
exhaustively, forcing a need for the diagnostic testing method introduced here, and finally (4) Quantum test
set generation has been mentioned in the literature several times, yet at the time of this writing no in depth
study has been done [13, 12].
1.
2.
Introduction and Overview............................................................................................................... 2
The problem of Testing a Quantum Circuit ..................................................................................... 3
2.1.
Selecting a Quantum Fault Model ............................................................................................... 4
2.2.
The existence of complete test sets.............................................................................................. 5
3.
Generation of the Quantum Fault Table ........................................................................................... 6
3.1.
The Quantum Covering Problem ................................................................................................. 7
4.
Localization of Faults ....................................................................................................................... 8
4.1.
Fault Trees ................................................................................................................................... 9
4.2.
Testing CAD Tool and Simulations – Q-Fault...........................................................................10
5.
Conclusion ......................................................................................................................................10
6.
Acknowledgements .........................................................................................................................10
Work Cited ....................................................................................................................................................11
7.
Appendix 1: Metrics ........................................................................................................................12
1
1. Introduction and Overview
I
In classical circuits the phrase “probabilistic fault”
(with contributions from [6, 7, 8, 9]) and the phrase
“deterministic fault” (with contributions from [6,
7, 8, 9]), should not be used when referring to a
fault in a quantum circuit, we will show that this
terminology is incorrect. It is the authors’ hope that
the new types of faults defined here will be coined
“quantum faults”, as is the case for the remainder
of this paper.
n classical circuit design an error in a circuit is
typically referred to as a fault – in this paper we use
the word error and fault interchangeably when
referring to both classical and quantum circuits. In
classical circuits we represent the occurrence of
faults digitally as the inversion of one or more bits
of information at one or more locations in the
circuit [6, 7, 11]. In analog circuits a fault is
manifested by lost signal integrity at one or more
stages in the circuit. The detection of faults
broudly falls in two distinct types of tests: (1)
Parametric tests, as those typically adapted by an
analog test engineer, taking into account
parametric measures [6]. (2) Logical test [6],
(known also as functional test [6,7,8,9]) in which
the functional output of a system is compared with
the expected output value for a given input test [6,
7, 8, 9].
Although it may seem as if testing quantum circuits
is similar to testing reversible circuits, there is
actually little specific similarity between the two.
An in-depth study of quantum circuits leads one to
understand that although quantum circuits are by
definition reversible, the fundamental differences
between the inner workings of quantum gates and
the gates used in other implementations of
reversible logic have a drastic impact on testing.
For example, a study recently done in [13] noted
that, “Each test vector covers exactly half of the
possible faults, and each fault is covered by exactly
half of the possible test vectors.” However, we
found that a similar property of symmetry does not
exist in quantum circuits. On the other hand, the
theories used in testing classical logic circuits form
the foundation for the new types of theories that we
develop and present here, especially in [6, 7, 8, 9,
10, 11].
A quantum computer can suffer from three general
types of errors; measurement, preperation, or
evolution. In this work, we concern ourselves with
Logical testing as applied to quantum circuits,
where we inspect the logical data processed by the
quantum circuit and compare this data with the
expected values allowing us to make a judgement
on the quantum circuits functionality.
To further narrow the category of logical testing,
we now form three catagories of fault occurance
where both classical and quantum circuits suffer:
(1) faults inherent in the circuit by manufacturing
errors (system faults [6], Manufacturing faults [6],
Physical malfunctions/defects [6, 7, 9]), (2) faults
introduced by the programmer (design errors [6],
Conceptual Errors [6], programming errors/bugs)
and (3) random errors caused by the environment
(transient failures [6], soft errors [6, 8], random
errors [13], probabilistic faults).
Most research to date (called Quantum errorcorrection [1, 2, 4, 5]) amounts to correcting a
phase or Pauli rotation fault through errorcorrecting codes, “… [Errors] can be characterized
by the application of a linear combination of the
Pauli spin matrices…” [2]. In order to prevent
quantum errors of this certain type, elegant codes
(such as those mentioned in [1, 2, 3, 5, 6]), have
been developed, surprisingly these codes ignore the
idea of a global phase error [14]. Our approach
involves testing for any type of quantum error that
can be represented with a fault model. It is
believed that the methods introduced in this work
can also be used to help design quantum circuits
that are more tolerant to random errors (fault
tolerant quantum circuits), system errors [2], and
the error of global phase [14,1].
As noted, similarity exists between the categories
of classical circuit faults and quantum circuit faults
listed so far, with the following very notable
exceptions: (1) A quantum circuit may have a fault
always present that is never detectable when
measured and (2) A quantum circuit may always
have a fault present that is only detectable in some
percentage of measurements. This gives rise to a
new definition needed to represent faults with these
properties, observed so far only in quantum circuits.
2
We organized this paper as follows: Section 2
addresses general issues related to diagnostic
testing of quantum circuits. An overview of the
different quantum fault models are presented, and
contrasted with known classical properties, and the
test set is discussed. In section 3 we present our
algorithm in the most general form, creating a
quantum fault table. We follow this with a
discussion of the covering problem. Section 4
presents several decision diagrams representing
localization trees, and then we conclude our work
by discussing future plans for a CAD tool based on
QuIDDpro [15]. The appendix contains a brief
introduction to quantum circuits. (if the
introduction to quantum circuits is not published
with this document, it can be found online at:
www.ece.pdx.edu/~biamonte ).
2. The problem of Testing a Quantum Circuit
method is to find a minimal test set to locate all the
faults in the circuit. The minimal test set is found
using an algorithm to solve the covering problem
from a location table. The size of this table limits
the applicability of this approach to relatively small
problems. Therefore we concentrate here only on
the Adaptive Tree Method [16], which dynamically
solves the covering problem and generates a fault
tree.
T
raditionally the Test Generation Problem is
thought of as the generation of a sequence of tests,
(test set) that when applied to a circuit and
compared with the circuit’s output, will either
verify that the circuit is correct or will determine
that it contains one or more faults [6]. In other
words, testing is the verification of functionality,
and running the ideal test set amounts to complete
system verification.
In this paper we do not address the issue of testing a
quantum circuit that has as its function a certain
expected probability of any number of basis states
when read, instead we address only circuits that are
supposed to function with the identical output when
measured any number of times. To solve the
problem of localizing faults in quantum circuits, we
must perform several steps that will be explained in
greater detail in the following sections:
(1)
calculate the ideal (expected) value of the circuit
under test, (2) choose a fault model that best
describes the error predicted to be present in a
given circuit (In the most general case an arbitrary
2 x 2 matrix), (3) determine the locations in the
circuit that the error is believed to be located in, (4)
place the gate representing the fault model at each
location in the circuit (from 3), and generate
separate calculations for each placement, (5)
generate fault table that contains a column for
every fault inserted in the circuit, a row for every
possible input vector to the circuit, and a cell that
contains the output of the circuit under the
conditions of the column,(6) apply the algorithm
presented in section 4 to the fault table generating
a decision diagram that contains instructions of
how to localize faults present in the circuit, and (7)
apply the test set (input) listed in the decision
diagram to localize (where possible) and detect the
faults present in an actual quantum circuit.
It is the typical case that certain single tests can
verify the existence of a fault at multiple locations
in a circuit at the same time, thus it is often the goal
to choose the fewest tests possible needed to
determine all possible errors. On the other hand, if
a circuit was found not to pass a certain test, a
method referred to commonly as fault diagnostics
can be employed. Fault diagnostics amounts to
finding a logical set of tests that will allow a circuit
engineer to gain a better understanding as to why
the circuit is malfunctioning. Fault localization is a
method typically used in classical circuits that we
adapted to quantum circuits. In the diagnostic
method of fault localization a test set is developed
that ideally will allow a circuit engineer to know
the location and type of fault present in a circuit.
For the diagnostic method of fault localization there
are typically two general methods used in classical
circuits: (1) single-fault-model [16], and (2) the
multiple-fault-model [16]. We address the single
fault model in this paper, leaving the multiple-faultmodel for latter discussion. The two most popular
approaches to Fault Localization are (1) Preset
Method and (2) Adaptive Tree Method [17]: In
literature, both methods start from a fault table
which has tests (input vectors) as rows and all
possible faults as columns.1 The goal of the preset
1
The quantum fault table has been extended
dimensionally adding the output value measured
from reading a circuit to the classical circuit.
3
2.1.
Selecting a Quantum Fault Model
work we selected all of the Pauli operators (for the
phase and rotation faults) and the Hadamard and
π/8-Gate (for faults resulting from superposition
and quantum effects).
I
n classical binary CMOS circuits a stuck-at fault
model has been used successfully for the last 50
years. However, one must be very careful while
adapting this model to a new technology. For
instance for many years a fault model that rarely
occurred in actual multi-valued CMOS circuits was
a standard fault model used by many researchers
until it was proven to actually occur more rarely
than other faults. Most researchers developed very
general methods, potentially applicable to arbitrary
technology, (as those presented here), so their work
was easily adapted. In classical binary CMOS
circuits, the following fault models are in wide use
today to test functionality and to perform diagnostic
methods [6, 7, 11]:



Stuck-at faults
Single stuck-at faults
Multiple stuck-at faults
With the gates from table 1 as our fault model we
noticed some very interesting results that have no
parallel in the classical theory of testability; we
present these classically unparalleled results of
testability:
LEMMA 1: Certain faults can always be present in
a circuit yet never detectable.
PROF FOR LEMMA 1: Let us consider the case
of a single Qubit, whose probability of being
measured in basis state|0> or basis state |1> is left
unchanged with a phase shift.
 Stuck Open
Faults
 Bridging Faults
 Delay Faults
The Lie group SO(3), the group of rotations in
three-dimensional space maps to U(2), the unitary
group that represents all single Qubits.
In
addition, the Pauli matrices are a realization (and,
in fact, the lowest-dimensional realization) of
infinitesimal rotations in three-dimensional space.
In constructing a quantum fault model one must
pay special attention to the historic lesson already
learned from classical testing, since quantum
computers are still in their beginning stages of
development. Although we can say with no
certainty what technological implementation of the
first commercial quantum computer the future
holds, we can say with certainty that this
implementation will impact the fault model used.
Although this is the first diagnostic method that
adapts similar established theories of testability to
quantum circuits, physicists have already in use
what could be considered a fault model. Ample
literature including [3, 4, 5] presents errorcorrecting codes, and these codes help the system
recover from errors of phase-shift and rotations,
and it is often mentioned [3, 4, 5, 1, 2] that Qubits
can become entangled with the environment
causing errors to occur[4, 5, 6, 2]. [18] Presents a
study on the occurrence of non-unitary faults. The
point here is to again mention that a need is already
present for diagnostic methods such as this, and to
give justification as to why we chose the fault
model used in this paper.
We believe the most
general fault model is inserting 2 x 2 matrices as
gates into quantum circuits. The removal of a
unitary quantum gate can be modeled as placing the
inverse gate next to the gate that is to be removed.
Clearly, for a given gate G, provided G is unitary,
the removal of G is simply the insertion of G†
directly after G such that, G†G=I. Formally for this
In quantum mechanics, the Pauli matrices
represent the generators of rotation acting on nonrelativistic particles with spin 1/2. The state of the
particles are represented as two-component
Spinors, which is the fundamental representation of
U(2) (the unitary group U(2), defines the current
state of a Qubit, according to the first postulate of
quantum mechanics[1,2]).
An interesting property of spin 1/2 particles is that
they must be rotated by an angle of 4π in order to
return to their original configuration. This is due to
the fact that SU(2) and SO(3) are not globally
isomorphic, even though their infinitesimal
generators su(2) and so(3) are isomorphic. SU(2) is
actually a "double cover" of SO(3), meaning that
each element of SO(3) actually corresponds to two
elements in SU(2).
Since SO(3) is the rotational group in R 3, and we
can map SO(3) to U(2), we are able to think of any
unitary gate as a rotation about the Bloch sphere.
In fact U(2) preserves all rotations from R3. From
the group SO(3) it is clear that rotations (around
ẑ for instance) do not change the distance between
the certain planes or certain basis, these are
unaffected by the rotation. If the measurement
basis is chosen to be Eigen states |0> and |1> in
4
U(2) than what we refer to as a phase shift is such
a rotation that does not change the distance from a
certain basis and therefore does not impact
measurement..
erroneous. When a pure basis is read its value will
depend on a certain probability of being the correct
state, or the incorrect state.
More formally we assume that out Qubit exists in
the state:
More formally we assume that out Qubit exists in
the state:
 
  0   1   
 
 
  0   1   
 
If we place our Qubit in a superposition by
applying the Hadamard transform, such that:
A simple example is clearer than the more general
case, however both proofs are straightforward. Let
us act on our Qubit with a phase shift (Pauli-Z):
 1 1 1     1    



   

 2 1  1    2    
1 0      
0  1       

   
If we measure from basis |0> and note that the
ideal circuit has   0 , in this case, we have1/2
as the probability of erroneous measure, if the fault
is indeed present. ◊
Since    , and      , we preserve
2
2
the fact that, 
2
2
  2  1 and leave the probability
amplitude unchanged. ◊
Gates Inserted As
faults:
Additional Gates used
often in quantum circuits:
LEMMA 2: Certain faults can always be present in
a circuit but only detectable a percentage of time
when measured.
Hadamard (H),
Pauli-X (X), PauliY (Y), and Pauli-Z
(Z)
Feynman (F), Controlled
square root of NOT(V) and
controlled square root of
NOT Hermitian gate(V+)
PROF FOR LEMMA 2: Let us state that the
occurrence of a fault is deterministic, detection or
measurement of the fault is probabilistic.
Table 1 – gates used for circuit construction and as
fault models
2
As example, suppose a Qubit enters an entangled
state or a state of superposition, where one of the
states is the correct state and the other is
2.2.
The existence of complete test sets
can say that we have determined that the fault exists
at X (we have localized X). However, even in this
simple case one can make no statements as to the
probability that a fault is present at location X in
the circuit prior to running a given test. It is only
running the test that allows us to make one of the
following statements: (1) the fault is definitely not
present at location X, or (2) the fault is definitely
present at location X (since the probability of
detection of a fault is 100%, if the fault is indeed
present).
T
he optimum test set will detect all possible
faults that can be present in the device with the
least number of test vectors; this is known as high
defect coverage for both classical and quantum
circuits [6]. In general when we perform a given
test, we are attempting to determine to a certain
degree of assurance whether or not a fault is
present. For example, let us assume that we have
defined a location in a theoretical quantum circuit
as location X.
Now if we perform the same calculations for a fault
at location X, and this time determine that the fault
we inserted only occurs with a given probability
denoted by P(x), prior to running any single test we
can make no statement related to the occurrence of
P(x). However, after running any number of tests
If we insert a fault at location X and perform a
calculation telling us that the fault we inserted
amounts to a bit flip when measured, then if we
measured an actual circuit and find the binary
output has been inverted (based on our model), we
5
we can say one of two things: (1) the fault is
definitely present at location X, or (2) we are able
to judge the probability of the assumption of the
occurrence of the fault at location X based on
passed experimental outcome. In other words, we
are only able to judge our assumption to a given
percentage, and this assumption never answers the
question of whether or not a fault is truly present in
the quantum circuit.
3. Generation of the Quantum Fault Table
In this section we describe the basic steps used in
our algorithm to generate the quantum fault table.
Quantum Fault table Construction begins with the
selection of a circuit that has either been proven or
suspected to not function correctly.
*Fault
diagnostics requires more time and tester memory,
and is generally much slower and unnecessary if
the simpler case of verification is all that is needed.
(We refer the reader to [17] for in-depth
information relating to testing quantum circuits
without diagnostics).
a certain basis. It now becomes clear as to what
input vector creates an outcome other than that
expected from ideal calculations made in the first
step. For example let us illustrate the principle just
outlined with a simple example. Table 2 below
illustrates a constructed fault table were a Pauli-X
fault was inserted at location XN, where N
corresponds to the location of the fault (locations 19 in circuit).
2
1
The first step to generate a quantum fault table is to
model the circuit in question and calculate the ideal
result stored in the circuits Qubit memory register
(state vector). This calculation is used to determine
the probability of measuring each individual state
for all possible input test vectors.
4
V
5
8
3
6
V+
7
9
V
Figure 1 – The locations that the fault is suspected to reside
From these calculations the Pauli-X fault table
directly follows: From the Pauli-X fault table it is
clear to see that the input test vector is located as a
column to the left, followed by the correct output of
the circuit. In the top row the faults are also named,
XN, where N is a number between 1 and 9 to signify
the location in the circuit we inserted the fault.
A decision must now be made defining all locations
that the fault is thought to reside. We illustrate this
by numbering locations in the circuit in Figure 1
(locations 1-9). After we number the locations of
possible faults, we are free to insert any given fault
model into any of the nine locations of the circuit.
For all of the locations in the circuit where a fault is
suspected to reside, the quantum circuits state
matrix is recalculated, and we store the possible
output as well as the probability of measurement in
Construct quantum fault table:
Select circuit to analyze
Calculate ideal output value for all possible inputs and store in fault table
Select all possible locations that the fault could reside
Select fault model
For all locations in the circuit
Insert fault model
Calculate new output value after fault was inserted
Record the measurement state probability in given cell
End
Algorithm to construct fault table
6
Input
X1
X2
X3
X4 , X5
|000>
Correct
Output
|000>
|100>
|100>
|001>
|001>
|101>
|101>
|010>
|010>
|111>
|011>
|011>
|110>
|100>
|100>
|000>
|111>50%
|110>50%
|110>50%
|111>50%
|000>
|101>
|101>
|001>
|001>
|110>
|111>
|010>
|111>
|110>
|011>
|010>50%
|011>50%
|011>50%
|010>50%
|100>50%
|101>50%
|101>50%
|100>50%
|111>50%
|110>50%
|110>50%
|111>50%
|000>50%
|001>50%
|001>50%
|000>50%
|010>50%
|011>50%
|011>50%
|010>50%
|010>50%
|011>50%
|011>50%
|010>50%
|000>50%
|001>50%
|001>50%
|000>50%
|110>50%
|111>50%
|111>50%
|110>50%
|101>50%
|100>50%
|100>50%
|101>50%
X6 ,
X7
|010>
X8 ,
X9
|001>
|011>
|000>
|000>
|011>
|001>
|010>
|110>
|101>
|111>
|100>
|101>
|110>
|100>
|111>
Table 2 – Pauli-X fault table
3.1.
0
0

0


0
X2  
1

0
0


0

0
0
0
0
0
0
1 0
0 1
0
0
0
0 0
0
0
0
0 0
0
1
0
0
0
0
0 0
0 0
1 j

2 2
1 j

2 2
0
0
1 j

2 2
1 j

2 2
1 j

2 2
1 j

2 2
0 0
0
0 0
0
0
0
0
0
0 
0 
1 j
 
2 2
1 j

2 2
0 

0 
0 

0 

Equation 1 –Pauli-X inserted at location 2 from
figure 1. Note: j is a complex number.
The Quantum Covering Problem
The general theory behind fault localization is that
if we know the expected output of a circuit, we
insert a fault at some location in the quantum circuit
and note the changes of outputs between this new
faulty circuit and the expected correct circuit. If we
then run a test on a real circuit and find the same
output as in the faulty case that we calculated, then
by our method we determined that the same fault as
we inserted into our theoretical circuit for
calculations is (or was) present in the actual circuit.
Let us examine the fault table from our last
example to further this point.
onto basis |010> we can ascertain a certain level of
percentage that X1 is present and not X2. For
example, if we input |010> 10 times and measure
|111> each time as output we know that if X 2 was
in fact present, the circuit would behave in this
manor 100 x (1/2)10 percent of the time (  0.1% ).
In the first stage of the algorithm we attempt to split
the tree to give it the most breadth using a greedy
algorithm. After the tree is split each node of the
tree can either be a terminal node, where no more
iterations can be applied to localize between further
faults, or otherwise. In the later case, a subsection
of the fault table is analyzed, and the test vector that
has the minimum overlap between all of the faults
still present in the node is selected. This is best
illustrated with the outline of our algorithm as
shown at the end of this section:
From the fault tables presented in section 3, it is
clear that many of the faults are detectable. Our
algorithm is a very simple greedy algorithm that
relies on our ability to perform some simple metrics
on the table. In table 3 we see the Pauli-X table
with some added metrics, all of which are explained
in the table.
The goal of our algorithm is simply to localize
between faults, however, in many cases there exists
several test vectors that are equivalent to each
other, such that we cannot localize between them.
(Let’s assume we are only using locations 1 and 2,
for possible fault locations from figure 1) We will
examine a particular case by pointing out X1 having
a different output than the correct output for all
possible input test vectors (|000> through |111>). If
we supply input |000> and get output |100> we
know that we have either fault X1, X2. To localize
between X1 and X2 we can supply an input of |010>
multiple times. If at any iteration of supplying
input |010> we read |110> as output we know that
X2 exists and not X1 (note we are using the single
fault model).
Create Tree:
{
examine metrics on each test
select test with highest number of unique entries
and lowest number of multiple entries
create nodes corresponding to each possible output
For all nodes:
NodeItterator( all nodes ):
if node is terminal node return
find optimum disjoint set corresponding to node
construct new nodes
for all each node constructed call NodeItterator
}
However, if we continue to measure |111> as
output when the state of the system is projected
Greedy Algorithm to solve quantum covering problem
7
Pauli-X
X1
Input
X2
X3
|000>
Correct
Output
|000>
|100>
|100>
|001>
|001>
|101>
|101>
|010>
|010>
|111>
|011>
|011>
|110>
|100>
|100>
|000>
|111>50%
|110>50%
|110>50%
|111>50%
|000>
|101>
|101>
|001>
|001>
|110>
|111>
|010>
|111>
|110>
|011>
|010>50%
|011>50%
|011>50%
|010>50%
X4 , X5
X6, X7
X8, X9
Unique
Entries:
Overlapping
Entries:
(Number – P)
(Number – cover  (P))
1–1
2 – 0.5
1–1
2 – 0.5
1–1
1 – 0.5
1–1
1 – 0.5
1–1
2 – 0.5
1–1
2 – 0.5
1–1
1 – 0.5
1–1
1 – 0.5
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
1 – 3  (1,0.5,0.5)
2 – 2  (0.5,0.5)(0.5,1)
1 – 3  (1,0.5,0.5)
2 – 2  (0.5,0.5)(0.5,1)
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
1 – 3  (1,0.5,0.5)
2 – 2  (0.5,0.5)(0.5,1)
1 – 3  (1,0.5,0.5)
2 – 2  (0.5,0.5)(0.5,1)
Unique
Correct
Output:
Y/N – (P)
|100>50%
|101>50%
|101>50%
|100>50%
|111>50%
|110>50%
|110>50%
|111>50%
|000>50%
|001>50%
|001>50%
|000>50%
|010>50%
|011>50%
|011>50%
|010>50%
|010>50%
|011>50%
|011>50%
|010>50%
|000>50%
|001>50%
|001>50%
|000>50%
|110>50%
|111>50%
|111>50%
|110>50%
|101>50%
|100>50%
|100>50%
|101>50%
|010>
|001>
|011>
|000>
|000>
|011>
|001>
|010>
|110>
|101>
|111>
|100>
|101>
|110>
|100>
|111>
Y
Y
Y
Y
Y
Y
Y
Y
Table 3 – Fault table for Pauli-Y fault inserted as depicted in Figure 1
Explanation of Table-3: The Unique entries column is given by the number of unique entries followed by
a dash and then the probability of detection for a given fault, if actually present. The overlapping entries
column is a metric relating the number of entries that are not correct and not unique (this means you can
not localize between them generally for a corresponding test vector). The number of over lap is followed
by a dash, then the number of entries that overlap is given, and following in brackets are the probabilities
for all given overlapping entries.
4. Localization of Faults
A solution to the covering problems leads its self
directly to the construction of trees, a graphical
simplification used to illustrate exactly the test to
run and the steps to take provided a given output,
and to localize between faults.
the edges are the output of the circuit, for a given
branching condition. For example, if we supply as
input to the circuit a test vector of |010>, and have
as output 011 we know that a Pauli-Z fault is
present at location 8 (from figure 1). However, if
we measure as output 010, we can have any number
of faults or a good circuit, and it is not until we run
another test (|100>) can we localize between all
detectable faults and that of a good circuit.
Explanation of Figure 2: Figure 2 is a tree created
from inserting the Pauli-Z fault as depicted in
Figure 1. From this tree it is clear that the input to
the circuit is inside the node, and the numbers on
Pauli-Z
Input
Correct
Output
|010>
011
010
Z8
|000>
|001>
|010>
|011>
|100>
|101>
|110>
|111>
|100>
else
Z(1-7)?
101
|000>
|001>
|010>
|011>
|100>
|101>
|111>
|110>
Z1-Z7
(Same as
correct output)
|000>
|001>
|010>
|011>
|100>
|101>
|111>
|110>
Z8
Z9
|000>
|001>
|011>
|010>
|100>
|101>
|110>
|111>
|000>
|001>
|010>
|011>
|101>
|100>
|110>
|111>
Table 4 – Fault table for Pauli-Z fault inserted
as depicted in figure 1
Z9
Figure 2 – (Tree to localize between Pauli-Z faults for
circuit in question)
8
4.1.
Fault Trees
The quantum-covering problem is different than in
the classical case as result of the introduction of
positive fractions inserted into the fault table. This
section presents trees generated from the algorithm
presented in section 3. The input of the circuit is
shown in the center of each node, as is the terminal
indication, where a fault can be localized no further.
The output branching condition is drawn on each
edge. All nodes with feed back edges correspond
to iterative testing, where one has to run a given test
any number of times before past outcome will
allow one to make a judgment as to whether or not
a fault is present, with a given probability of
assurance.
111
X1,X2,X3
|000>
|110>
001
100
111
|010>
000
001
X8,X9
010
010
H2
110
X2,X3
101
000
H1,H3
(X4,X5),(X6,X7)
011
|100>
|000>
111
010
010
|110>
101
011
(H4,H5),(H6,H7)
110
011
001
011
X3
100
X4,X5
|110>
111
101
H8,H9
H3
|101>
100
100
Pauli-X
(Tree to localize between Pauli-X faults)
101
H8
(Note, the edges that loop back illustrate iterative
testing where probabilities are involved in the
determination of a given fault)
H4,H5
Hadamard
(Tree to localize between Hadamard faults)
Hadamard
Input
H1
H2
H3
H4 , H5
H6 , H7
H8
H9
|000>50%
|100>50%
|000>50%
|110>25%
|111>25%
|001>50%
|110>25%
|111>25%
|010>50%
|100>25%
|101>25%
|011>50%
|100>25%
|101>25%
|100>50%
|010>25%
|011>25%
|101>50%
|010>25%
|011>25%
|111>50%
|000>25%
|001>25%
|110>50%
|000>25%
|001>25%
|000>50%
|100>25%
|101>25%
|001>50%
|100>25%
|101>25%
|010>50%
|111>25%
|110>25%
|011>50%
|110>25%
|111>25%
|100>50%
|000>25%
|001>25%
|101>50%
|001>25%
|000>25%
|111>50%
|010>25%
|011>25%
|110>50%
|011>25%
|010>25%
|000>50%
|010>25%
|011>25%
|001>50%
|010>25%
|011>25%
|010>50%
|000>25%
|001>25%
|011>50%
|001>25%
|000>25%
|100>50%
|110>25%
|111>25%
|101>50%
|111>25%
|110>25%
|111>50%
|101>25%
|100>25%
|110>50%
|100>25%
|101>25%
|000>50%
|010>50%
|000>50%
|001>50%
|000>50%
|001>50%
|001>50%
|011>50%
|001>50%
|000>50%
|001>50%
|000>50%
|010>50%
|000>50%
|011>
|010>50%
|011>50%
|011>50%
|001>50%
|010>
|011>50%
|010>50%
|100>50%
|110>50%
|100>50%
|101>50%
|101>
|101>50%
|111>50%
|101>50%
|100>50%
|100>
|111>50%
|101>50%
|110>
|110>
|110>50%
|100>50%
|111>
|111>
|000>
Correct
Output
|000>
|001>
|001>
|001>50%
|101>50%
|010>
|010>
|010>50%
|111>50%
|011>
|011>
|011>50%
|110>50%
|100>
|100>
|100>50%
|000>50%
|101>
|101>
|101>50%
|001>50%
|110>
|111>
|111>50%
|010>50%
|111>
|110>
|110>50%
|011>50%
Hadamard Fault Table
9
4.2.
Testing CAD Tool and Simulations – Q-Fault
The simulations in this work were done on
QuIDDpro [15]. The end result of this work is a
functional software package that verifies all results
contained in this paper, as a plug in to QuIDDpro.
However, the algorithm presented here can be
applied by hand and is completely ready to be used.
The author is willing to construct test trees for
circuits provided by our readers. The binary
executable as well as the source code will not be
made available, due to our license agreement with
the University of Michigan.
5. Conclusion
In this paper we presented a solution to the open
problem of quantum fault diagnostics. The authors
(Perkowski, Biamonte) founded this area of study
with their introductory work in [12]. This work was
a finalized continuation of [12], and marks the first
useful diagnostic method available for actual
quantum computers other than the exhaustive
approach.
We feel that the elegance of this method is its
simplicity and hope that the usefulness of what is
presented here will somehow stand apart from the
common approach of error correcting codes, that
are however less general then the presented
approach. This work is by no means the optimal
solution, since the covering problem is well known
to be NP. However, the algorithm presented has
good heuristics and solves the problem completely,
just not optimally.
In this work we defined the quantum fault model.
Fault models are always very technology
dependent, and our future work will result in the
development of a working software package to
perform the algorithm automatically, using
technology dependent fault models.
In closing, we would like to say that this is a very
deep area of study, and now that one solution exists
and the problem of fault diagnostics is no longer
what can be thought of as an open problem, we are
sure many solutions will soon be discovered.
6. Acknowledgements
A preliminary version of this paper was presented
at the INQ research conference, Portland Oregon,
May 2004, with John Buell as a coauthor.
This work was supported by Ronald E. McNair Post
baccalaureate Achievement Program of Portland
State University. The views and conclusions
contained herein are those of the authors and
should not be interpreted as necessarily
representing official policies of endorsements,
either expressed or implied, of the Ronald E.
McNair Post baccalaureate Achievement Program
of Portland State University, or Portland State
University. ◊
We would like to thank George Viamontes for
providing us QuIDDPro beta version 1.1.1, the
world’s fastest quantum simulation tool that he is
developing for his PhD thesis at the University of
Michigan [15].
10
Work Cited
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
M. Nielsen, I. Chuang, “Quantum Computing and Quantum Information”, Cambridge University
Press, 2000
C. Williams, S. Clearwater, “Explorations in Quantum Computing”, Springer Press, 1997
Ashikhmin, A., Barg, A., Knill, E., and Litsyn, S. Quantum error detection I: Statement of the
problem. IEEE Trans. Inf. Theory, to appear, 1999. arXiv, quant-ph/9906126.
Ashikhmin, A., Barg, A., Knill, E., and Litsyn, S. Quantum error detection II: Bounds. IEEE
Trans. Inf. Theory, to appear, 1999. arXiv, quant-ph/9906131.
Bennett, C. H., DiVincenzo, D. P., Smolin, J. A., and Wootters, W. K. Mixed state entanglement
and quantum error-correcting codes. Phys. Rev. A, 54:3824, 1996. arXiv, quant-ph/9604024.
C. Landrault, Translated by M. A. Perkowski, “Test and Design For Test”
http://www.ee.pdx.edu/~mperkows/CLASS_TEST_99/inx.html
S. Reddy, “Easily Testable Realizations for Logic Functions”. 1972,
T. Sasao, “Easily Testable Realizations for Generalized Reed-Muller Expressions”, 1997
E. McCluskey and Ch-W. Tseng, ``Stuck-Fault Tests vs. Actual Defects.''
R. Butler, B. Keller, S.Paliwal, R. Schooner, J.Swenton, ``Design and Implementation of a Parallel
Automatic Test Pattern Generation Algorithm with Low Test Vector Count ''.
A.M. Brosa and J. Figueras, ``Digital Signature Proposal for Mixed-Signal Circuits''.
S. Aligala, S. Ratakonda, K. Narayan, K. Nagarajan, M. Lukac, J. Biamonte and M. Perkowski,
Deterministic and Probabilistic Test Generation for Binary and Ternary Quantum Circuits,
Proceedings of ULSI 2004 symposium, Toronto, Canada, in May
K. Patel, J. Hayes, I. Markov, Fault Testing for Reversible Circuits, to appear in IEEE Trans. on
CAD, quant-ph/0404003
S. Kak, The Initialization Problem in Quantum Computing, Foundations of Physics, vol 29, pp.
267-279, 1999
G. Viamontes, I. Markov, J. Hayes, Improving Gate-Level Simulation of Quantum Circuits,
Quantum Information Processing, vol. 2(5), pp. 347-380, October 2003, quant-ph/0309060
K. Ramasamy, R. Tagare, E. Perkins and M. Perkowski, Fault localization in reversible circuits is
easier than for classical circuits, IWLS proceedings, 2003
Z. Kohavi, Switching and Finite Automata Theory, McGraw Hill, 1978
S. Bettelli, Quantitative model for the effective decoherence of a quantum computer with
imperfect unitary operations, Physical Review A 69,042310 (2004) (14 pages)
J. Biamonte, J. Allan, M. Lukac, M. Perkwoski, Principles of Quantum Fault Detection, to be
submitted to IEEE Transactions on Computing 2004
11
7. Appendix 1: Metrics
Input
Unique
Entries:
(Number –
P)
|000>
4 – 0.25
|001>
4 – 0.25
|010>
4 – 0.25
|011>
4 – 0.25
|100>
4 – 0.25
|101>
4 – 0.25
|110>
4 – 0.25
|111>
4 – 0.25
Hadamard
Overlapping
Entries:
1 – 8 (1,0.5 ,0.5,0.5,
0.5,0.5,0.5,0.5)
2 – 2 (0.5,0.25)(0.25,0.5)
(0.5,0.5)
1 – 8 (1,1,0.5,0.5,
0.5,0.5,0.5,0.5)
3 – 2 (0.5,0.25)(0.25,0.5)
(0.5,0.5)
1 – 7 (1, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5)
3 – 2 (0.5, 0.25)(0.25,0.5)
(1,0.5)
1 – 7 (1, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5)
3 – 2 (0.5, 0.25)(0.25,0.5)
(1,0.5)
1 – 7 (1, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5)
3 – 2 (0.5, 0.25)(0.25,0.5)
(1,0.5)
1 – 7 (1, 0.5, 0.5, 0.5, 0.5, 0.5,
0.5)
3 – 2 (0.5, 0.25)(0.25,0.5)
(1,0.5)
1 – 6 (1, 0.5, 0.5, 0.5, 0.5, 0.5)
3 – 2 (0.5, 0.25)(0.25,0.5)
(1,1)
1 – 6 (1, 0.5, 0.5, 0.5, 0.5, 0.5)
3 – 2 (0.5, 0.25)(0.25,0.5)
(1,1)
Unique
Correct
Output:
Unique
Entries:
(Number –
P)
Pauli-Y
Overlapping
Entries:
(Number – cover 
(P))
Unique
Correct
Output:
Y/N – (P)
Unique
Entries:
(Number –
P)
Pauli-X
Overlapping
Entries:
(Number – cover 
(P))
1 – 10
(1,1,1,1,1,1,1,1,1,1)
N–
(1,1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
3–2
(1,0.5)(0.5,1)(1,1)
Y
1–1
2 – 0.5
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
0
1 – 10
(1,1,1,1,1,1,1,1,1,1)
N–
(1,1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
3–2
(1,0.5)(0.5,1)(1,1)
Y
1–1
2 – 0.5
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
Y
N
1–1
1 – 9 (1,1,1,1,1,1,1,1,1)
N – (1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
3–2
(1,1)(1,0.5)(0.5,1)
N – (1,1)
1–1
1 – 0.5
1 – 3  (1,0.5,0.5)
2–2
(0.5,0.5)(0.5,1)
Y
N
1–1
1 – 9 (1,1,1,1,1,1,1,1,1)
N – (1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
3–2
(1,1)(1,0.5)(0.5,1)
N – (1,1)
1–1
1 – 0.5
1 – 3  (1,0.5,0.5)
2–2
(0.5,0.5)(0.5,1)
Y
N
1–1
1 – 9 (1,1,1,1,1,1,1,1,1)
N – (1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
3–2
(1,1)(1,0.5)(0.5,1)
N – (1,1)
1–1
2 – 0.5
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
Y
N
1–1
1 – 9 (1,1,1,1,1,1,1,1,1)
N – (1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
3–2
(1,1)(1,0.5)(0.5,1)
N – (1,1)
1–1
2 – 0.5
1 – 3  (1,1,0.5)
1 – 2  (0.5,1)
Y
N
0
1 – 10
(1,1,1,1,1,1,1,1,1,1)
N–
(1,1,1,1,1,1,1,1,1,1)
1–1
2 – 0.5
1 – 3 (1,1,1)
2 – 2 (1,0.5)(0.5,1)
N–
(1,1,1)
1–1
1 – 0.5
Y
N
0
1 – 8 (1,1,1,1,1,1,1,1)
1 – 2 (1,1)
N – (1,1,1,1,1,1,1,1)
1–1
2 – 0.5
1 – 3 (1,1,1)
2 – 2 (1,0.5)(0.5,1)
N–
(1,1,1)
1–1
1 – 0.5
1 – 3  (1,0.5,0.5)
2–2
(0.5,0.5)(0.5,1)
1 – 3  (1,0.5,0.5)
2–2
(0.5,0.5)(0.5,1)
Unique
Correct
Output:
Unique
Entries:
N–
(1,1,0.5,0.5,
0.5,0.5,0.5,0.5)
0
N
Pauli-Z
Overlapping
Entries:
The above table shows the metrics calculated on each of the faults inserted into the circuit
(Locations 1-9, Figure 1, Faults: Pauli-X, Pauli-Y, Pauli-Z, Hadamard)
12
Unique
Correct
Output:
Y/N –
(P)
Y
Y