Hardware quantum gate

Abstract

A hardware quantum gate for running quantum algorithms in a very fast manner exploits the fact that a large number of multiplications required by an entanglement operation of the quantum algorithm provides a null result since only one component per row of the entanglement matrix UF is not a null. The entanglement operation generates an entanglement vector by permuting pairs of opposite components of a linear superposition vector, depending on the value assumed by the function f. More specifically, if function f is null in correspondence to the vector identified by the first (leftmost) n qubits in common with the two n+1 qubit vectors, in which a pair of opposite components of the superposition vector is referred to, then the corresponding pair of components of the entanglement vector is equal to that of the superposition vector, otherwise it is the opposite.

Description

FIELD OF THE INVENTION

[0002] The present invention relates to quantum algorithms, and more precisely, to a hardware quantum gate that performs, in particular, the entanglement operation of quantum algorithms.

BACKGROUND OF THE INVENTION

[0003] Quantum algorithms are global random searching algorithms based on the principles, laws and effects of quantum mechanics. They are used for controlling a process or for processing data in a database, and more specifically, for controlling a process that may include search-of-minima intelligent operations.

[0004] In a quantum search, each design variable is represented by a finite linear superposition of initial states, with a sequence of elementary unitary steps manipulating the initial quantum state |i> (for the input) such that a measurement of the final state of the system yields the correct output. Usually, three principle operators, i.e., linear superposition (coherent states), entanglement and interference, are used in the quantum search algorithm.

[0005] For a better understanding, a brief description of quantum search algorithms is provided. The problems solved by quantum algorithms may be stated as follows:

Input   A function f: {0, 1}n →{0, 1}m
Problem Find a certain property of f

[0006] The structure of a quantum algorithm is outlined by a high level representation in the schematic diagram of FIG. 1.

[0007] The input of a quantum algorithm is always a function f from binary strings into binary strings. This function is represented as a map table, which defines for every string its image. Function f is first encoded into a unitary matrix operator UF depending on f properties. This operator calculates f when its input and output strings are encoded into canonical basis vectors of a Complex Hilbert Space: UF maps the vector code of every string into the vector code of its image by f. 1$\&AutoLeftMatch;\begin{array}{c}\mathrm{BOX}1\text{:}\mathrm{UNITARY}\mathrm{MATRIX}{U}_F\\ A\mathrm{squared}\mathrm{matrix}{U}_F\mathrm{on}\mathrm{the}\mathrm{complex}\mathrm{field}\mathrm{is}\mathrm{unitary}\\ \mathrm{if}\mathrm{its}\mathrm{inverse}\mathrm{matrix}\mathrm{coincides}\mathrm{with}\mathrm{its}\mathrm{conjugate}\mathrm{transpose}\text{:}\\ U_F^{-1}=U_F^{=}\\ A\mathrm{unitary}\mathrm{matrix}\mathrm{is}\mathrm{always}\mathrm{reversible}\mathrm{and}\mathrm{preserves}\mathrm{the}\mathrm{norm}\\ \mathrm{of}\mathrm{vectors}.\end{array}$

[0008] When the matrix operator UF has been generated, it is embedded into a quantum gate G, a unitary matrix whose structure depends on the form of matrix UF and on the problem to be solved. The quantum gate is the core of a quantum algorithm. In every quantum algorithm, the quantum gate acts on an initial canonical basis vector (the same vector can always be chosen) to generate a complex linear combination (called a superposition) of basis vectors as the output. The superposition contains all the information to answer the initial problem.

[0009] After the superposition has been created, a measurement takes place to extract this information. In quantum mechanics, measurement is a non-deterministic operation that produces as output only one of the basis vectors in the superposition. The probability of every basis vector being the output of a measurement depends on its complex coefficient (probability amplitude) in entering a complex linear combination.

[0010] The segmental action of the quantum gate and of the measurement forms the quantum block. The quantum block is repeated k times to produce a collection of k basis vectors. In measuring a non-deterministic operation, these basic vectors would not be necessarily identical and each one of them will encode a piece of the information needed to solve the problem. The last part of the algorithm includes interpretation of the collected basis vectors to get the right answer for the initial problem with a certain probability.

[0011] The behavior of the encoder block is described in the detailed schematic diagram of FIG. 2. Function f is encoded into matrix UF in three steps.

[0012] Step 1: The map table of function f:{0, 1}n→{0, 1}m is transformed into the map table of the injective function F:{0, 1}n+m→{0, 1}n+m such that:

F (x0, . . . , xn−1, y0, . . . , ym−1)=(x0, . . . , xn−1, f(x0, . . . , xn−1)⊕(y0, . . . , ym−1))  (1) 2 $$ &AutoLeftMatch;   ⁢ BOX ⁢   ⁢ 2 ⁢ : ⁢   ⁢ XOR ⁢   ⁢ OPERATOR ⁢   ⊕ The ⁢   ⁢ XOR ⁢   ⁢ operator ⁢   ⁢ between ⁢   ⁢ two ⁢   ⁢ binary ⁢   ⁢ strings ⁢   ⁢ p ⁢   ⁢ and ⁢   ⁢ q ⁢   of ⁢   ⁢ length ⁢   ⁢ m ⁢   ⁢ is ⁢   ⁢ a ⁢   ⁢ string ⁢   ⁢ s ⁢   ⁢ of ⁢   ⁢ length ⁢   ⁢ m ⁢   ⁢ such ⁢   ⁢ that ⁢   ⁢ the ⁢   ⁢ i ⁢ - ⁢ th ⁢   ⁢ digit of ⁢   ⁢ s ⁢   ⁢ is ⁢   ⁢ calculated ⁢   ⁢ as ⁢   ⁢ the ⁢   ⁢ exclusive ⁢   ⁢ OR ⁢   ⁢ between ⁢   ⁢ the ⁢   ⁢ i ⁢ - ⁢ th ⁢   ⁢ digits of ⁢   ⁢ p ⁢   ⁢ and ⁢   ⁢ q ⁢ :   ⁢ p = ( p 0 , … ⁢   , p n - 1 )   ⁢ q = ( q 0 , … ⁢   , q n - 1 ) s = p ⊕ q = ( ( p 0 + q 0 ) ⁢   ⁢ mod ⁢   ⁢ 2 , … ⁢   , ( p n - 1 + q n - 1 ) ⁢   ⁢ mod ⁢   ⁢ 2 ) )

[0013] The need to deal with an injective function comes from the requirement that UF is unitary. A unitary operator is reversible, so it cannot map two different inputs in the same output. Given that UF is the matrix representation of F, F is supposed to be infective. If the matrix representation of function f is directly used, a non-unitary matrix could be obtained since f could be non-injective. Injectivity is thus fulfilled by increasing the number of bits and considering function F instead of function f. Function f can always be calculated from F by putting (y0, . . . , ym−1)=(0, . . . , 0) in the input string and reading the last m values of the output string.

[0014] Step 2: Function F map table is transformed into UF map table, following the following constraint:

∀sε{0,1}n+m:UF[τ(s)]=τ[F(s)]  (2)

[0015] The code map τ:{0,1}n+m→c2n+m(c2n+m is the target Complex Hilbert Space) is such that: 3$\begin{array}{cc}\tau \left(0\right)=\left(\begin{array}{c}1\\ 0\end{array}\right)=|0⟩\tau \left(1\right)=\left(\begin{array}{c}0\\ 1\end{array}\right)=|1⟩& \left(3\right)\\ \tau \left(x_0,\dots ,x_{n+m-1}\right)=\tau \left(x_0\right)\otimes \dots \otimes \tau \left(x_{n+m-1}\right)=|x_0\dots {x_{n+m-1}}_{}⟩& \end{array}$

4BOX⁢ ⁢3⁢:⁢ ⁢VECTOR⁢ ⁢TENSOR⁢ ⁢PRODUCT⊗
The tensor product between two vectors of dimensions
h and k is a tensor product of dimension hk, such
that:
5❘x⟩⊗|y⟩=(x1…xh)⊗(y1…yk)=(x1⁢y1…x1⁢yk…xh⁢y1…xh⁢yk)⇒Physical⁢ ⁢interpretation⁢:_If a component of a complexvector is interpreted as theprobability amplitude of asystem being in a given state(indexed by the componentnumber, the tensor product between two vectors describesthe joing probability amplitudeof two systems being in a joint state.

EXAMPLES

Vector Tensor Products

[0016]

6                                                                                                                        (                                                          0                              ,                              0                                                        )                                                    ⁢                                                      →                                                                                                                                                       ⁢                              τ                              ⁢                                                                                                                                                                             ⁢                                                                                    (                                                                                                                                    1                                                                                                                                                                        0                                                                                                                              )                                                        ⊗                                                          (                                                                                                                                    1                                                                                                                                                                        0                                                                                                                              )                                                                                                      =                                                                              (                                                                                                                            1                                                                                                                                                              0                                                                                                                                                              0                                                                                                                                                              0                                                                                                                      )                                                    =                                                      &LeftBracketingBar;                            00                            ⟩ 7                                                                                                                        (                                                          0                              ,                              1                                                        )                                                    ⁢                                                      →                                                                                                                                                       ⁢                              τ                              ⁢                                                                                                                                                                             ⁢                                                                                    (                                                                                                                                    1                                                                                                                                                                        0                                                                                                                              )                                                        ⊗                                                          (                                                                                                                                    0                                                                                                                                                                        1                                                                                                                              )                                                                                                      =                                                                              (                                                                                                                            0                                                                                                                                                              1                                                                                                                                                              0                                                                                                                                                              0                                                                                                                      )                                                    =                                                      &LeftBracketingBar;                            01                            ⟩
8                                                                                                                        (                                                          1                              ,                              0                                                        )                                                    ⁢                                                      →                                                                                                                                                       ⁢                              τ                              ⁢                                                                                                                                                                             ⁢                                                                                    (                                                                                                                                    0                                                                                                                                                                        1                                                                                                                              )                                                        ⊗                                                          (                                                                                                                                    1                                                                                                                                                                        0                                                                                                                              )                                                                                                      =                                                                              (                                                                                                                            0                                                                                                                                                              0                                                                                                                                                              1                                                                                                                                                              0                                                                                                                      )                                                    =                                                      &LeftBracketingBar;                            10                            ⟩ 9                                                                                                                        (                                                          1                              ,                              1                                                        )                                                    ⁢                                                      →                                                                                                                                                       ⁢                              τ                              ⁢                                                                                                                                                                             ⁢                                                                                    (                                                                                                                                    0                                                                                                                                                                        1                                                                                                                              )                                                        ⊗                                                          (                                                                                                                                    0                                                                                                                                                                        1                                                                                                                              )                                                                                                      =                                                                              (                                                                                                                            0                                                                                                                                                              0                                                                                                                                                              0                                                                                                                                                              1                                                                                                                      )                                                    =                                                      &LeftBracketingBar;                            11                            ⟩

[0017] Code τ maps bit values into complex vectors of dimension 2 belonging to the canonical basis of C2. Besides using a tensor product, τ maps the general state of a binary string of dimension n into a vector of dimension 2n for reducing this state to the joint state of the n bits composing the register. Every bit state is transformed into the corresponding 2-dimensional basis vector, and then the string state is mapped into the corresponding 2n-dimensional basis vector by composing all bit-vectors through a tensor product. The tensor product is thus the vector counterpart of a state conjunction. Basis vectors are denoted using the notation |i>. This notation is taken from the description of quantum mechanics.

[0018] Step 3: UF map table is transformed into UF using the following transformation rule:

[UF]ij=1UF|j>=|i>  (4)

[0019] which can be easily understood when considering vectors |i> and |j> as column vectors. Associating these vectors to the canonical basis, UF defines a permutation map of the identity matrix rows. In general, row |j> is mapped into row |i>. This rule will be illustrated in detail in an example quantum algorithm: Grover's algorithm.

[0020] The core of the quantum block is the quantum gate, which depends on the properties of matrix UF. The scheme in FIG. 3 gives a more detailed description of the quantum block. The matrix operator UF in FIG. 3 is the output of the encoder block represented in FIG. 2. Here, it becomes the input for the quantum block.

[0021] This matrix operator is first embedded into a more complex gate: the quantum gate G. Unitary matrix G is applied k times to an initial canonical basis vector |i> of dimension 2n+m. Every time, the resulting complex superposition G|0 . . . 01 . . . 1> of basis vectors is measured, and one basis vector |xi> is produced as a result. All the measured basis vectors {|x1>, . . . , |xk>} are collected together. This collection is the output of the quantum block.

[0022] The intelligence of such algorithms is in the ability to build a quantum gate that is able to extract the information necessary to find the required property of f and to store it into the output vector collection. The structure of the quantum gate for every quantum algorithm will be discussed in detail, observing that a general description is possible. To represent quantum some special diagrams called quantum circuits are going to be used.

[0023] An example of a quantum circuit, relative to the so called Deutsch-Jozsa's quantum algorithm, is illustrated in FIG. 4. Every rectangle is associated to a matrix 2n×2n, where n is the number of lines entering and leaving the rectangle. For example, the rectangle marked UF is associated to matrix UF. Typically, matrix H represents a Hadamard rotation 10$\begin{array}{cc}H=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]& \left(5\right)\end{array}$

[0024] Quantum circuits provide a high-level description of the gate, and using some of the transformation rules listed in FIGS. 5a-5f, it is possible to compile them into the corresponding gate-matrix. 11$\&AutoLeftMatch;\begin{array}{c}\underset{\_}{\mathrm{BOX}4\text{:}\mathrm{MATRIX}\mathrm{TENSOR}\mathrm{PRODUCT}\otimes }\\ \mathrm{The}\mathrm{tensor}\mathrm{product}\mathrm{between}\mathrm{two}\mathrm{matrices}{X}_{n\times m}\mathrm{and}{Y}_{h\times k}\\ \mathrm{is}a\left(\mathrm{block}\right)\mathrm{matrix}\left(n·h\right)\times \left(m·k\right)\mathrm{such}\mathrm{that}\text{:}\\ X\otimes Y=\left[\begin{array}{ccc}{x}_{11}Y& \cdots & x_{1m}Y\\ \cdots & \cdots & \cdots \\ x_{\mathrm{n1}}Y& \cdots & x_{nm}Y\end{array}\right]\mathrm{with}X=\left[\begin{array}{ccc}{x}_{11}& \cdots & x_{1m}\\ \cdots & \cdots & \cdots \\ x_{\mathrm{n1}}& \cdots & x_{nm}\end{array}\right]\end{array}$

Example

Matrix Tensor Product

[0025] 12 $$ [ 1 2 3 4 ] ⊗ [ 5 6 7 8 ] = [ 1 · [ 5 6 7 8 ] 2 · [ 5 6 7 8 ] 3 · [ 5 6 7 8 ] 4 · [ 5 6 7 8 ] ] = [ 5 6 10 12 7 8 14 16 15 18 20 24 21 24 28 32 ] _ _

[0026] It will be clearer how to use these rules when the first example of a quantum algorithm will be discussed in greater detail below.

[0027] The decoder block has the function to interpret the basis vectors collected after the iterated execution of the quantum block. Decoding these vectors means to retranslate them into binary strings and interpreting them directly if they already contain the answer to the starting problem. Alternatively, the vectors may be used as coefficient vectors for an equation system to get the searched solution. This part will not be discussed in any greater detail because it is relatively straightforward to understand by those skilled in the art.

[0028] Because of the particular importance of the Grover's quantum algorithm in the realization of controllers and data search algorithms in databases, a brief description of the Grover's algorithm will be given below. Grover's problem is stated as follows:

Input   A function f: {0, 1}n→{0, 1} such that
        ∃x∈{0, 1}n:
        (f(x) = 1∀y∈{0, 1}n:
        x ≠ yf(y) = 0)
Problem Find x

[0029] In the Deutsch-Jozsa's algorithm there are two classes of input functions and it must be determined what class the input function belongs to. In this case the problem is almost identical in its form, even if it is more difficult because now we are dealing with 2n classes of input functions (each function of the kind described forms a class).

[0030] The diagram of the Grover's algorithm is depicted in FIG. 6, and the gate equation is

Φ=[(Dn⊕I)·UF]h·(n+1H)  (6)

[0031] Operator Dn is called a diffusion matrix of order n and is responsible for interference in this algorithm. The diffusion matrix is defined as follows:

Dn	|0 . . . 0>	|0 . . . 1>	. . .	|i>	. . .	|1 . . . 0>	|1 . . . 1>
|0 . . . 0>	−1 + 1/2n−1	1/2n−1	. . .	1/2n−1	. . .	1/2n−1	1/2n−1
|0 . . . 1>	1/2n−1	−1 + 1/2n−1	. . .	1/2n−1	. . .	1/2n−1	1/2n−1
. . .	. . .	. . .	. . .	. . .	. . .	. . .	. . .
|i>	1/2n−1	1/2n−1	. . .	−1 + 1/2n−1	. . .	1/2n−1	1/2n−1
. . .	. . .	. . .	. . .	. . .	. . .	. . .	. . .
|1 . . . 0>	1/2n−1	1/2n−1	. . .	1/2n−1	. . .	−1 + 1/2n−1	1/2n−1
|1 . . . 1>	1/2n−1	1/2n−1	. . .	1/2n−1	. . .	1/2n−1	−1 + 1/2n−1

[0032] Grover's algorithm may be implemented in routines for searching a desired item in a set, by representing in vector form each item of the set forming an input set of vectors, and applying a Grover's algorithm to this set of vectors. The output vector represents the desired item.

[0033] The implementation of the Grover's algorithm clearly implies the calculation of several vector products. In fact, all qubits must be multiplied by matrix H, then by the entanglement matrix UF and all qubits but the latter must be multiplied by matrix Dn.

[0034] These multiplications could be carried out via software, but it is quite evident that the number of qubits of a quantum algorithm is very critical in terms of computational speed. In fact, referring to the scheme in FIG. 6, the addition of only one qubit doubles the dimensions of the matrices. Thus, the number of elements (and products) increases exponentially.

[0035] A method of performing the superposition operation of the Grover's or Deutsch-Jozsa's quantum algorithm over an input set of vectors is disclosed in European Patent No. 1267304, which is assigned to the current assignee of the present invention. This method exploits the fact that any rotated vector, obtained performing the Hadamard rotation (on an input vector) contemplated by the superposition operation of these quantum algorithms can be easily encoded in a binary vector. Therefore, the successive tensor product of the rotated vectors for generating linear superposition vectors can be carried out by logic gates. This fact allows a noticeable time saving since logic gates are very fast.

[0036] However, this is not sufficient to significantly speed up running these quantum algorithms because the entanglement matrix UF is a 2n+1×2n+1 square matrix, which implies a considerable computational weight both in the Grover's algorithm as well as in the Deutsch-Jozsa's algorithm.

[0037] Differently from other quantum algorithms, in the Grover's algorithm it is possible to iterate h times the entanglement and interference operations until the best solution is reached. An example of evolution of the Grover's algorithm with n=3 is given in FIG. 7a, in which basis vector and superposition, entanglement and interference output vectors are reported in order. Several iterations of entanglement and interference operations produce a better distribution of probability amplitudes.

[0038] Each value is a component on the output vector referred to a basis of vectors of n+1 qubits. There are couples or pairs of values having an opposite sign, referred to vectors of the basis having in common the first (leftmost) n qubits. For example, the values 0.625 and −0.625 are respectively referred to as vectors |0110> and |0111>, respectively. Each pair of elements having an opposite sign represents the probability amplitude of a certain element of the database. For the considered example, the value 0.625 is the probability of the element associated to vector |011> after 3 iterations (h=3).

[0039] The algorithm may be iterated as far as a certain quantity is to be minimized, calculated as a function of the components of the output vector, and is smaller than a certain pre-established value. For instance, this quantity can be the Shannon entropy: 13$\begin{array}{cc}S\left(h\right)=-\sum _{k=1}^{2^{n+1}}{\&LeftDoubleBracketingBar;q_k\left(h\right)\&RightDoubleBracketingBar;}^2\log {\&LeftDoubleBracketingBar;q_k\left(h\right)\&RightDoubleBracketingBar;}^2& \left(7\right)\end{array}$

[0040] where qk(h) is the k-th component of the output vector Q taken after h iterations.

[0041] The components of the output vector obtained after h=15 iterations are represented in FIG. 7b. From FIG. 7b it is clear that the element of the database to be found is associated with vector |011>, and after 15 iterations the Grover's quantum algorithm will find it with a probability of about 0.69.

[0042] From the above discussion it is evident that the problem of the large number of computations is even more crucial in the Grover's algorithm than in the Deutsch-Jozsa's algorithm because multiplication by the entanglement matrix UF and the interference matrix Dn⊕I might be repeated many (h) times to output the best result.

SUMMARY OF THE INVENTION

[0043] In view of the foregoing background, an object of the present invention is to provide a hardware quantum gate for running a quantum algorithms in a very fast manner.

[0044] The present invention exploits the fact that a large number of multiplications required by the entanglement operation of quantum algorithms give a null result, because only one component per row of the entanglement matrix UF is not a null. The entanglement operation generates an entanglement vector by permuting the places of pairs of opposite components of a linear superposition vector, depending on the value assumed by the function f(.). More specifically, if function f(.) is null in correspondence to the vector identified by the first (leftmost) n qubits in common with the two n+1 qubit vectors to which a pair of opposite components of which the superposition vector is referred to, then the corresponding pair of components of the entanglement vector is equal to that of the superposition vector. Otherwise, it is the opposite.

[0045] Therefore, it is not necessary to calculate the entanglement matrix UF to generate an entanglement vector from a superposition vector, but it is sufficient to copy or invert components of a superposition vector to generate corresponding components of an entanglement vector, depending on the values of the function f(.) processed by the quantum algorithm. This can be easily done using switches input with a pair of components having an opposite value of a superposition vector.

[0046] More precisely, the object of the present invention is to provide a quantum gate for running quantum algorithms using a certain binary function defined on a space having a basis of vectors of n qubits, composed of a superposition subsystem carrying out a superposition operation over components of input vectors for generating components of linear superposition vectors referred on a second basis of vectors of n+1 qubits. An entanglement subsystem carries out an entanglement operation over components of the linear superposition vectors for generating components of entanglement vectors. An interference subsystem carries out an interference operation over components of the entanglement vectors for generating components of output vectors.

[0047] The entanglement subsystem comprises a command circuit generating a number (2n) of logic command signals encoding the values of the binary function in correspondence to the vectors of the first basis, and an array of multiplexers input with the logic command signals that generate, for each superposition vector, corresponding signals representing components of an entanglement vector.

[0048] Each component of the entanglement vector referred to a respective vector of the second basis is equal to the corresponding component of the respective superposition vector if the binary function is null in correspondence to the vector of the first basis formed by the first n qubits of the respective vector of the second basis. Alternatively, each component may be equal to the opposite of the corresponding component of the respective superposition vector if the binary function is not a null in correspondence to the vector of the first basis formed by the first n qubits of the respective vector of the second basis.

BRIEF DESCRIPTION OF THE DRAWINGS

[0049] The particular aspects and advantages of the invention will become more evident through the following description of several important embodiments and by referring to the attached drawings, wherein:

[0050] FIG. 1 is a block diagram of quantum algorithm in accordance with the prior art;

[0051] FIG. 2 is a block diagram of an encoder in accordance with the prior art;

[0052] FIG. 3 is a general structure of the quantum algorithm as shown in FIG. 1;

[0053] FIG. 4 is a circuit for a Deutsch-Jozsa's quantum gate in accordance with the prior art;

[0054] FIG. 5 a shows an example of a tensor product transformation in accordance with the prior art;

[0055] FIG. 5 b shows an example of dot product transformation in accordance with the prior art;

[0056] FIG. 5 c shows the identity transformation in accordance with the prior art;

[0057] FIG. 5 d shows an example of the propagation rule in accordance with the prior art;

[0058] FIG. 5 e shows an example of the iteration rule in accordance with the prior art;

[0059] FIG. 5 f explains the input/output tensor rule in accordance with the prior art;

[0060] FIG. 6 is an example of a circuit forming a Grover's quantum gate in accordance with the prior art;

[0061] FIGS. 7 a and 7b illustrate the evolution of the Grover's quantum algorithm in accordance with the prior art;

[0062] FIG. 8 is a detailed view of entanglement and interference subsystems of the quantum gate in accordance with the present invention;

[0063] FIG. 9 is a detailed view of section I-a as shown in FIG. 8;

[0064] FIG. 10 is an embodiment of the section I-b as shown in FIG. 8;

[0065] FIG. 11 is an embodiment of an adder as shown section I-c of FIG. 8;

[0066] FIG. 12 is a detailed view of the digital section of the quantum gate in accordance with the present invention; and

[0067] FIG. 13 is one possible embodiment of the level shifters as shown in FIG. 12.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0068] The quantum gate of the invention is suitable for s fast running quantum algorithm applied over a set of input vectors, such as for example, decision making or data search routines based on the Deutsch-Jozsa's algorithm or the Grover's algorithm. It is composed of a superposition subsystem carrying out a linear superposition, an entanglement subsystem carrying out an entanglement operation, and an interference subsystem carrying out an interference operation according to the quantum algorithm to be implemented.

[0069] An essential feature of the quantum gate of the invention includes the fact that the entanglement subsystem does not multiply a superposition vector for the entanglement matrix UF, but generates components of an entanglement vector simply by copying or inverting respective components of the superposition vector depending on values of the function f(.).

[0070] This allows a relevant reduction of the number of multiplications with respect to known methods, and can be carried out using multiplexers. For the sake of simplicity, the hardware quantum gate of the invention will be described in reference to the Grover's quantum algorithm for n=3, though what will be discussed may be easily repeated for other quantum algorithms (in particular, the Deutsch and the Deutsch-Jozsa's algorithm) whose entanglement operation includes a permutation of components of a superposition vector.

[0071] A hardware quantum gate of the invention suitable for running the Grover's algorithm with any number of iterations is substantially composed of two parts. Part I: (analog) Calculation step-by-step of the output values. This part is divided in the following subsections: I-a: Entanglement; I-b and I-c: Interference. Part II: (digital) Entropy evaluation, storage of vectors for iterations and output display. This part provides also the first basis of vectors.

[0072] The analog part of this scheme for a three-qubits quantum gate is depicted in FIG. 8. A command circuit HB14 generates eight command signals Vc1, . . . Vc8 each representing a value of the function f(.) on a respective vector of the first basis. An array of multiplexers HB13 is input with voltage signals 011, . . . , 082 representing the sixteen components of a linear superposition vector and generates signals Vo1, . . . , Vo8 representing only the even or the odd components of an entanglement vector. Let us suppose that these signals represent the odd components of an entanglement vector.

[0073] Section I-a is present in every hardware quantum gate of the invention, irrespective of the quantum algorithm to be implemented. Each multiplexer, depicted in FIG. 9 is input with a pair of components (011 and 012 for example) that are referred to vectors of the second basis having the first (leftmost) 3 qubits in common (|0000> and |0001>), and generates a respective component (Vo1) which is equal to 011 if Vc1 represents a null value of function f(.) on vector |000>, or to 012 if Vc1 represents a non-null value.

[0074] Sections I-b and I-c depicted in FIG. 8 are specifically designed for Grover's quantum algorithms. The presence of tensor products in the interference operation, whose number increases dramatically with the dimensions, forms a critical point.

[0075] Sections I-b and I-c of FIG. 8 of the quantum gate allow the interference operation of Grover's quantum algorithm to be quickly carried out. It has been noticed that the matrix Dn⊕I has the following properties: odd columns (or rows, because Dn⊕I is symmetric) have non-zero odd components and even columns have non-zero even components. The value of all non-zero components, except for the ith component of ith column (diagonal elements), is ½n−1. The components on the up-left down-right diagonal of the matrix differ from the other non-zero components because they are decreased by 1. The variable G* in an entanglement vector, and the output vector of the quantum algorithm V=(Dn⊕I)G* involves only a suitable weighted sum of components of G*. The value ½n−1 depends only from the number n of qubits.

[0076] From the above analysis, the generic element vi of V can be written as follows as a function of components g*i of the entanglement vector G*: 14$\begin{array}{cc}{v}_i=\{\begin{array}{c}\frac{1}{2^{n-1}}\sum _{j=1}^{2^n}{g}_{2j-1}^{*}-g_i^{*}\mathrm{for}i\mathrm{odd}\\ \frac{1}{2^{n-1}}\sum _{j=1}^{2^n}{g}_{2j}^{*}-g_i^{*}\mathrm{for}i\mathrm{even}\end{array}& \left(16\right)\end{array}$

[0077] Therefore, to calculate a component vi of the output vector it is sufficient to calculate a weighted sum of even 15$\left(\frac{1}{2^{n-1}}\sum _{j=1}^{2^n}{g}_{2j}^{*}\right)$

[0078] or odd 16$\left(\frac{1}{2^{n-1}}\sum _{j=1}^{2^n}{g}_{2j-1}^{*}\right)$

[0079] components of the entanglement vector and to subtract from it the corresponding component g*i of the entanglement vector.

[0080] An adder HB25, depicted in greater detail in FIG. 10, sums these components with a certain scale factor that depends only on the number n of qubits (which is 0.25 for n=3), and generates a signal SQ representing the sum of the odd (or even) components of the entanglement vector. Finally, an array of adders I-c generates signals 01, . . . , 08 representing the odd (or even) components of an output vector by subtracting the signals Q1, . . . , Q8 from the scaled sum SQ.

[0081] A hardware quantum gate of the invention for carrying out a Deutsch-Jozsa's quantum algorithm does not have the sections I-b and I-c of FIG. 8 for performing the interference operation. In this case, the interference subsystem is substantially composed of an array of adders, each calculating a respective component 01, . . . , 08 of the output vector as a linear combination of components Vo1, . . . , Vo8 of a corresponding entanglement vector.

[0082] It is not necessary to calculate all components of the entanglement or output vectors, because the odd components of any vector are always opposite to the even components. For this reason entanglement and interference operations are carried out only on the odd or even components. The other components are calculated by inverting the first ones.

[0083] The adders of section I-c may be formed, for instance, as depicted in FIG. 11. A voltage of 2.5V is added to transpose the value inside the range [0÷5]V of A/D converters that interface with Part II (digital part).

[0084] To provide better performances, a different range of probability amplitudes is chosen. The presence of converters, whose range is [0÷5]V, suggests adoption of a range of [−2.5÷2.5] instead of [−1/{square root}{square root over (2)}÷1/{square root},{square root over (2)}]. This implies that the output is not normalized to 1 but to 2*2.52=12.5.

[0085] Because of the necessity of different types of operations (storing values, entropy evaluation and stopping iteration) for performing the Grover's algorithm, a microprocessor unit has been chosen as the core of Part II. For instance, an appropriate microprocessor unit may be the commercial device CPLD XC95288XL of STMicroelectronics, as depicted in FIG. 12.

[0086] An analog/digital converter, which may be for example the A/D converter ADC0808 of STMicroelectronics, receives signals representing components 01, . . . , 08 of the output vector and produces a corresponding binary string D1, . . . , D8. The microprocessor unit XC95288XL receives this string and calculates the Shannon entropy.

[0087] Summarizing, the microprocessor unit performs the following functions:

[0088] 1. Drives correctly the A/D converter.

[0089] 2. Acquires eight digital values and evaluates Shannon entropy S.

[0090] 3. Compares S with a fixed threshold.

[0091] 4. If S<threshold, stops iteration and sends the results to LED Matrix display; otherwise sends the results to a digital/analog converter.

[0092] 5. Provide initial condition of superposed basis vectors.

[0093] A display may also be connected to the CPLD to display the result. If Shannon entropy is not a minimum, the binary string has to be re-converted in an analog signal by a digital/analog converter for it to feedback into the entanglement subsystem I-a. In the preferred embodiment of FIG. 12, the digital/analog converter is the commercial device AD7228 of STMicroelectronics.

[0094] The level shifters HB3, . . . , HB10, which can be formed as depicted in FIG. 13, re-translate the values of IN1, . . . , IN8 into the range [−2.5÷2.5] and re-obtain all components from odd components. The iterations are carried out very fast, according to the CPLD frequency (20÷30 MHz). This fact suggests that very high performances could be reached even with a greater number of qubits, resulting in a very efficient search in a large database.

Claims

1. A quantum gate for running quantum algorithms using a certain binary function (f) defined on a space having a basis of vectors of n qubits, composed of a superposition subsystem carrying out a superposition operation over components of input vectors for generating components of linear superposition vectors referred on a second basis of vectors of n+1 qubits, an entanglement subsystem carrying out an entanglement operation over components of said linear superposition vectors for generating components of entanglement vectors, and an interference subsystem carrying out an interference operation over components of said entanglement vectors for generating components of output vectors, said entanglement subsystem comprising a command circuit (HB14) generating a number (2n) of logic command signals (Vc1, . . . , Vc8) encoding the values of said binary function (f) in correspondence of the vectors of the first basis; an array of multiplexers (I-a), each driven by a respective logic command signal (Vc1, . . . , Vc8) and input with a couple of signals (O11, O12; . . . ; O81, O82) representing components of a linear superposition vector that are referred to vectors of said second basis having the first n qubits in common, outputting, for each superposition vector (O11, . . . , O82), corresponding signals representing components of an entanglement vector (Vo1, . . . , Vo8), each component (Vo1, . . . , Vo8) referred to a respective vector of the second basis being equal to the corresponding component of the respective superposition vector, if said binary function (f) is null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis, or the opposite of the corresponding component of the respective superposition vector, if said binary function (f) is non null in correspondence of the vector of the first basis constituted by the first n qubits of said respective vector of the second basis.

2. The quantum gate of claim 1 for running a Grover's quantum algorithm, wherein said interference subsystem comprises an adder input with voltage signals representing even or odd components of an entanglement vector (Vo1, . . . , Vo8) and generating a sum signal (SQ) representing a weighed sum with a scale factor (½n−1) of said even or odd components; an array of adders each being input with a respective signal representing an even or odd component, respectively, of an entanglement vector (Vo1, . . . , Vo8) and with said sum signal (SQ), generating a signal representing an even or odd component, respectively, of output vector (O1, . . . , O8) as the difference between said sum signal (SQ) and said signal representing an even or odd component of an entanglement vector (Vo1, . . . , Vo8).

3. The quantum gate of claim 1 for running a Deutsch-Jozsa's quantum algorithm, wherein said interference subsystem comprises an array of adders each being input with signals representing even or odd components of an entanglement vector (Vo1, . . . , Vo8) and generating a signal representing a corresponding even or odd component, respectively, of output vector (O1, . . . , O8) as a linear combination of said signals representing even or odd components of an entanglement vector (Vo1, . . . , Vo8).

4. The quantum gate of claim 2, further comprising an elaboration subsystem having an analog/digital converter, input with said signals representing odd or even components of output vector (O1, . . . , O8) and converting them in a digital string (D1, . . . , D8); a microprocessor unit input with said digital string (D1, . . . , D8), that calculates a quantity to be minimized (S) associated to said components of output vector (O1, . . . , O8), compares said quantity to be minimized (S) with a certain threshold and stops the Grover's algorithm or commands another iteration whether it (S) is smaller than the threshold or not, respectively, outputs an output digital string representing components of output vector; a digital/analog converter input with said output digital string, generating output signals (IN1, . . . , IN8) corresponding to odd or even components of output vector; an array of level shifters, each input with a respective output signal (IN1, . . . , IN8), and generating a pair of voltage signals, in a certain voltage range, representing opposite components (O11, O12; . . . ; O81, O82) of a new superposition vector input to said entanglement subsystem.

5. The quantum gate of claim 4, wherein said analog/digital converter is the commercial device ADC0808; said microprocessor unit is the commercial device CPLD XC95288XL; said digital/analog converter is the commercial device AD7228; and each level shifter is composed of an adder that subtracts a certain voltage (V+) from a respective output signal (IN1, . . . , IN8) generating an odd component (O11, O21 . . . , O81) of said new superposition vector, and an inverter input with said odd component (O11, O21 . . . , O81) generating the corresponding even component (O12, O22 . . . , O82).

6. The quantum gate of claim 4, wherein said quantity to be minimized (S) is the Shannon entropy.