USRE41900E1 - Compiler for a quantum computer - Google Patents
Compiler for a quantum computer Download PDFInfo
- Publication number
- USRE41900E1 USRE41900E1 US10/947,489 US94748904A USRE41900E US RE41900 E1 USRE41900 E1 US RE41900E1 US 94748904 A US94748904 A US 94748904A US RE41900 E USRE41900 E US RE41900E
- Authority
- US
- United States
- Prior art keywords
- operations
- sequence
- matrices
- node
- matrix
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Lifetime
Links
Images
Classifications
-
- B—PERFORMING OPERATIONS; TRANSPORTING
- B82—NANOTECHNOLOGY
- B82Y—SPECIFIC USES OR APPLICATIONS OF NANOSTRUCTURES; MEASUREMENT OR ANALYSIS OF NANOSTRUCTURES; MANUFACTURE OR TREATMENT OF NANOSTRUCTURES
- B82Y10/00—Nanotechnology for information processing, storage or transmission, e.g. quantum computing or single electron logic
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N7/00—Computing arrangements based on specific mathematical models
- G06N7/01—Probabilistic graphical models, e.g. probabilistic networks
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N10/00—Quantum computing, i.e. information processing based on quantum-mechanical phenomena
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N10/00—Quantum computing, i.e. information processing based on quantum-mechanical phenomena
- G06N10/20—Models of quantum computing, e.g. quantum circuits or universal quantum computers
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S977/00—Nanotechnology
- Y10S977/902—Specified use of nanostructure
- Y10S977/932—Specified use of nanostructure for electronic or optoelectronic application
- Y10S977/933—Spintronics or quantum computing
Definitions
- the present application includes a microfiche appendix comprising the C++ source code of a fully functional computer program called Qubiter1.0.
- Qubiter1.0 is a possible embodiment of the software of the present invention.
- the microfiche appendix comprises 1 microfiche with a total of 52 frames.
- the first frame is a test pattern for focusing.
- the second frame, called Appendix A is a list of files contained in a CodeWarriorTM project for Qubiter1.0.
- Subsequent frames are labelled Appendix B, and comprise source code contained within said files.
- the invention relates to an array of quantum bits known as a quantum computer. More specifically, it relates to the generation of the instruction sequences that are used to manipulate such an array.
- a quantum computer is an array of quantum bits (qubits) together with some hardware for manipulating these qubits. Quantum computers with only a few bits have already been built.
- Quantum computers with only a few bits have already been built.
- DiV95 D. P. DiVincenzo, Science 270, 255 (1995).
- QB Nets are a method of modeling quantum systems graphically in terms of network diagrams.
- Tuc95 R. R. Tucci, Int. Jour. of Mod. Physics B9, 295 (1995).
- Tuc98 U.S. Pat. No. 5,787,236.
- This invention comprises a classical computer running a computer program that expresses the information contained in a QB net as a SEO. One can then run these SEOs on a quantum computer.
- QB nets can and have been run entirely on a classical computer. (See the software program called “Quantum Fog”, produced by the Artiste company (www.ar-tiste.com)).
- Quantum Fog produced by the Artiste company (www.ar-tiste.com)
- CB nets are to quantum physics what Classical Bayesian (CB) nets are to classical physics.
- CB nets see Nea9O: Richard E. Neapolitan, Probabilistic Reasoning in Expert Systems: Theory and Algorithms (Wiley, 1990). See also Pea88: Judea Pearl, Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference (Morgan Kaufmann, Palo Alto, 1988).
- CB nets have been used very successfully in the field of artificial intelligence (AI).
- AI artificial intelligence
- the main goal of the invention is to provide a new method for generating the SEOs that are used to manipulate a quantum computer. This goal is achieved by means of a classical computer running a computer program that takes as input a QB net, and returns as output the desired SEO.
- a related goal of the invention is for said computer program to serve as a blueprint that future workers can modify and enlarge.
- a related goal is to allow users to run QB nets on a quantum instead of a classical computer.
- the QB nets could be used, for example, to do AI tasks such as decision making.
- a quantum computer is an array of quantum bits (qubits) together with some method for manipulating these qubits.
- Quantum Bayesian (QB) nets are a method of modeling quantum systems graphically in terms of network diagrams.
- This invention comprises a classical computer that runs a computer program.
- the program takes a QB net and decomposes it into a sequence of elementary operations (SEO). Such a sequence can be used to manipulate a quantum computer.
- SEO elementary operations
- step (1) we partition the set of nodes of the QB net into subsets called eras. All nodes in a given era “occur at roughly the same time”. We also assign a matrix to each era.
- step (2) we pad the era matrices of step (1) with delta functions so that the resultant era matrices can be multiplied by each other.
- step (3) we extend the era matrices of step (2) (by adding rows and columns) so that the resultant era matrices are all unitary and of the same size.
- step (4) we reduce into a SEO each of the unitary era matrices of step (3).
- Step (4) is based on the CS Decomposition Theorem. This theorem asserts that: given a unitary matrix U, if we partition it into 4 blocks U 0 , U 1 , U 2 , U 3 of the same size, then one can express each U k , where k ⁇ 0, 1, 2, 3 ⁇ , as a product L k D k R k , such that L k and R k are unitary matrices and D k is diagonal. Since the matrices L k and R k are unitary, one can apply the CS Decomposition Theorem to them next.
- Qubiter1.0 An appendix to this document contains the C++ source code of a computer program called “Qubiter1.0”.
- Qubiter can decompose into a SEO only the simplest non-trivial kind of QB net: a single unitary matrix, or, equivalently, 2 connected nodes.
- Future versions of Qubiter are planned that will take an arbitrary QB net as input, and return as output a SEO for running a quantum computer.
- FIG. 1 shows a labelled graph and the four node matrices associated with the four nodes of the graph.
- a QB net consists of 2 parts: a labelled graph and a collection of node matrices, one matrix for each node.
- FIG. 2 shows a QB Net for Teleportation. This figure also shows the number of quantum or classical bits carried by each arrow.
- FIG. 3 shows the root node eras for the Teleportation net.
- FIG. 4 shows the external node eras for the Teleportation net.
- FIG. 5 shows an example of a QB net in which an external node is not in the final era.
- FIG. 6 shows a binary tree.
- Each node ⁇ has a single parent. If the parent is to ⁇ 's right (ditto, left), then ⁇ contains the names of the matrices produced by applying the CS Decomposition Theorem to the L matrices (ditto, R matrices) of ⁇ 's parent.
- FIG. 8 shows a file listing the entries of a unitary matrix. Such files are called “mat.in”, where the string “mat” is a variable specified by the user.
- FIG. 9 shows a file listing a SEO. Such files are called “mat-cmnd.out”, where the string “mat” is a variable specified by the user.
- the SEO in this figure is a decomposition of the matrix specified by FIG. 8 .
- FIG. 10 shows another file listing a SEO.
- This SEO can be obtained from that in FIG. 9 by deleting from the latter those factors arising from rotations by a zero angle.
- FIG. 11 shows the first file that Qubiter looks for. It's called “qbtr-params.in”, and it determines the name of other input files that Qubiter may look for. It also determines the mode of operation of Qubiter.
- a QB net consists of two parts: a labelled graph with each node labelled by a random variable, and a collection of node matrices, one matrix for each node. These two parts must satisfy certain constraints.
- An internal arrow is an arrow that has a starting (source) node and a different ending (destination) one.
- Z ext be the set of all j ⁇ Z 1,N such that ⁇ circumflex over (x) ⁇ j is an external node
- Z int be the set of all j ⁇ Z 1,N such that ⁇ circumflex over (x) ⁇ j is an internal node.
- Z ext and Z int are disjoint and their union is Z 1,N .
- Each possible value x. of ⁇ circumflex over (x) ⁇ . defines a different net story.
- For any net story x. we call (x.) z int the internal state of the story and (x.) z ext its external state.
- each node For each net story, we may assign an amplitude to each node.
- S j to be the set of all k such that an arrow labelled x k (i.e., an arrow whose source node is ⁇ circumflex over (x) ⁇ k ) enters node ⁇ circumflex over (x) ⁇ j .
- x k i.e., an arrow whose source node is ⁇ circumflex over (x) ⁇ k
- (x.) S j ] the amplitude of node ⁇ circumflex over (x) ⁇ j within net story x..
- A(x.) The amplitude of net story x, call it A(x.), is defined to be the product of all the node amplitudes A j [x j
- a ⁇ ( x . ) ⁇ j ⁇ Z 1 , N ⁇ ⁇ A j ⁇ [ x j ⁇ ( x . ) ⁇ s j ] . ( 1 )
- (x.) S j ] determines a matrix that we will call the node matrix of node ⁇ circumflex over (x) ⁇ j , and denote by Q j .
- x j is the matrix's row index
- (x.) S j is its column index.
- FIG. 1 gives the four node matrices Q 1 , Q 2 , Q 3 , Q 4 associated with the four nodes of the graph shown there.
- Step 1 Find Eras
- the root node eras of a graph are defined as follows. Call the original graph Graph(1).
- the first era T 1 is defined as the set of all root nodes of Graph(1).
- Graph(2) the graph obtained by erasing from Graph(1) all the T 1 nodes and any arrows connected to these nodes.
- T 2 is defined as the set of all root nodes of Graph(2).
- FIG. 3 shows the root node eras of the Teleportation net FIG. 2 .
- FIG. 4 shows the external node eras of the Teleportation net FIG. 2 .
- B 1 (x 1 ) A 1 (x 2 ), (11a) B 2 (x 2 ,x 3
- x 1 ) A 3 (x 3
- x 3 ) A 4 (x 4
- x 4 ) A 5 (x 5
- This technique of inserting delta functions can be generalized as follows to deal with arbitrary QB nets. For j ⁇ Z 1,N , let a min (j) be the smallest a ⁇ Z 1,
- such that x j appears in B a . Hence, a min (j) is the first era in which x j appears. If ⁇ circumflex over (x) ⁇ j is an internal node, let a max (j) be the largest a such that x j appears in B a (i.e., the last era in which x j appears). If ⁇ circumflex over (x) ⁇ j is an external node, let a max (j)
- M a so that the x,y entry of M a is B a (x
- M to be a column vector whose components are the values of FI for each external state.
- the flagged columns of M a 0 can be changed without affecting the value of M. If the non-flagged columns of M a 0 are orthonormal, and the number of columns in M a 0 does not exceed the number of rows, then the Gram Schmidt method, to be discussed later, can be used to replace the flagged columns by new columns such that all the columns of the new matrix M a 0 are orthonormal. If it is not possible to repair M a 0 in any of the above ways (or in some other way that might become clear once we program this), one can always remove the breakpoint between M a 0 +1 and M a 0 .
- d a the number of rows of matrix M a and d a ⁇ 1 its number of columns.
- N S min ⁇ 2 i
- d a N S ⁇ d a for all a. For each a ⁇ 1.
- U a to be the matrix that one obtains by extending M a as follows. We append an d a ⁇ d a ⁇ 1 block of zeros beneath M a and an N S ⁇ d a ⁇ 1 block of gray entries to the right of M a .
- gray entries we mean entries whose value is yet to be specified.
- M 1 be can extended in two ways.
- e 1 we mean the N S dimensional column vector whose first entry equals one and all others equal zero. Which extension of M 1 is used, whether the one that requires e 1 or the one that doesn't, should be left as a choice of the user.
- G.S. Gram-Schmidt
- e j for j ⁇ Z 1,N S be the j'th standard unit vector (i.e., the vector whose j'th entry is one and all other entries are zero).
- G.S. method on the set S consisting of the non-gray columns of U a together with the vectors e 1 , e 2 , . . . e N s .
- Step 4 Decompose Each Unitary Matrix into a SEO
- Bool ⁇ 0,1 ⁇ .
- ⁇ right arrow over (u) ⁇ ( ⁇ ) i.e, the vector with bit value of 1 at bit position ⁇ and bit value of zero at all other bit positions.
- I r will represent the r dimensional unit matrix.
- M is any 2 ⁇ 2 matrix.
- the numbers that label bit positions in the tensor product increase from right to left ( ⁇ ), and the rightmost bit is taken to be at position 0.
- 0> 0,n
- 1>
- U is an N ⁇ N unitary matrix, where N is an even number.
- a central matrix either (1) a single D matrix, or (2) a direct sum D 1 (+)D 2 (+) . . . (+)D r of D matrices, or (3) a diagonal unitary matrix. From FIG. 6 it is clear that the initial matrix U can be expressed as a product of central matrices, with each node of the tree providing one of the central matrices in the product. Next, we show how to decompose each of the 3 possible kinds of central matrices into a SEO.
- ⁇ right arrow over ( ⁇ ) ⁇ (ditto, ⁇ right arrow over ( ⁇ ) ⁇ ) is a column vector whose components are the numbers ⁇ ⁇ right arrow over (a) ⁇ (ditto, ⁇ ⁇ right arrow over (a) ⁇ ) arranged in order of increasing ⁇ right arrow over (a) ⁇ .
- We define new angles ⁇ right arrow over ( ⁇ ) ⁇ in terms of the angles ⁇ right arrow over ( ⁇ ) ⁇ by ⁇ ⁇ 1 4 ⁇ H 2 ⁇ ⁇ ⁇ .
- a ⁇ right arrow over (b) ⁇ [ ⁇ x (N B ⁇ 1) n( ⁇ r ⁇ 1) . . .
- ⁇ ⁇ one ⁇ ⁇ can ⁇ ⁇ show ⁇ ⁇ that ( 54 )
- C ⁇ b ⁇ ⁇ Bool N B ⁇ ⁇ A b ⁇ , ( 55 ) where the A ⁇ right arrow over (b) ⁇ operators commute and will be defined next.
- a preferred embodiment of the invention is a classical computer that feeds data (a SEO) to a quantum computer.
- a classical computer we mean a device that makes a desired calculation using digital circuits which implement deterministic (classical, non-quantum) logic.
- a quantum computer we mean a device that makes a desired calculation using an array of quantum bits (qubits).
- classical and quantum computers may comprise input, output and memory devices. The important difference is that an array of quantum bits may be put in an entangled quantum state, whereas a digital deterministic logic circuit cannot be put in such a state (in practice, for useful periods of time).
- the classical computer of our preferred embodiment is a Mac computer, produced by Apple Computer Inc. of Cupertino, California.
- FIG. 7 is a block diagram of a classical computer feeding data to a quantum computer.
- 70 represents a classical computer. It comprises 71 , 72 , 73 .
- 71 represents input devices, such as a mouse or a keyboard.
- 72 represents the CPU, internal and external memory units.
- 72 does calculations and stores information.
- 73 represents output devices, such as a printer or a display screen.
- An image of a QB net (for example, FIG. 2 ) can be rendered on the display screen.
- 75 represents a quantum computer, comprising an array of quantum bits and some hardware for manipulating the state of those bits.
- Code WarriorTM is a C++ Integrated Development Environment produced by MetroWerks Inc. of Austin, Texas.
- C++ source code for a computer program called “Qubiter1.0” is included as a Microfiche Appendix to this document.
- the Microfiche Appendix has two parts: Appendix A and Appendix B.
- Appendix A is a listing of the names of all the files in the “CodeWarrior Project” for Qubiter.
- Appendix B is a listing of Qubiter source code. Apart from libraries provided with CodeWarrior, Qubiter requires parts of the C library called Clapack. This library is freeware and can be downloaded via the Internet from the website “www.netlib.org”.
- Qubiter uses files that list the entries of a unitary matrix U.
- FIG. 8 shows an example of such files. Qubiter ignores the lines labelled 81 and 83 .
- the line labelled 82 tells how many bits are necessary to label U's columns (or rows, since U must be square). In the example of FIG. 8 , according to 82 , two bits are necessary to label U's column, so one expects U to be a 4 ⁇ 4 matrix with 16 elements.
- 84 labels all the lines after the line labelled 83 .
- Each line in 84 represents a complex number z, the real part of z is listed first, then some white space to the right of it, and then the imaginary part of z to the right of that.
- 84 contains the entries of U, arranged so that the entries in the first column of U are listed first, then those of the second column of U, etc.
- Qubiter also uses files that list SEOs.
- FIG. 9 is an example of such a file.
- the line labelled 91 tells how many bits the gates listed in the file are to operate on, (i.e., what we called N B in Section (A)).
- 92 labels all the other lines in the file.
- Each line in 92 represents a gate.
- the matrix given in FIG. 8 can be decomposed into the SEO given in FIG. 9 . Such decompositions are not unique. After doing the trivial optimization of removing all factors A ⁇ right arrow over (b) ⁇ for which the rotation angle is zero, the 33 operations in FIG. 9 reduce to 25 operations in FIG. 10 .
- Qubiter starts by looking for a parameter file entitled “qbtr-params.in”.
- FIG. 11 is an example of such a file. Lines labelled 111 , 113 , 115 and 117 are ignored by the program. Lines labelled 112 , 114 , 116 , 118 are not.
- Qubiter will look for a file named “DiscFourier2bits.in”. In other words, it will look for a file whose name is the string in line 112 plus the suffix “.in”. Qubiter expects to find in this file the entries of the unitary matrix U initial to be decomposed.
- the file should be of the form exemplified by FIG. 8 .
- Qubiter will look for a file named “DiscFourier2bits-cmnd.out”. In other words, it will look for a file whose name is the string in line 112 plus the suffix “-cmnd.out”. Qubiter expects to find in this file a SEO.
- the file should be of the form exemplified by FIGS. 9 and 10 .
- Qubiter will produce a file of the type exemplified by FIG. 10 instead of the type exemplified by FIG. 9 . Thus, it will omit those gates arising from a rotation by a zero angle.
- Qubiter has 2 main modes of operation.
- the first mode of operation is when the user enters “yes” in line 114 as an answer to “Do compilation?”, and “yes” in line 116 as an answer to “Do decompilation?”
- the user must provide 2 input files entitled “qbtr-params.in” and “mat.in”, where “mat” is the string in line 112 .
- Qubiter will output a file called “mat-cmnd.out”.
- mat-cmnd.out as input, multiply the SEO listed in this file, arrive at a unitary matrix U final , and output a file called “mat-check.out” which lists the entries of U final . If everything goes well, the matrix U initial specified by file “mat.in” and the matrix U final specified by file “mat-check.out” will be the same matrix, within machine precision.
- the second mode of operation is when the user enters “no” in line 114 as an answer to “Do compilation?”, and “yes” in line 116 as an answer to “Do decompilation?”
- the user must provide 2 input files entitled “qbtr-params.in” and “mat-cmnd.out”. Qubiter will multiply the SEO listed in “mat-cmnd.out”, arrive at a unitary matrix U final , and output a file called “mat-check.out” which lists the entries of U final .
- Qubiter outputs the file “mat-cmnd.out”, it also outputs a file called “mat-pict.out” which is a translation of “mat-cmnd.out” to a pictorial language.
- Mat-pict.out is a translation of “mat-cmnd.out” to a pictorial language.
- Each elementary gate is represented by a line in “mat-pict.out”.
- a bit that is rotated about the Z axis is represented by a “Z” character (ditto, “Y” character). If the gate is a c-not that flips a bit when the control bit is true (ditto, false), then the control bit is represented by a “@” character (ditto, “0” character). The bit to be flipped is represented by an “X” character. If the gate is a pure phase acting on all bits, all bits are represented by the ⁇ character.
- the CS Decomposition is intimately related to the Generalized Singular Value Decomposition (GSVD).
- GSVD Generalized Singular Value Decomposition
- Qubiter1.0 does CS decompositions by means of a Clapack subroutine for doing GSVD.
- Pai94 and references therein. See also the Clapack documentation that comes with the subroutine zggsvd.c
- the basic set of elementary operators is not unique. For example, instead of using AND, NOT and OR gates, one can just use NAND gates. The same is true in quantum computation: the basic set of elementary operators is not unique. In this preferred embodiment of the invention, we use the set ⁇ CONTROLLED-NOT, QUBIT ROTATION ⁇ of elementary operators, but the invention also applies to other sets of elementary operators.
Landscapes
- Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- Theoretical Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Mathematical Physics (AREA)
- Mathematical Optimization (AREA)
- Chemical & Material Sciences (AREA)
- Evolutionary Computation (AREA)
- Computational Mathematics (AREA)
- Mathematical Analysis (AREA)
- Artificial Intelligence (AREA)
- Pure & Applied Mathematics (AREA)
- Computing Systems (AREA)
- General Engineering & Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Software Systems (AREA)
- Nanotechnology (AREA)
- Algebra (AREA)
- Crystallography & Structural Chemistry (AREA)
- Probability & Statistics with Applications (AREA)
- Condensed Matter Physics & Semiconductors (AREA)
- Multi Processors (AREA)
- Complex Calculations (AREA)
Abstract
A quantum computer is an array of quantum bits (qubits) together with some hardware for manipulating these qubits. Quantum Bayesian (QB) nets are a method of modeling quantum systems graphically in terms of network diagrams. This invention comprises a classical computer running a computer program that expresses the information contained in a QB net as a sequence of elementary operations (SEO). One can then run these sequences on a quantum computer. We show how to reduce a QB net into a SEO by a two step process. First, express the information contained in the QB net as a sequence of unitary operators. Second, express each of those unitary operators as a SEO. An appendix to this document contains the C++ source code of a computer program called “Qubiter1.0”, which is a preferred embodiment of the invention.
Description
The present application includes a microfiche appendix comprising the C++ source code of a fully functional computer program called Qubiter1.0. Qubiter1.0 is a possible embodiment of the software of the present invention. The microfiche appendix comprises 1 microfiche with a total of 52 frames. The first frame is a test pattern for focusing. The second frame, called Appendix A, is a list of files contained in a CodeWarrior™ project for Qubiter1.0. Subsequent frames are labelled Appendix B, and comprise source code contained within said files.
The invention relates to an array of quantum bits known as a quantum computer. More specifically, it relates to the generation of the instruction sequences that are used to manipulate such an array.
This invention deals with quantum computers. A quantum computer is an array of quantum bits (qubits) together with some hardware for manipulating these qubits. Quantum computers with only a few bits have already been built. For a review of quantum computers, see DiV95: D. P. DiVincenzo, Science 270, 255 (1995). See also Ste97:A. M. Steane, Los Alamos eprint https://xxx.lanl.gov/abs/quant-ph/9708022 www.arxiv.org/abs/quant-ph/9708022.
This invention also deals with Quantum Bayesian (QB) nets. QB Nets are a method of modeling quantum systems graphically in terms of network diagrams. For more information, see Tuc95: R. R. Tucci, Int. Jour. of Mod. Physics B9, 295 (1995). See also Tuc98: U.S. Pat. No. 5,787,236.
In classical computation and digital electronics, one deals with sequences of elementary instructions (instructions such as AND, NOT and OR). These sequences are used to manipulate an array of classical bits. The instructions are elementary in the sense that they act on only a few bits (usually 1, 2 or 3) at a time. Henceforth, we will sometimes refer to sequences as products and to instructions as operations, operators, steps or gates. Furthermore, we will abbreviate the phrase “sequence of elementary operations” by “SEO”. In quantum computation, one also deals with SEOs, but for manipulating qubits instead of classical bits.
This invention comprises a classical computer running a computer program that expresses the information contained in a QB net as a SEO. One can then run these SEOs on a quantum computer. Of course, QB nets can and have been run entirely on a classical computer. (See the software program called “Quantum Fog”, produced by the Artiste company (www.ar-tiste.com)). However, because of the higher speeds promised by quantum parallelism, one expects QB nets to run much faster on a quantum computer.
With classical computers, one usually writes a computer program in a high level language (like Fortran, C or C++). A compiler then expresses this as a SEO for manipulating bits. In the case of quantum computers, a QB net may be thought of as a program in a high level language. This invention is like a “quantum compiler” in the sense that it can take a QB net input, and re-express it as a SEO that can then be used to manipulate qubits.
This invention shows how to reduce a QB net into a SEO by a two step process. First, express the information contained in the QB net as a sequence of unitary operators. Second, express each of those unitary operators as a SEO. An appendix to this document contains the C++ source code of a computer program called “Qubiter.1.0”. In its current version (1.0), Qubiter can decompose into a SEO only the simplest non-trivial kind of QB net: a single unitary matrix, or, equivalently, 2 connected nodes. Future versions of Qubiter are planned that will take an arbitrary QB net as input, and return as output a SEO for running a quantum computer.
QB nets are to quantum physics what Classical Bayesian (CB) nets are to classical physics. For a review of CB nets, see Nea9O: Richard E. Neapolitan, Probabilistic Reasoning in Expert Systems: Theory and Algorithms (Wiley, 1990). See also Pea88: Judea Pearl, Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Inference (Morgan Kaufmann, Palo Alto, 1988). CB nets have been used very successfully in the field of artificial intelligence (AI). Thus, we hope and expect that some day QB nets, running on quantum computers, will be used for AI applications. In fact, we believe that quantum computers are ideally suited for such applications. First, because AI tasks often require tremendous power, and quantum computers seem to promise this. Second, because quantum computers are plagued by quantum noise, which makes their coherence times short. There are palliatives to this, such as quantum error correction (See the review Ste97). But such palliatives come at a price: a large increase in the number of steps. The current literature often mentions factoring a large number into primes as a future use of quantum computers (See the review Ste97). However, due to noise, quantum computers may ultimately prove to be impractical for doing long precise calculations such as this. On the other hand, short coherence times appear to be a less serious problem for the types of calculations involved in AI. The human brain has coherence times too short to factor a 100 digit number into primes, and yet long enough to conceive the frescoes in the Sistine Chapel. We do not mean to imply that the human brain is a quantum computer. An airplane is not a bird, but it makes a good flyer. Perhaps a quantum computer, although not a human brain, can make a good thinker.
To our knowledge, nobody else has invented a method of reducing an arbitrary QB net to a SEO for running a quantum computer. It's true that previous workers (See Bar95: A. Barrenco, C. H. Bennett, R. Cleve, D. P. DiVincenzo, N. Margolus, P. Shor, T. Sleator, J. H. Smolin, H. Weinfurter, Physical Review A 52, 3457 (1995)) have described a method for reducing a single unitary operator into a SEO. But our method for doing this is significantly different from theirs. Their method is based on a mathematical technique described in Rec94: M. Reck and A. Zeilinger, Physical Review Letters 73, 58 (1994). Our method is based on a mathematical technique called the CS Decomposition, to be described later. For a review of the CS decomposition, see Pai94: C. C. Paige, M. Wei, Linear Algebra And Its Applications 208, 303 (1994). Our CS method for reducing unitary matrices has inherent binary symmetries that make it easy to apply to qubit systems, which also possess binary symmetries. The method of Bar95 possesses no such symmetries. For this reason, we believe our method to be superior to theirs.
The main goal of the invention is to provide a new method for generating the SEOs that are used to manipulate a quantum computer. This goal is achieved by means of a classical computer running a computer program that takes as input a QB net, and returns as output the desired SEO.
A related goal of the invention is for said computer program to serve as a blueprint that future workers can modify and enlarge.
A related goal is to allow users to run QB nets on a quantum instead of a classical computer. The QB nets could be used, for example, to do AI tasks such as decision making.
A quantum computer is an array of quantum bits (qubits) together with some method for manipulating these qubits. Quantum Bayesian (QB) nets are a method of modeling quantum systems graphically in terms of network diagrams.
This invention comprises a classical computer that runs a computer program. The program takes a QB net and decomposes it into a sequence of elementary operations (SEO). Such a sequence can be used to manipulate a quantum computer.
This invention shows how to reduce a QB net into a SEO by performing four steps: (1) Find eras. (2) Insert delta functions. (3) Find unitary extensions of era matrices. (4) Decompose each unitary matrix into a SEO.
In step (1), we partition the set of nodes of the QB net into subsets called eras. All nodes in a given era “occur at roughly the same time”. We also assign a matrix to each era.
In step (2), we pad the era matrices of step (1) with delta functions so that the resultant era matrices can be multiplied by each other.
In step (3), we extend the era matrices of step (2) (by adding rows and columns) so that the resultant era matrices are all unitary and of the same size.
In step (4), we reduce into a SEO each of the unitary era matrices of step (3). Step (4) is based on the CS Decomposition Theorem. This theorem asserts that: given a unitary matrix U, if we partition it into 4 blocks U0, U1, U2, U3 of the same size, then one can express each Uk, where kε{0, 1, 2, 3□, as a product LkDkRk, such that Lk and Rk are unitary matrices and Dk is diagonal. Since the matrices Lk and Rk are unitary, one can apply the CS Decomposition Theorem to them next. One can continue to apply the CS Decomposition Theorem to the unitary matrices generated in previous steps. In this way, one can express the original matrix U as a product of matrices of a type that we call “central matrices”. We show how to express any central matrix as a SEO.
An appendix to this document contains the C++ source code of a computer program called “Qubiter1.0”. In its current version (1.0), Qubiter can decompose into a SEO only the simplest non-trivial kind of QB net: a single unitary matrix, or, equivalently, 2 connected nodes. Future versions of Qubiter are planned that will take an arbitrary QB net as input, and return as output a SEO for running a quantum computer.
(A)NEW METHOD
We begin by presenting a brief review of QB nets. For more information, see Tuc95, Tuc98.
In what follows, we use the following notation. We define Za,b={a,a+1a +2 . . . , b} for any integers a and b, δ(x,y) equals one if x=y and zero otherwise. For any finite set S, |S| denotes the number of elements in S.
We call a graph (or a diagram ) a collection of nodes with arrows connecting some pairs of these nodes. The arrows of the graph must satisfy certain constraints. We call a labelled graph a graph whose nodes are labelled. A QB net consists of two parts: a labelled graph with each node labelled by a random variable, and a collection of node matrices, one matrix for each node. These two parts must satisfy certain constraints.
An internal arrow is an arrow that has a starting (source) node and a different ending (destination) one. We will use only internal arrows. We define two types of nodes: an internal node is a node that has one or more internal arrows leaving it, and an external node is a node that has no internal arrows leaving it. It is also common to use the terms root node or prior probability node for a node which has no incoming arrows (if any arrows touch it, they are outgoing ones).
We restrict our attention to acyclic graphs: that is, graphs that do not contain cycles. (A cycle is a closed path of arrows with the arrows all pointing in the same sense.)
We assign a random variable to each node of the QB net. (Henceforth, we will underline or put a caret over random variables. For example, we might write P({circumflex over (x)}=x) for the probability that the random variable {circumflex over (x)} assumes the particular value x.) Suppose the random variables assigned to the N nodes are {circumflex over (x)}1, {circumflex over (x)}2, . . . , {circumflex over (x)}N. For each jεZ1,N, the random variable {circumflex over (x)}j will be assumed to take on values within a finite set Σj called the set of possible states of {circumflex over (x)}j.
For example, consider the net of FIG. 1. Nodes 11, 12 and 13 are internal and node 14 is external. Node 11 is a root node. There are four nodes so N=4. We will assume that the four nodes must lie in one of two states: either no or si. Thus, Σ1=Σ2=Σ3=Σ4={no,si}.
If S={k1, k2, . . . ,k|S|}⊂Z1,N, and k1<k2<. . . <k|S|, define (x.)S=(xk 1 , xk 2 , . . . , xk |S| ) and ({circumflex over (x)}.)S=(xk 1 , {circumflex over (x)}k 2 , . . . , {circumflex over (x)}k |S| ). Sometimes, we also abbreviate (x.)Z 1,N (i.e., the vector that includes all the possible xj components) by just x., and ({circumflex over (x)}.)Z 1,N by just {circumflex over (x)}..
For example, suppose N=4. One has Z1,4={1,2,3,4}. If S={1,3}, then |S|=2. Furthermore, (x.)S=(x1,x3) and ({circumflex over (x)}.)S=({circumflex over (x)}1, {circumflex over (x)}3). One defines x.=(x.)z 1,4 =(x1,x2, x3,x4) and {circumflex over (x)}.=({circumflex over (x)}.)z 1,4 =({circumflex over (x)}1, {circumflex over (x)}2,{circumflex over (x)}3,{circumflex over (x)}4).
Let Zext be the set of all jεZ1,N such that {circumflex over (x)}j is an external node, and let Zint be the set of all jεZ1,N such that {circumflex over (x)}j is an internal node. Clearly, Zext and Zint are disjoint and their union is Z1,N.
For example, for FIG. 1 , Zext={4} and Zint={1,2,3}.
Each possible value x. of {circumflex over (x)}. defines a different net story. For any net story x., we call (x.)z int the internal state of the story and (x.)z ext its external state.
For example, a possible story for the net of FIG. 1 is the case when {circumflex over (x)}1={circumflex over (x)}2=si and {circumflex over (x)}3={circumflex over (x)}4=no. This net story may also be represented by {circumflex over (x)}.=(si, si, no, no). Since we are assuming that each of the four nodes of FIG. 1 can assume two states, there are total of 24=16 stories possible for the net of FIG. 1. For story {circumflex over (x)}.=(si,si,no,no), the internal state is (x1,x2,x3)=(si,si,no) and the external state is x4=no.
For each net story, we may assign an amplitude to each node. Define Sj to be the set of all k such that an arrow labelled xk (i.e., an arrow whose source node is {circumflex over (x)}k) enters node {circumflex over (x)}j. We assign a complex number Aj[xm|(x.)S j ] to node {circumflex over (x)}j. We call Aj[xj|(x.)S j ] the amplitude of node {circumflex over (x)}j within net story x..
For example, consider a particular net story, call it (x1, x2,x3,x4), of FIG. 1. No arrow enters node {circumflex over (x)}1 so both S1 and (x.)S 1 are empty. Node {circumflex over (x)}2 is entered by an arrow from node {circumflex over (x)}1 so S2={1} and (x.)S 2 =(x1). Likewise, S3={1} and (x.)S 3 =(x1). Finally, S4={2,3} and (x.)S 4 =(x2,x3). We assign the complex number A1[x1] to node {circumflex over (x)}1, A2[x2|x1] to node {circumflex over (x)}2, A3[x3|x1] to node {circumflex over (x)}3, and A4[x4|x2,x3] to node {circumflex over (x)}4.
The amplitude of net story x, call it A(x.), is defined to be the product of all the node amplitudes Aj[xj|(x.)S j] for jεZ1,N. Thus,
For example, consider a particular net story, call it (x1, x2, x3, x4), of FIG. 1. One has that
A(x1,x2,x3,x4)=A1[x1]A2[x2|x1]A3[x3|x1]A4[x4|x2,x3] (2)
A(x1,x2,x3,x4)=A1[x1]A2[x2|x1]A3[x3|x1]A4[x4|x2,x3] (2)
The function Aj with values Aj[xj|(x.)S j ] determines a matrix that we will call the node matrix of node {circumflex over (x)}j, and denote by Qj. Thus, xj is the matrix's row index and (x.)S j is its column index.
For example, FIG. 1 gives the four node matrices Q1, Q2, Q3, Q4 associated with the four nodes of the graph shown there.
One can translate a QB net into a SEO by performing 4 steps: (1) Find eras. (2) Insert delta functions. (3) Find unitary extensions of era matrices. (4) Decompose each unitary matrix into a SEO. Next we will discuss these 4 steps in detail. We will illustrate our discussion by using Teleportation as an example. Teleportation was first discussed in Tel93: C. H. Bennett, G. Brassard, C. Crépeau, R. Jozsa, A. Peres, W. K. Wootters, Physical Review Letters 70, 1895 (1993). FIG. 2 shows a QB net for Teleportation. Reference Bra96: G. Brassard, Los Alamos eprint https://xxx.lanl.gov/abs/quant-ph/9605035 www.arxiv.org/abs/quant-ph/9605035, gives a SEO, expressed graphically as a qubit circuit, for Teleportation. It appears that the author of Bra96 obtained his circuit mostly by hand, based on information very similar to that contained in a QB net. The present invention gives a general method whereby such circuits can be obtained from a QB net in a completely mechanical way by means of a classical computer.
Step 1: Find Eras
The root node eras of a graph are defined as follows. Call the original graph Graph(1). The first era T1 is defined as the set of all root nodes of Graph(1). Call Graph(2) the graph obtained by erasing from Graph(1) all the T1 nodes and any arrows connected to these nodes. Then T2 is defined as the set of all root nodes of Graph(2). One can continue this process until one defines an era T|τ| such that Graph(|τ|+1) is empty. (One can show that if Graph(1) is acyclic, then one always arrives at a Graph(|τ|+1) that is empty.) For example, FIG. 3 shows the root node eras of the Teleportation net FIG. 2. Let τ represent the set of eras: τ={T1, T2, . . . , T|τ|}. Note that Ta⊂Z1,N for all aεZ1,|τ| and the union of all Ta equals Z1,N. In mathematical parlance, the collection of eras is a partition of Z1,N.
Rather than defining eras by (1) removing successive layers of root nodes, one can also define them by (2) removing successive layers of external nodes. We call this second type of era, the external node eras of the graph. For example, FIG. 4 shows the external node eras of the Teleportation net FIG. 2.
This process whereby one classifies the nodes of an acyclic graph into eras is a well know technique referred to as a chronological or topological sort in the computer literature. See, for example, Fla95: Bryan Flamig, Practical Algorithms in C++ (Wiley, 1995) page 369.
Henceforth, for the sake of definiteness, we will speak only of root node eras. The case of external node eras can be treated similarly.
Suppose that aεZ1,|τ|. The arrows exiting the a'th era are labelled by (x.)T a . Those entering it are labelled by (x.)Γ a , where Γa is defined by Γa=∪jεT a Sj. Note that the a'th era node is only entered by arrows from nodes that belong to previous (not subsequent) eras so Γa⊂Ta−1∪. . . ∪T2∪T1. The amplitude Ba of the a'th era is defined as
The amplitude A(x.) of story x. is given by
The amplitude A(x.) of story x. is given by
For example, for Teleportation we get from FIG. 3
B1(x1,x4)=A1(x1)A4(x4), (5a)
B2(x2,x3|x1)=A2(x2|x1)A3(x3|x1), (5b)
B3(x5|x2,x4)=A5(x5|x2,x4), (5c)
B4(x6|x3,x5)=A6(x6|x3,x5), (5d)
and
A(x.)=B4B3B2B1. (6)
Step 2: Insert Delta Functions
B1(x1,x4)=A1(x1)A4(x4), (5a)
B2(x2,x3|x1)=A2(x2|x1)A3(x3|x1), (5b)
B3(x5|x2,x4)=A5(x5|x2,x4), (5c)
B4(x6|x3,x5)=A6(x6|x3,x5), (5d)
and
A(x.)=B4B3B2B1. (6)
Step 2: Insert Delta Functions
The Feynman Integral FI for a QB net is defined by
Note that we are summing over all stories x. that have (x.)Zext as their external state. We want to express the right side of Eq. (7) as a product of matrices.
Note that we are summing over all stories x. that have (x.)Z
Consider how to do this for Teleportation. In that case one has
where the Ba are given by Eqs. (5). The right side of Eq. (8) is not ready to be expressed as a product of matrices because the column indices of Ba+1 and the row indices of Ba are not the same for all aεZ1,|τ|−1. Furthermore, the variable x3 occurs in B4 and B2 but not in B3. Likewise, the variable x4 occurs in B3 and B1 but not in B2. Suppose we defineB a for aεZ1,|τ| by
where we sum over all intermediate indices; i.e., all xj a except x6. Contrary to Eq. (8), the right side of Eq. (10) can be expressed immediately as a product of matrices since now Ba+1 column indices and Ba row indices are the same. The purpose of inserting a delta function of x3 into B3 is to allow the system to “remember” the value of X3 between non-consecutive eras T4 and T2. Inserting a delta function of x4 into B2 serves a similar purpose.
where the Ba are given by Eqs. (5). The right side of Eq. (8) is not ready to be expressed as a product of matrices because the column indices of Ba+1 and the row indices of Ba are not the same for all aεZ1,|τ|−1. Furthermore, the variable x3 occurs in B4 and B2 but not in B3. Likewise, the variable x4 occurs in B3 and B1 but not in B2. Suppose we define
where we sum over all intermediate indices; i.e., all xj a except x6. Contrary to Eq. (8), the right side of Eq. (10) can be expressed immediately as a product of matrices since now Ba+1 column indices and Ba row indices are the same. The purpose of inserting a delta function of x3 into B3 is to allow the system to “remember” the value of X3 between non-consecutive eras T4 and T2. Inserting a delta function of x4 into B2 serves a similar purpose.
In the Teleportation net of FIG. 2 , the last era contains all the external nodes. However, for some QB nets like the one in FIG. 5 , this is not the case. For the net of FIG. 5.
B1(x1)=A1(x2), (11a)
B2(x2,x3|x1)=A3(x3|x1)A2(x2|x1), (11b)
B3(x4|x3)=A4(x4|x3), (11c)
B4(x5|x4)=A5(x5|x4). (11d)
Even though node {circumflex over (x)}2 is external, the variable x2 does not appear as a row index in B4. Suppose we set
where we sum over all intermediate indices; i.e., all xj a except x2 and x5. Contrary to B4, the rows ofB 4 are labelled by the indices of both external nodes {circumflex over (x)}2 and {circumflex over (x)}5.
B1(x1)=A1(x2), (11a)
B2(x2,x3|x1)=A3(x3|x1)A2(x2|x1), (11b)
B3(x4|x3)=A4(x4|x3), (11c)
B4(x5|x4)=A5(x5|x4). (11d)
Even though node {circumflex over (x)}2 is external, the variable x2 does not appear as a row index in B4. Suppose we set
where we sum over all intermediate indices; i.e., all xj a except x2 and x5. Contrary to B4, the rows of
This technique of inserting delta functions can be generalized as follows to deal with arbitrary QB nets. For jεZ1,N, let amin(j) be the smallest aεZ1,|τ| such that xj appears in Ba. Hence, amin(j) is the first era in which xj appears. If {circumflex over (x)}j is an internal node, let amax(j) be the largest a such that xj appears in Ba (i.e., the last era in which xj appears). If {circumflex over (x)}j is an external node, let amax(j)=|τ|+1. For aεZ 1,|τ|+1. For aεZ1,|τ|, let
Δa={jεZ1,N|amin(j)<a<amax(j)}, (14)
In Eq. (15), xj |T| should be identified with xj and xj 0 with no variable at all. Equation (7) for FI can be written in terms of theB a functions:
where the sum is over all intermediate indices (i.e., all xj a for which a≠|τ|). For all a, define matrix Ma so that the x,y entry of Ma isB a(x|y). Define M to be a column vector whose components are the values of FI for each external state. Then Eq. (16) can be expressed as:
M=M|τ| . . . M2M1. (17)
The rows of the column vector M are labelled by the possible values of (x.)Zext . The rows of the column vector M1 are labelled by the possible values of (x.)T 1 , where T1 is the set of root nodes.
Step 3: Find Unitary Extensions of Era Matrices
Δa={jεZ1,N|amin(j)<a<amax(j)}, (14)
In Eq. (15), xj |T| should be identified with xj and xj 0 with no variable at all. Equation (7) for FI can be written in terms of the
where the sum is over all intermediate indices (i.e., all xj a for which a≠|τ|). For all a, define matrix Ma so that the x,y entry of Ma is
M=M|τ| . . . M2M1. (17)
The rows of the column vector M are labelled by the possible values of (x.)Z
Step 3: Find Unitary Extensions of Era Matrices
So far, we have succeeded in expressing FI as a product of matrices Ma, but these matrices are not necessarily unitary. In this step, we will show how to extend each Ma matrix (by adding rows and columns) into a unitary matrix Ua.
By combining adjacent Ma's, one can produce a new, smaller set of matrices Ma. Suppose the union of two consecutive eras is also defined to be an era. Then combining adjacent Ma's is equivalent to combining consecutive eras to produce a new, smaller set of eras. We define a breakpoint as any position aεZ1,|τ|−1 between two adjacent matrices Ma+1 and Ma. Combining two adjacent Ma's eliminates a breakpoint. Breakpoints are only necessary at positions where internal measurements are made. For example, in Teleportation experiments, one measures node {circumflex over (x)}5, which is in era T3. Hence, a breakpoint between M4 and M3 is necessary. If that is the only internal measurement to be made, all other breakpoints can be dispensed with. Then we will have M=M2′M1′ where M2′=M4, M1′=M3M2M1. If no internal measurements are made, then we can combine all matrices Ma into a single one, and eliminate all breakpoints.
We will henceforth assume that for all aεZ1,|τ|, the columns of Ma are orthonormal. If for some a0εZ1,|τ|, Ma 0 does not satisfy this condition, it may be possible to “repair” Ma 0 , so that it does. First: If a row β of Ma 0 −1 is zero, then eliminate the column β of Ma 0 , and the row β of Ma 0 −1. Next: If a row β of the column vector Ma 0 −1 . . . M2M1 is zero, then flag the column β of Ma 0 . The flagged columns of Ma 0 can be changed without affecting the value of M. If the non-flagged columns of Ma 0 are orthonormal, and the number of columns in Ma 0 does not exceed the number of rows, then the Gram Schmidt method, to be discussed later, can be used to replace the flagged columns by new columns such that all the columns of the new matrix Ma 0 are orthonormal. If it is not possible to repair Ma 0 in any of the above ways (or in some other way that might become clear once we program this), one can always remove the breakpoint between Ma 0 +1 and Ma 0 .
We will call da the number of rows of matrix Ma and da−1 its number of columns. We define D and NS by
D=max{da|1≦a≦|τ|} (18)
NS=min{2i|iεZ1,∞,D≦2i}. (19)
Letd a=NS−da for all a. For each a≠1. we define Ua to be the matrix that one obtains by extending Ma as follows. We append an d a×da−1 block of zeros beneath Ma and an NS× d a−1 block of gray entries to the right of Ma. By gray entries we mean entries whose value is yet to be specified. When a=1, M1 be can extended in two ways. One can append a column of d 1 zeros beneath it and call the resulting NS dimensional column vector v1. Alternatively, one can append a column of d 1 zeros beneath M1 and an NS×(NS−1 block of gray entries to the right of M1, and call the resulting NS×NS matrix U1. In this second case, one must also insert e1 to the right of U1. By e1 we mean the NS dimensional column vector whose first entry equals one and all others equal zero. Which extension of M1 is used, whether the one that requires e1 or the one that doesn't, should be left as a choice of the user. Henceforth, for the sake of definiteness, we will assume that the user has chosen the extension without the e1. The other case can be treated similarly. Equation (17) then becomes
v=U|τ| . . . U3U2v1, (20)
where v is just the column vector M withd |τ| zeros attached to the end.
D=max{da|1≦a≦|τ|} (18)
NS=min{2i|iεZ1,∞,D≦2i}. (19)
Let
v=U|τ| . . . U3U2v1, (20)
where v is just the column vector M with
To determine suitable values for the gray entries of the Ua matrices, one can use the Gram-Schmidt (G.S.) method. (See Nob88: B. Noble and J. W. Daniels, Applied Linear Algebra, Third Edition (Prentice Hall, 1988)). This method takes as input an ordered set S=(v1, v2, . . . , vN) of vectors, not necessarily independent ones. It yields as output another ordered set of vectors S′=(u1, u2, . . . , uN), such that S′ spans the same vector space as S. Some vectors in S′ may be zero. Those vectors of S′ which aren't zero will be orthonormal. For rεZ1,N, if the first r vectors of S are already orthonormal, then the first r vectors of S′ will be the same as the first r vectors of S. Let ej for jεZ1,N S be the j'th standard unit vector (i.e., the vector whose j'th entry is one and all other entries are zero). For each aεZ1,|τ|, to determine the gray entries of Ua one can use the G.S. method on the set S consisting of the non-gray columns of Ua together with the vectors e1, e2, . . . eN s .
Step 4: Decompose Each Unitary Matrix into a SEO
In this section we present a CS method for decomposing an arbitrary unitary matrix into a SEO. By following the previous 3 steps, one can reduce a QB net to a product of unitary operators Ua. By applying the CS method of this section to each of the matrices Ua, one can reduce the QB net to a SEO.
We will use the symbol NB for the number (≦1) of bits and NS=2N B for the number of states with NB bits. We define Bool={0,1}. We will use lower case Latin letters a,b,c . . . εBool to represent bit values and lower case Greek letters α,β,δ, . . . εZ0,N b −1 to represent bit positions. A vector such as {right arrow over (a)}=aN b −1 . . . a2a1a0 will represent a string of bit values, aμ being the value of the μ'th bit for μεZ0,N b −1. A bit string {right arrow over (a)} has a decimal representation
For βεZ0,NB −1, we will use {right arrow over (u)}(β) to denote the β'th standard unit vector, i.e, the vector with bit value of 1 at bit position β and bit value of zero at all other bit positions.
For βεZ0,N
Ir will represent the r dimensional unit matrix. Suppose βεZ0,N B −1 and M is any 2×2 matrix. We define M(β) by
M(β)=I2(×) . . . (×)I2(×)M(×)I2(×) . . . (×)I2, (22)
where the matrix M on the right side is located at bit position β in the tensor product ofN B2×2 matrices. The numbers that label bit positions in the tensor product increase from right to left (←), and the rightmost bit is taken to be at position 0.
M(β)=I2(×) . . . (×)I2(×)M(×)I2(×) . . . (×)I2, (22)
where the matrix M on the right side is located at bit position β in the tensor product of
For any two square matrices A and B of the same dimension, we define the (·) product by A(·)B=ABA†, where A† is the Hermitian conjugate of A.
{right arrow over (σ)}=(σx,σy,σz) will represent the vector of Pauli matrices, where
The Sylvester-Hadamard matrices Hr are 2r×2r matrices whose entry at row {right arrow over (a)} and column {right arrow over (b)} is given by
(Hr){right arrow over (a)}, {right arrow over (b)}=(−1){right arrow over (a)}·{right arrow over (b)}, (24)
where
(Hr){right arrow over (a)}, {right arrow over (b)}=(−1){right arrow over (a)}·{right arrow over (b)}, (24)
where
The qubit's basis states |0< and |1> will be represented by
The number operator n of the qubit is defined by
Note that
n|0>=0,n|1>=|1>. (28)
Note that
n|0>=0,n|1>=|1>. (28)
We will often use n as shorthand for
We define P0 and P1 by
For βεZ0,NB −1, we define P0(β),P1(β), n(β) and n (β) by means of Eq. (22). For {right arrow over (a)}εBoolB B ,let
P{right arrow over (a)}=PaNB −1(×) . . . (×)Pa 2 (×)Pa 1 (×)Pa 0 . (31)
We define P0 and P1 by
For βεZ0,N
P{right arrow over (a)}=PaN
As mentioned earlier, we utilize a mathematical technique called the CS Decomposition. In this name, the letters C and S stand for “cosine” and “sine”. Next we will state the special case of the CS Decomposition Theorem that arises in a preferred embodiment of the invention.
Suppose that U is an N×N unitary matrix, where N is an even number. Then the CS Decomposition Theorem states that one can always express U in the form
where L0,L1,R0,R1 are N/2×N/2 unitary matrices and
For
Ci and Si are real numbers that satisfy
Ci 2+Si 2=1. (33e)
Henceforth, we will use the term D matrix to refer to any matrix that satisfies Eqs. (33). If one partitions U into four blocks Uij ofsize
then
Uij=LiDijRj, (34)
for i,jε{0,1}. Thus, Dij gives the singular values of Uij.
where L0,L1,R0,R1 are N/2×N/2 unitary matrices and
For
Ci and Si are real numbers that satisfy
Ci 2+Si 2=1. (33e)
Henceforth, we will use the term D matrix to refer to any matrix that satisfies Eqs. (33). If one partitions U into four blocks Uij of
then
Uij=LiDijRj, (34)
for i,jε{0,1}. Thus, Dij gives the singular values of Uij.
More general versions of the CS Decomposition Theorem allow for the possibility that we partition U into 4 blocks of unequal size.
Note that if U were a general (not necessarily unitary) matrix, then the four blocks Uij would be unrelated. Then to find the singular values of the four blocks Uij would require eight unitary matrices (two for each block), instead of the four Li,Rj. This double use of the Li,Rj is a key property of the CS decomposition.
Consider FIG. 6. We start at 61 with a unitary matrix U. Without loss of generality, we can assume that the dimension of U is 2N B for some NB≧1. (If initially U's dimension is not a power of 2, we replace it by a direct sum U(+)Ir whose dimension is a power of two.) We apply the CS Decomposition method to U. This yields node 62 comprising matrix D(0,U) of singular values, two unitary matrices L(0,U) and L(1,U) on the left and two unitary matrices R(0,U) and R(1,U) on the right. Then we apply the CS Decomposition method to each of the 4 matrices L(0.U),L(1.U),R(0,U) and R(1,U) and obtain nodes 63 and 64. Then we apply the CS Decomposition method to each of the 16 R and L matrices in nodes 63 and 64. And so on. This process ends when the current row of nodes in the pyramid of FIG. 6 has L's and R's that are 1×1 dimensional, i.e., just complex numbers.
Call a central matrix either (1) a single D matrix, or (2) a direct sum D1(+)D2(+) . . . (+)Dr of D matrices, or (3) a diagonal unitary matrix. From FIG. 6 it is clear that the initial matrix U can be expressed as a product of central matrices, with each node of the tree providing one of the central matrices in the product. Next, we show how to decompose each of the 3 possible kinds of central matrices into a SEO.
Case 1: Central Matrix is a Single D Matrix
Consider how to decompose a central matrix when it is a single D matrix. Before dealing with arbitrary NB consider NB=3. Then the central matrix D can be expressed as:
Suppose {right arrow over (φ)} (ditto, {right arrow over (θ)}) is a column vector whose components are the numbers φ{right arrow over (a)} (ditto, θ{right arrow over (a)}) arranged in order of increasing {right arrow over (a)}. We define new angles {right arrow over (θ)} in terms of the angles {right arrow over (φ)} by
Then one can show that
D=A00A01A10A11, (37)
where
A00=exp(iθ00σy)(×)I2(×)I2, (38a)
A01=σx(2)n(0)(·)[exp(iθ01σy)(×)I2(×)I2], (38b)
A10=σx(2)n(1)(·)[exp(iθ10σy)(×)I2(×)I2], (38c)
A11=[σx(2)n(1)σx(2)n(0)](·)[exp(iθ11σy)(×) I2(×)I2]. (38d)
Eqs. (37)-(38) achieve our goal of decomposing D into a SEO. Now consider an arbitrary NB. D can be written as
where the φ{right arrow over (a)} are real numbers. We define new angles {right arrow over (θ)} in terms of the angles {right arrow over (φ)} by
where the operators A{right arrow over (b)} on the right side commute and will be defined next. For any {right arrow over (b)}εboolND −1 we can write
where
NB−2≧βr−1>. . . β1>B0≧o. (43)
In other words, {right arrow over (b)} has bit value of 1 at bit positions βj. At all other bit positions, {right arrow over (b)} has bit value of 0. r is the number of bits in {right arrow over (b)} whose value is 1. When {right arrow over (b)}=0, r=0. One can show that
A{right arrow over (b)}=[σx(NB−1)n(βr−1) . . . σx(NB−1)n(β1)σx(NN−1)n(β0)](·)exp[iθ{right arrow over (b)}σ y(NB−1] (44)
There are other ways of decomposing A{right arrow over (b)} into a SEO.
Suppose {right arrow over (φ)} (ditto, {right arrow over (θ)}) is a column vector whose components are the numbers φ{right arrow over (a)} (ditto, θ{right arrow over (a)}) arranged in order of increasing {right arrow over (a)}. We define new angles {right arrow over (θ)} in terms of the angles {right arrow over (φ)} by
Then one can show that
D=A00A01A10A11, (37)
where
A00=exp(iθ00σy)(×)I2(×)I2, (38a)
A01=σx(2)n(0)(·)[exp(iθ01σy)(×)I2(×)I2], (38b)
A10=σx(2)n(1)(·)[exp(iθ10σy)(×)I2(×)I2], (38c)
A11=[σx(2)n(1)σx(2)n(0)](·)[exp(iθ11σy)(×) I2(×)I2]. (38d)
Eqs. (37)-(38) achieve our goal of decomposing D into a SEO. Now consider an arbitrary NB. D can be written as
where the φ{right arrow over (a)} are real numbers. We define new angles {right arrow over (θ)} in terms of the angles {right arrow over (φ)} by
where the operators A{right arrow over (b)} on the right side commute and will be defined next. For any {right arrow over (b)}εboolN
where
NB−2≧βr−1>. . . β1>B0≧o. (43)
In other words, {right arrow over (b)} has bit value of 1 at bit positions βj. At all other bit positions, {right arrow over (b)} has bit value of 0. r is the number of bits in {right arrow over (b)} whose value is 1. When {right arrow over (b)}=0, r=0. One can show that
A{right arrow over (b)}=[σx(NB−1)n(β
There are other ways of decomposing A{right arrow over (b)} into a SEO.
Case 2: Central Matrix is Direct Sum of D Matrices
Next, consider how to decompose a central matrix when it is a direct sum of D matrices. Consider first the case NB=3. Let R(φ)=exp(iσyφ). Previously we mentioned the fact that any D matrix D can be expressed as
where the Dj and Dij are D matrices. It follows that by permuting the bit positions, we can change such a direct sum of D matrices into a single D matrix. The latter can then be decomposed into a SEO by the method already discussed.
where the Dj and Dij are D matrices. It follows that by permuting the bit positions, we can change such a direct sum of D matrices into a single D matrix. The latter can then be decomposed into a SEO by the method already discussed.
Case 3: Central Matrix is a Diagonal Unitary Matrix
Finally, consider how to decompose a central matrix when it is a diagonal unitary matrix. Before dealing with arbitrary NB, consider NB=2. Then the central matrix C can be expressed as
C=diag(eiφoo, eiφ01, eiφ10, eiφ11). (49)
We define {right arrow over (φ)} by
One can show that
C=A00A01A10A11, (51)
where
A00=exp(iθ00), (52a)
A01=I2(×)exp(iθ01σz), (52b)
A10=exp(iθ10σz)(×)I2, (52c)
A11=σx(0)n(1)(·)[I2(×)exp(iθ11σz)]. (52d)
Now consider an arbitrary NB. Any diagonal unitary matrix C can be expressed as
where the φ{right arrow over (a)} are real numbers. We define {right arrow over (θ)} by
where the A{right arrow over (b)} operators commute and will be defined next. For any {right arrow over (b)}εBoolNB , we can write
where
NB−1≧βr−1>. . . >β1>β0≧0. (57)
One can show that
There are other ways of decomposing A{right arrow over (b)} into a SEO.
(B) Implementation of New Method on Classical Computer
C=diag(eiφoo, eiφ01, eiφ10, eiφ11). (49)
We define {right arrow over (φ)} by
One can show that
C=A00A01A10A11, (51)
where
A00=exp(iθ00), (52a)
A01=I2(×)exp(iθ01σz), (52b)
A10=exp(iθ10σz)(×)I2, (52c)
A11=σx(0)n(1)(·)[I2(×)exp(iθ11σz)]. (52d)
Now consider an arbitrary NB. Any diagonal unitary matrix C can be expressed as
where the φ{right arrow over (a)} are real numbers. We define {right arrow over (θ)} by
where the A{right arrow over (b)} operators commute and will be defined next. For any {right arrow over (b)}εBoolN
where
NB−1≧βr−1>. . . >β1>β0≧0. (57)
One can show that
There are other ways of decomposing A{right arrow over (b)} into a SEO.
(B) Implementation of New Method on Classical Computer
So far in Section (A), we have described a mathematical algorithm for decomposing any QB net into a SEO. Next we describe a particular implementation of the algorithm, a computer program called “Qubiter” that can be run on a classical computer.
The use of a computer is practically indispensable for obtaining useful numerical answers through the method of Section (A). In all but the simplest of cases, vast amounts of data storage and processing are necessary to obtain final numerical answers from the method of Section (A). The necessary book-keeping and number crunching are prohibitively error prone and time consuming to a human, but not to a computer.
A preferred embodiment of the invention is a classical computer that feeds data (a SEO) to a quantum computer. By a classical computer, we mean a device that makes a desired calculation using digital circuits which implement deterministic (classical, non-quantum) logic. By a quantum computer we mean a device that makes a desired calculation using an array of quantum bits (qubits). Besides their calculational circuits, classical and quantum computers may comprise input, output and memory devices. The important difference is that an array of quantum bits may be put in an entangled quantum state, whereas a digital deterministic logic circuit cannot be put in such a state (in practice, for useful periods of time). The classical computer of our preferred embodiment is a Mac computer, produced by Apple Computer Inc. of Cupertino, California. The Mac is running a program written in the computer language C++. Of course, this invention could just as easily be implemented in a language other than C++, and on a platform other than a Mac. FIG. 7 is a block diagram of a classical computer feeding data to a quantum computer. 70 represents a classical computer. It comprises 71, 72, 73. 71 represents input devices, such as a mouse or a keyboard. 72 represents the CPU, internal and external memory units. 72 does calculations and stores information. 73 represents output devices, such as a printer or a display screen. An image of a QB net (for example, FIG. 2 ) can be rendered on the display screen. 75 represents a quantum computer, comprising an array of quantum bits and some hardware for manipulating the state of those bits.
Software for a preferred embodiment of the invention was written using Code Warrior™. Code Warrior is a C++ Integrated Development Environment produced by MetroWerks Inc. of Austin, Texas. C++ source code for a computer program called “Qubiter1.0” is included as a Microfiche Appendix to this document. The Microfiche Appendix has two parts: Appendix A and Appendix B.
Appendix A is a listing of the names of all the files in the “CodeWarrior Project” for Qubiter. Appendix B is a listing of Qubiter source code. Apart from libraries provided with CodeWarrior, Qubiter requires parts of the C library called Clapack. This library is freeware and can be downloaded via the Internet from the website “www.netlib.org”.
Qubiter uses files that list the entries of a unitary matrix U. FIG. 8 shows an example of such files. Qubiter ignores the lines labelled 81 and 83. The line labelled 82 tells how many bits are necessary to label U's columns (or rows, since U must be square). In the example of FIG. 8 , according to 82, two bits are necessary to label U's column, so one expects U to be a 4×4 matrix with 16 elements. 84 labels all the lines after the line labelled 83. Each line in 84 represents a complex number z, the real part of z is listed first, then some white space to the right of it, and then the imaginary part of z to the right of that. 84 contains the entries of U, arranged so that the entries in the first column of U are listed first, then those of the second column of U, etc.
Qubiter also uses files that list SEOs. FIG. 9 is an example of such a file. The line labelled 91 tells how many bits the gates listed in the file are to operate on, (i.e., what we called NB in Section (A)). 92 labels all the other lines in the file. Each line in 92 represents a gate. There are four types of gates, and they are specified as follows:
(a) PHAS ang
where ang is a real number. This signifies a phase factor
(b) CNOT α a char β
(b) CNOT α a char β
-
- where α,βεZ0,N
B −1 and char ε{T,F}. T and F stand for true and false. If char is the character T, this signifies σx(β)n(α). Read it as “c-not: if α is true, then flip β.” If char is the character F, this signifies σx(β)n (α)n. Read it as “c-not: if α is false, then flip β.”
(c) ROTY α ang - where αεZ0,N
B −1 and ang is a real number. This signifies the rotation of qubit α about the Y axis by an angle ang in degrees. In other words,
(d) ROTZ α ang - This is the same as (c) except that the rotation is about the Z axis instead of the Y one.
- where α,βεZ0,N
The matrix given in FIG. 8 can be decomposed into the SEO given in FIG. 9. Such decompositions are not unique. After doing the trivial optimization of removing all factors A{right arrow over (b)} for which the rotation angle is zero, the 33 operations in FIG. 9 reduce to 25 operations in FIG. 10.
Qubiter starts by looking for a parameter file entitled “qbtr-params.in”. FIG. 11 is an example of such a file. Lines labelled 111, 113, 115 and 117 are ignored by the program. Lines labelled 112, 114, 116, 118 are not.
The user should enter into line 112 the name of a matrix. In FIG. 11 , we have used “DiscFourier2bits”.
If the user enters “yes” into line 114 as an answer to “Do compilation?”, then Qubiter will look for a file named “DiscFourier2bits.in”. In other words, it will look for a file whose name is the string in line 112 plus the suffix “.in”. Qubiter expects to find in this file the entries of the unitary matrix Uinitial to be decomposed. The file should be of the form exemplified by FIG. 8.
If the user enters “yes” into line 116 as an answer to “Do decompilation?”, then Qubiter will look for a file named “DiscFourier2bits-cmnd.out”. In other words, it will look for a file whose name is the string in line 112 plus the suffix “-cmnd.out”. Qubiter expects to find in this file a SEO. The file should be of the form exemplified by FIGS. 9 and 10 .
If the user enters “yes” into line 118 as an answer to “Do zero angle optimization?”, then Qubiter will produce a file of the type exemplified by FIG. 10 instead of the type exemplified by FIG. 9. Thus, it will omit those gates arising from a rotation by a zero angle.
Qubiter has 2 main modes of operation.
The first mode of operation is when the user enters “yes” in line 114 as an answer to “Do compilation?”, and “yes” in line 116 as an answer to “Do decompilation?” In this mode, the user must provide 2 input files entitled “qbtr-params.in” and “mat.in”, where “mat” is the string in line 112. Qubiter will output a file called “mat-cmnd.out”. Then it will use mat-cmnd.out as input, multiply the SEO listed in this file, arrive at a unitary matrix Ufinal, and output a file called “mat-check.out” which lists the entries of Ufinal. If everything goes well, the matrix Uinitial specified by file “mat.in” and the matrix Ufinal specified by file “mat-check.out” will be the same matrix, within machine precision.
The second mode of operation is when the user enters “no” in line 114 as an answer to “Do compilation?”, and “yes” in line 116 as an answer to “Do decompilation?” In this mode, the user must provide 2 input files entitled “qbtr-params.in” and “mat-cmnd.out”. Qubiter will multiply the SEO listed in “mat-cmnd.out”, arrive at a unitary matrix Ufinal, and output a file called “mat-check.out” which lists the entries of Ufinal.
We should also mention a small frill to the first mode of operation. At the same time that Qubiter outputs the file “mat-cmnd.out”, it also outputs a file called “mat-pict.out” which is a translation of “mat-cmnd.out” to a pictorial language. Each elementary gate is represented by a line in “mat-pict.out”. Consider a single line of the file. There is a 1 to 1 correspondence between the characters in the line and the qubits of an array of qubits. The rightmost character represents bit 0. The next to rightmost character in the line represents bit 1. And so on. A bit that is not operated on is represented by a “|” character. A bit that is rotated about the Z axis (ditto, Y axis) is represented by a “Z” character (ditto, “Y” character). If the gate is a c-not that flips a bit when the control bit is true (ditto, false), then the control bit is represented by a “@” character (ditto, “0” character). The bit to be flipped is represented by an “X” character. If the gate is a pure phase acting on all bits, all bits are represented by the ˜ character.
The CS Decomposition is intimately related to the Generalized Singular Value Decomposition (GSVD). In fact, Qubiter1.0 does CS decompositions by means of a Clapack subroutine for doing GSVD. For more information about the GSVD and its connection to the CS Decomposition, see Pai94 and references therein. See also the Clapack documentation that comes with the subroutine zggsvd.c
So far, we have described version 1.0 of Qubiter. Future versions of Qubiter are planned that will: (1)Take as input an arbitrary QB net (not just 2 connected nodes), and return as output a SEO. (2) Add quantum error correction code to the input QB net. (3)Include optimizations enabling it to produce SEOs with fewer steps.
In classical computation, the basic set of elementary operators is not unique. For example, instead of using AND, NOT and OR gates, one can just use NAND gates. The same is true in quantum computation: the basic set of elementary operators is not unique. In this preferred embodiment of the invention, we use the set {CONTROLLED-NOT, QUBIT ROTATION} of elementary operators, but the invention also applies to other sets of elementary operators.
So far, we have described what are at present the preferred embodiments of this invention. Those skilled in the art will be able to come up with many modifications to the given embodiments without departing from the present invention. It is therefore desired that the scope of the invention be determined by the appended claims rather than by the given embodiments.
Claims (37)
1. A method of operating a classical computer, wherein said method must be stored in a computer readable medium which said classical computer can read, , wherein said method must be stored in the external or internal memory units of said classical computer, to calculate a sequence of operations with the purpose of applying said sequence of operations to a quantum computer comprising an array of qubits, to induce said quantum computer to execute a desired calculation, said method comprising the steps of:
storing in said classical computer a QB net (Quantum Bayesian net) data-set comprising:
(a) graph information comprising a node label for each node of a plurality of N nodes, and also comprising a plurality of directed lines, wherein a directed line comprises an ordered pair of said node labels, wherein one member of the label pair labels the source node and the other member labels the destination node of the directed line,
(b) state information comprising, for each jε{1, 2, . . . N}, a finite set Σj containing labels for the states that the j'th node {circumflex over (x)}j may assume assumes, and
(c) amplitude information comprising, for each jε{1, 2, . . . N}, a representation of a complex number
for each vector
such that xjεΣj, xk 1 εΣk 1 , xk 2 εΣk 2 , . . . , and
wherein
are the |Sj| nodes connected to {circumflex over (x)}j by directed lines entering {circumflex over (x)}j, wherein said directed lines entering {circumflex over (x)}j transmit the state of their source node, wherein said |Sj| is an integer greater or equal to zero,
composing with said classical computer and using said QB net data-set, a data-set that specifies yields a unitary matrix Vin, wherein Vin is equivalent to the unitary matrix U |T| . . . U 3 U 2 of Eq. ( 20 ), and V in describes the quantum-state evolution for the situation described by said QB net data-set,
calculating said sequence of operations using said classical computer, wherein said sequence of operations and said Vin both would, if applied to an said array of qubits, produce equivalent transformations of the array of qubits.
2. The method of claim 1 , wherein said sequence of operations comprises c-not operations elementary operations on said array of qubits.
3. The method of claim 1 , wherein said sequence of operations comprises qubit rotation operations is a sequence of elementary operations on said array of qubits.
4. The method of claim 1 , further also utilizing a quantum computer, comprising the additional step of:
manipulating said quantum computer largely according to said sequence of operations.
5. The method of claim 1 , wherein said classical computer includes a unitary matrix decomposer which is used in the calculation of said sequence of operations, wherein if the decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies specifies a represetation of three unitary matrices: L, D, R, such that the following matrix equation holds: U=LDR.
6. The method of claim 1 , wherein said classical computer includes a unitary matrix decomposer which is used in the calculation of said sequence of operations, wherein if the decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies eight unitary matrices: specifies a represetation of four matrices D00, D01, D10, D11, and four unitary matrices L0, L1, R0, R1, such that if one partitions said U into four blocks U00, U01, U10, U11, then the following four matrix equations hold: Uij=LiDijRj for iεBool and jεBool.
7. The method of claim 1 , comprising the additional step of:
calculating with said classical computer and using said QB net data-set, a tree data-set that comprises data that can be represented as a tree-node matrix for each node contained in a subset of the nodes of a tree, wherein the product, in some order defined by the determined in accordance with said tree, of all said tree-node matrices is equivalent to said Vin.
8. A method of operating a classical computer having display, storage and calculation means, wherein said method must be stored in a computer readable medium which said classical computer can read, , wherein said method must be stored in the external or internal memory units of said classical computer, to analyze a quantum physical system that exhibits quantum mechanical behavior comprising an array of qubits, said method comprising the steps of:
displaying on said display means a graph comprising a plurality of N nodes, and a plurality of directed lines connecting certain pairs of said nodes,
storing in said storage means a QB net (Quantum Bayesian net) data-set comprising:
(a) graph information comprising a node label for each of said N nodes, and also comprising, for each said directed line, said node label for the source node and for the destination node of the directed line,
(b) state information comprising, for each jε{1, 2, . . . N}, a finite set Σj containing labels for the states that the j'th node {circumflex over (x)}j may assume assumes, and
(c) amplitude information comprising, for each jε{1, 2, . . . N}, a representation of a complex number
for each vector
such that xjεΣj, xk 1 εΣk 1 , xk 2 εΣk 2 , . . . , and
wherein
are the |Sj| nodes connected to {circumflex over (x)}j by directed lines entering {circumflex over (x)}j, wherein said directed lines entering {circumflex over (x)}j transmit the state of their source node, wherein said |Sj| is an integer greater or equal to zero,
composing with said calculation means and using said QB net data-set, a data-set that specifies yields a unitary matrix Vin, wherein Vin is equivalent to the unitary matrix U |T| . . . U 3 U 2 of Eq. ( 20 )1 and V in describes the quantum-state evolution for the situation described by said QB net data-set,
calculating with said calculation means and using said QB net data-set, a sequence of operations on said array of qubits, wherein said sequence of operations and said Vin both would, if applied to an said array of qubits, produce equivalent transformations of the array of qubits.
9. The method of claim 8 , wherein said sequence of operations comprises c-not operations elementary operations on said array of qubits.
10. The method of claim 8 , wherein said sequence of operations comprises qubit rotation operations is a sequence of elementary operations on said array of qubits.
11. The method of claim 8 , further also utilizing a quantum computer, comprising the additional step of:
manipulating said quantum computer largely according to said sequence of operations.
12. The method of claim 8 , wherein said classical computer includes a unitary matrix decomposer which is used in the calculation of said sequence of operations, wherein if the decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies specifies a represetation of three unitary matrices: L, D, R, such that the following matrix equation holds: U=LDR.
13. The method of claim 8 , wherein said classical computer includes a unitary matrix decomposer which is used in the calculation of said sequences sequence of operations, wherein if the decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies eight unitary matrices; specifies a represetation of four matrices D00, D01, D10, D11, and four unitary matrices L0, L1, R0, R1, such that if one partitions said U into four blocks U00, U01, U10, U11, then the following four matrix equations hold: Uij=LiDijRj for iεBool and jεBool.
14. The method of claim 8 , comprising the additional step of:
calculating with said classical computer and using said QB net data-set, a tree data-set that comprises data that can be represented as a tree-node matrix for each node contained in a subset of the nodes of a tree, wherein the product, in some order defined by the determined in accordance with said tree, of all said tree-node matrices is equivalent to said Vin.
15. A method of operating a classical computer, wherein said method must be stored in a computer readable medium which said classical computer can read, , wherein said method must be stored in the external or internal memory units of said classical computer, to calculate a sequence of operations with the purpose of applying said sequence of operations to a quantum computer comprising an array of qubits, to induce said quantum computer to execute a desired calculation, wherein said classical computer comprises a unitary matrix decomposer, wherein if said unitary matrix decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U of dimension greater than 2, then the decomposer will calculate a data-set that fairly directly specifies specifies a represetation of three unitary matrices: L, D, R, such that the following matrix equation holds: U=LDR, wherein L and R each yields unitary matrices whose dimension is smaller than that of U, said method comprising the steps of:
storing in said classical computer an input data-set that fairly directly specifies specifies a represetation of a unitary matrix Vin, wherein at least one row of Vin has 3 or more non-zero entries and at least one column of Vin has 3 or more non-zero entries,
applying said unitary matrix decomposer to decompose the initial unitary matrix U=Vin ,
applying said unitary matrix decomposer repeatedly to decompose initial unitary matrices obtained from the output of a previous application of said unitary matrix decomposer,
calculating with said classical computer, using said input data-set and data obtained by applying said unitary matrix decomposer, said sequence of operations on said array of qubits, wherein said sequence of operations and said Vin both would, if applied to an said array of qubits, produce equivalent transformations of the array of qubits.
16. The method of claim 15 , wherein if said unitary matrix decomposer is given data that fairly directly specifies a unitary matrix U of dimension greater than 2 species a represetation of said initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies eight unitary matrices: specifies a represetation of four matrices D00, D01, D10, D11, and four unitary matrices L0, L1, R0, R1, such that if one partitions said U into four blocks U00, U01, U10, U11, then the following four matrix equations hold: Uij=LiDijRj for iεBool and jεBool.
17. The method of claim 15 , wherein said sequence of operations comprises c-not operations.
18. The method of claim 15 , wherein said sequence of operations comprises qubit rotation operations elementary operations on said array of qubits.
19. The method of claim 15 , wherein some of said sequences of operations comprise qubit rotations and c-nots said sequence of operations is a sequence of elementary operations on said array of qubits.
20. The method of claim 15 , further also utilizing a quantum computer, comprising the additional step of:
manipulating said quantum computer largely according to said sequence of operations.
21. A method of operating a classical computer, wherein said method must be stored in a computer readable medium which said classical computer can read, , wherein said method must be stored in the external or internal memory units of said classical computer, to calculate a sequence of operations with the purpose of applying said sequence of operations to a quantum computer comprising an array of qubits, to induce said quantum computer to execute a desired calculation, said method comprising the steps of:
storing in said classical computer an input data-set that fairly directly specifies specifies a represetation of a unitary matrix Vin, wherein at least one row of Vin has 3 or more non-zero entries and at least one column of Vin has 3 or more non-zero entries,
calculating with said classical computer and using said input data-set, a tree data-set that comprises data that can be represented as a node matrix Mj for each node j contained in a subset J of the nodes of a tree, wherein the product, in some order defined by the determined in accordance with said tree, of all said node matrices is equivalent to said Vin,
calculating with said classical computer and using said tree data-set, for each of the node matrices M, a string of operations on qubits, wherein said string of operations and said M both would, for each jεJ, a product πj of operations on said array of qubits, wherein M j and π j both would, if applied to an said array of qubits, produce equivalent transformations of the array of qubits.
22. The method of claim 21 , wherein some of said sequences of operations comprise for some jεJ, πj comprises c-not operations.
23. The method of claim 21 , wherein some of said sequences of operations comprise for some jεJ, πj comprises qubit rotation operations.
24. The method of claim 21 , wherein some of said sequences of operations comprise qubit rotations and c-nots for some jεJ, πj comprises elementary operations on said array of qubits.
25. The method of claim 21 , wherein said sequences of operations are sequences of elementary operations for all jεJ, πj is a sequence of elementary operations on said array of qubits.
26. The method of claim 21 , further also utilizing a quantum computer, comprising the additional step of:
manipulating said quantum computer largely according to said sequence of operations.
27. The method of claim 21 , wherein if said Vin is a square matrix with N rows, then said node matrices are also square matrices with N rows and with at most two non-zero entries in each row and in each column.
28. The method of claim 21 , wherein if said Vin is a square matrix with N rows, then said node matrices are also square matrices with N rows and with about two non-zero entries in each row and in each column.
29. The method of claim 21 , wherein if said Vin is a square matrix with N rows, then said node matrices have theoretically a number of nonzero real parameters which grows linearly with N or slower, for large N grows, for large N1 linearly with N or slower.
30. The method of claim 21 , wherein said classical computer includes a unitary matrix decomposer which is used in the calculation of said sequences sequence of operations, wherein if said unitary matrix decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies specifies a represetation of three unitary matrices: L, D, R, such that the following matrix equation holds: U=LDR.
31. The method of claim 21 , wherein said tree is a binary tree in which each node branches out into two nodes.
32. The method of claim 31 21, wherein said classical computer includes a unitary matrix decomposer which is used in the calculation of said sequences sequence of operations, wherein if the decomposer is given data that fairly directly specifies a specifies a represetation of an initial unitary matrix U, then the decomposer will calculate a data-set that fairly directly specifies eight unitary matrices: specifies a represetation of four matrices D00, D01, D10, D11, and four unitary matrices L0, L1, R0, R1, such that if one partitions said U into four blocks U00, U01, U10, U11, then the following four matrix equations hold: Uij=LiDijRj for iεBool and jεBool.
33. The method of claim 32 , wherein some of said sequences of operations comprise for some jεJ, πj comprises c-not operations.
34. The method of claim 32 , wherein some of said sequences of operations comprise for some jεJ, πj comprises qubit rotation operations.
35. The method of claim 32 , wherein some of said sequences of operations comprise qubit rotations and c-nots for some jεJ, πj comprises elementary operations on said array of qubits.
36. The method of claim 32 , wherein said sequences of operations are sequences of elementary operations for all jεJ, πj is a sequence of elementary operations on said array of qubits.
37. The method of claim 32 , further also utilizing a quantum computer, comprising the additional step of:
manipulating said quantum computer largely according to said sequence of operations.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/947,489 USRE41900E1 (en) | 1998-05-05 | 2004-09-22 | Compiler for a quantum computer |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/073,132 US6456994B1 (en) | 1998-05-05 | 1998-05-05 | Computer for a quantum computer |
US10/947,489 USRE41900E1 (en) | 1998-05-05 | 2004-09-22 | Compiler for a quantum computer |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/073,132 Reissue US6456994B1 (en) | 1998-05-05 | 1998-05-05 | Computer for a quantum computer |
Publications (1)
Publication Number | Publication Date |
---|---|
USRE41900E1 true USRE41900E1 (en) | 2010-10-26 |
Family
ID=22111908
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/073,132 Ceased US6456994B1 (en) | 1998-05-05 | 1998-05-05 | Computer for a quantum computer |
US10/947,489 Expired - Lifetime USRE41900E1 (en) | 1998-05-05 | 2004-09-22 | Compiler for a quantum computer |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/073,132 Ceased US6456994B1 (en) | 1998-05-05 | 1998-05-05 | Computer for a quantum computer |
Country Status (1)
Country | Link |
---|---|
US (2) | US6456994B1 (en) |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8612499B1 (en) * | 2010-11-01 | 2013-12-17 | Robert R. Tucci | Method for evaluating quantum operator averages |
US9111230B2 (en) | 2013-03-14 | 2015-08-18 | International Business Machines Corporation | Frequency arrangement for surface code on a superconducting lattice |
US10885678B2 (en) * | 2017-09-29 | 2021-01-05 | International Business Machines Corporation | Facilitating quantum tomography |
US11544613B2 (en) | 2019-12-26 | 2023-01-03 | International Business Machines Corporation | Controlling a quantum computing device based on predicted operation time |
Families Citing this family (29)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030164490A1 (en) * | 2001-02-13 | 2003-09-04 | Alexandre Blais | Optimization method for quantum computing process |
US7212974B2 (en) * | 2001-07-11 | 2007-05-01 | Daniel Kilbank | System and method for compressing and encoding data |
US20030121028A1 (en) * | 2001-12-22 | 2003-06-26 | Michael Coury | Quantum computing integrated development environment |
US20090182542A9 (en) * | 2001-12-22 | 2009-07-16 | Hilton Jeremy P | Hybrid classical-quantum computer architecture for molecular modeling |
US7307275B2 (en) * | 2002-04-04 | 2007-12-11 | D-Wave Systems Inc. | Encoding and error suppression for superconducting quantum computers |
CA2479170A1 (en) * | 2002-04-23 | 2003-11-06 | Daniel Kilbank | System and method for using microlets in communications |
DE04711889T1 (en) * | 2003-02-14 | 2006-11-30 | Clearsight Systems Inc., Bellevue | Method and programmable device for quantum calculation |
US7364923B2 (en) * | 2003-03-03 | 2008-04-29 | The Governing Council Of The University Of Toronto | Dressed qubits |
US7408486B2 (en) * | 2003-04-21 | 2008-08-05 | Qbit Corporation | System and method for using a microlet-based modem |
US7353148B1 (en) | 2003-08-06 | 2008-04-01 | The United States Of America As Represented By The Secretary Of The Army | Generation of displays of solutions to physics problems represented by complex mathematical equations using quantum computations or simulation of quantum computations on classic computers |
US7219017B2 (en) * | 2003-09-11 | 2007-05-15 | Franco Vitaliano | Quantum information processing elements and quantum information processing platforms using such elements |
US7219018B2 (en) * | 2003-09-11 | 2007-05-15 | Franco Vitaliano | Quantum information processing elements and quantum information processing platforms using such elements |
US7216038B2 (en) * | 2003-09-11 | 2007-05-08 | Franco Vitaliano | Quantum information processing elements and quantum information processing platforms using such elements |
US7620672B2 (en) * | 2004-05-24 | 2009-11-17 | Tucci Robert R | Method for performing classical Bayesian net calculations using a quantum computer |
US20070294070A1 (en) * | 2004-12-09 | 2007-12-20 | National University Corporation NARA Institute of Science and Technology | Program Development Support Apparatus for Computer System Including Quantum Computer, Program Development Support Program, and Simulation Apparatus |
US20070162262A1 (en) * | 2005-12-08 | 2007-07-12 | Tucci Robert R | Multiplexor approximation method for quantum compilers |
US7655850B1 (en) * | 2008-08-26 | 2010-02-02 | University Of Seoul Industry Cooperation Foundation | Universal quantum gate |
US11096901B2 (en) | 2009-03-06 | 2021-08-24 | Metaqor Llc | Dynamic bio-nanoparticle platforms |
US11235062B2 (en) * | 2009-03-06 | 2022-02-01 | Metaqor Llc | Dynamic bio-nanoparticle elements |
JP4786727B2 (en) * | 2009-03-27 | 2011-10-05 | 株式会社東芝 | Quantum calculation method, quantum computer and program |
JP2011130120A (en) * | 2009-12-16 | 2011-06-30 | Sony Corp | Quantum public key cryptosystem, key generation device, encryption device, decoder, key generating method, encryption method, and decoding method |
US8543627B1 (en) * | 2010-10-01 | 2013-09-24 | Robert R. Tucci | Method for sampling probability distributions using a quantum computer |
US8527437B1 (en) * | 2010-10-05 | 2013-09-03 | Robert R. Tucci | Method for driving starting quantum state to target one |
US9412074B2 (en) * | 2013-06-28 | 2016-08-09 | Microsoft Technology Licensing, Llc | Optimized trotterization via multi-resolution analysis |
US10366339B2 (en) | 2014-11-21 | 2019-07-30 | Microsoft Technology Licensing, Llc | Method for efficient implementation of diagonal operators over clifford+T basis |
US10540604B1 (en) | 2018-05-15 | 2020-01-21 | Rigetti & Co, Inc. | Operating a quantum processor having a three-dimensional device topology |
KR102100368B1 (en) * | 2018-05-17 | 2020-04-14 | 한국과학기술원 | Effective quantum RAM architecture for quantum database |
US10908885B2 (en) * | 2019-06-11 | 2021-02-02 | IonQ, Inc. | Quantum compiler |
US11829842B2 (en) | 2020-10-07 | 2023-11-28 | International Business Machines Corporation | Enhanced quantum circuit execution in a quantum service |
Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5787236A (en) * | 1996-01-11 | 1998-07-28 | Tucci; Robert R. | Graphical computer method for analyzing quantum systems |
-
1998
- 1998-05-05 US US09/073,132 patent/US6456994B1/en not_active Ceased
-
2004
- 2004-09-22 US US10/947,489 patent/USRE41900E1/en not_active Expired - Lifetime
Patent Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5787236A (en) * | 1996-01-11 | 1998-07-28 | Tucci; Robert R. | Graphical computer method for analyzing quantum systems |
Non-Patent Citations (19)
Title |
---|
A Barenco et al. Elementary Gates for Quantum Computation, Phys. Review A52, 3457 (1995). |
A. M. Steane, "Quantum Computing" (1997), Los Alamos eprint http:/xxx.lanl.gov/abs/quant-ph/9708022. |
Barenco et al., Elementary Gates for Quantum Computation, Physical Review A 52, 3457, 1998. * |
Bennett et al., Teleporting an Unknown Quantum State via Dual Classical and EPR Channels, Physical Review Letters 70, 1895. * |
Brassard Teleportation as Quantum Computation Los Alamos preprint https://xxx.lanl.gov/abs/quant-ph/9605035 (1996). |
Brassard, Teleportation as a Quantum Computation, Los Alamos eprint https://xxx.lanl.gov/abs/quant-ph/9605035. * |
DiVincenzo, Quantum Computation, Science 270, 255, 1995. * |
Flamig, Practical Algorothms in C++, 369-71, 1995. * |
Gilbert Strang, Linear Algebra and Its Applications: Third Edition, 31-39, 195-206, 236-38, 1998. * |
J. Adams, S. Leestma, L. Nyhoff, "C++, An Inroduction to Computing" (Prentice Hall 1995) (pp. 19-20). |
Murnaghan, The Orthogonal and Symplectic Groups, Institute for Advanced Studies, Dublin 12-16, 1958. * |
Paige et al., History and Generality of the CS Decomposition, Linear Algebra and Its Applications 208, 303, 1994. * |
Reck et al., Experimental Realization of Any Discrete Operator, Physical Review Letters 73, 58, 1994. * |
Robert R. Tucci, "A Quantum Compiler", Disclosure Document 431118 (1998). |
Robert R. Tucci, "A Rudimentary Quantum Compiler" (1998) Los Alamos eprint https://xxx.lanl.gov/abs/quant-ph9805015. |
Robert R. Tucci, "A Rudimentary Quantum Compiler" Disclosure Document 433559 (1998). |
Robert R. Tucci, "How to Compile a Quantum Bayerian Net" Los Alamos eprint https://xxx.lanl.gov/abs/quant-ph9805016. |
Robert R. Tucci, "Quantum Fog Library of Essays" (vers.1.0) 1997. |
Tucci, Quantum Bayesian Nets, Int. Jour. of Mod. Physics B9, 295, 1995. * |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8612499B1 (en) * | 2010-11-01 | 2013-12-17 | Robert R. Tucci | Method for evaluating quantum operator averages |
US9111230B2 (en) | 2013-03-14 | 2015-08-18 | International Business Machines Corporation | Frequency arrangement for surface code on a superconducting lattice |
US10885678B2 (en) * | 2017-09-29 | 2021-01-05 | International Business Machines Corporation | Facilitating quantum tomography |
US11544613B2 (en) | 2019-12-26 | 2023-01-03 | International Business Machines Corporation | Controlling a quantum computing device based on predicted operation time |
Also Published As
Publication number | Publication date |
---|---|
US6456994B1 (en) | 2002-09-24 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
USRE41900E1 (en) | Compiler for a quantum computer | |
Ventura et al. | Initializing the amplitude distribution of a quantum state | |
Amy et al. | A meet-in-the-middle algorithm for fast synthesis of depth-optimal quantum circuits | |
Tacchino et al. | Variational learning for quantum artificial neural networks | |
Jozsa | Entanglement and quantum computation | |
Jozsa | An introduction to measurement based quantum computation | |
Tucci | A rudimentary quantum compiler (2cnd ed.) | |
Lin et al. | FTQLS: Fault-tolerant quantum logic synthesis | |
Jozsa et al. | Matchgate and space-bounded quantum computations are equivalent | |
Steane et al. | Fault-tolerant logical gate networks for Calderbank-Shor-Steane codes | |
Sperduti | On the computational power of recurrent neural networks for structures | |
Bisio et al. | Free quantum field theory from quantum cellular automata: Derivation of Weyl, Dirac and Maxwell quantum cellular automata | |
Acampora et al. | D-nisq: a reference model for distributed noisy intermediate-scale quantum computers | |
Amy et al. | Improved synthesis of Toffoli-Hadamard circuits | |
US20050262179A1 (en) | Method for performing classical bayesian net calculations using a quantum computer | |
Kang et al. | Modular component-based quantum circuit synthesis | |
de Oliveira et al. | Quantum Bayesian decision-making | |
Acampora et al. | Quantum implementation of fuzzy systems through grover’s algorithm | |
Mulderij et al. | A polynomial size model with implicit swap gate counting for exact qubit reordering | |
Shapira et al. | Groverian measure of entanglement for mixed states | |
Pegolotti et al. | Fast M\" obius and Zeta Transforms | |
Nikahd et al. | One-way quantum computer simulation | |
Bhatia et al. | Quantifying matrix product state | |
Klappenecker | Wavelets and wavelet packets on quantum computers | |
Houshmand et al. | Decomposition of diagonal hermitian quantum gates using multiple-controlled pauli Z gates |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
FPAY | Fee payment |
Year of fee payment: 12 |