JP4260751B2 - Unitary matrix decomposition apparatus, unitary matrix decomposition method, unitary matrix decomposition program, and recording medium - Google Patents

Description

  The present invention relates to a unitary matrix decomposition apparatus, a unitary matrix decomposition method for decomposing an arbitrary unitary matrix into a smaller matrix, a unitary matrix decomposition program for realizing the function by a computer, and a recording medium storing the unitary matrix decomposition program .

Each operation in a quantum computer is represented by a unitary matrix, but in order to realize each operation represented by this unitary matrix with an actual quantum circuit, this unitary matrix must be decomposed into basic gates that can be realized. Don't be. A conventional unitary matrix decomposition method will be described below.
<Matrix Decomposition Method Using Cartan Decomposition (see Non-Patent Document 1)>
In this method, a 2 ^j × 2 ^j special unitary matrix G∈SU (2 ^j ) belonging to a Lie group is used as an input, and the unitary group decomposition framework using Cartan decomposition by Khaneja and Glaser (Non-patent Document 2) is used. Decompose unitary matrix. That is, the Lie algebra gεsu (2 ^j ) satisfying G = exp (g) is calculated from the input matrix, and then g is decomposed into two matrices k and m (g = k + m) by Cartan decomposition, and k And M = exp (k) and M = exp (m) are calculated to calculate G = K · M. Then, by repeating this recursively, the product is decomposed to a unitary matrix product having a small size (number of rows and columns). In order for the decomposed matrix to become a unitary matrix having a size smaller than that of the input matrix G, K and M must satisfy a predetermined condition. In this method, decomposition into K and M satisfying this condition is possible by using Cartan decomposition in Lie algebra.

<Cosine-Sine decomposition (see Non-Patent Documents 3 to 5)>
Cosine-Sine decomposition is a kind of singular value decomposition of a matrix (Non-patent Document 3). By applying this, a technique for decomposing a unitary matrix into a product of a matrix with a small dimension has been proposed (Non-Patent Documents 4 and 5).

First, the input matrix G is decomposed into four blocks of half size as follows.

If G is a 2 ^j × 2 ^j unitary matrix, A ₁ , A ₂ , C ₁ , S ₁ , B ₁ , B ₂ are 2 ^j-1 × 2 ^j-1 unitary matrices. Further, C ₁ and S ₁ are diagonal matrices of the following form.

Thereafter, similar decomposition is performed on A ₁ , A ₂ , B ₁ , B ₂ , and thereafter the same decomposition is repeated recursively until A _β , B _β becomes a 2 × 2 matrix.
When this Cosine-Sine decomposition is performed using an 8 × 8 matrix G as an example, the matrix G is decomposed into a matrix product having patterns as shown in FIG. In this figure, white squares represent components that are always 0 regardless of the input matrix, and colored squares represent components that have some value depending on the input matrix.
Hiromi Murakami, Yasuto Kawano, Hiroshi Sekikawa, Quantum circuit generation using Cartan decomposition, 10th Quantum Information Technology Study Group (QIT10), Proceedings pp.123-126, 2004. N. Khaneja and S. Glaser, Cartan decomposition of SU (2n), constructive controllability of spin systems and universal quantum computing, Chemical Physics, Vol. 267 (Issues 1-3), pp.11-23, 2001. C. Paige and M. Wei, History and generality of the CS decomposition, Linear Algebra and its Applications, pp.303-326, 1994. M. Mottonen, J. Vartiainen, Ville Bergholm, and M. Salomaa, Quantum circuits for general multi-qubit gates, quant-ph / 0404089. R. Tucci, “A Rudimentary Quantum Compiler,” [online], May 7, 1998, [searched December 28, 2004], Internet <http://jp.arxiv.org/abs/quant-ph/ 9805015>

However, in the case of a matrix decomposition method using Cartan decomposition, it is necessary to calculate an exponential function of a matrix and its inverse function, and there is a problem that the calculation cost is very high.
In the case of this method, in order for G = K · M to be decomposed in the decomposition process, the condition that k and m are commutative (k · m = m · k) must be satisfied. However, this property does not hold in general unitary matrices. For this reason, this method cannot be applied to the decomposition of an arbitrary unitary matrix.
In addition, if it is assumed to be mounted on an NMR (Nuclear Magnetic Resonance) quantum computer, the configuration advantage of the quantum computer can be sufficiently obtained, and as a result, the quantum computer can be operated at high speed (Khaneja− (Forms that meet the definition of Glaser decomposition) (M. Nakahara, Y. Kondo, K. Hata, and S. Tanimura, "Demonstrating quantum algorithm acceleration with NMR quantum computer," Internet <http: //jp.arxiv. org / abs / quant-ph / 0405050>). However, it is not easy to replace the decomposition result by Cosine-Sine decomposition with a configuration suitable for implementation of such an NMR quantum computer.

The present invention has been made in view of the above points, and is intended to cause a computer to execute a unitary matrix decomposition apparatus, a unitary matrix decomposition method, and a function thereof that can decompose an arbitrary unitary matrix into a small matrix at a low operation cost. It is an object to provide a unitary matrix decomposition program and a recording medium.
Another object of the present invention is to provide a unitary matrix decomposition apparatus, a unitary matrix decomposition method, and a unitary matrix decomposition for causing a computer to execute the function, which can easily replace the decomposition result with a configuration suitable for implementation of an NMR quantum computer. It is to provide a program and a recording medium.

In the present invention, in order to solve the above-described problem, first, for a unitary matrix G to be decomposed, G = K · M (product of unitary matrix K∈κ and matrix M∈μ) and X = M ² are set. A matrix X that satisfies is generated. Note that κ and μ mean a set that satisfies the following relationship.

Next, a matrix P for block diagonalizing the matrix X is generated, and a complex conjugate transpose matrix P ^* of the matrix P is generated. Then, a block diagonal matrix B is generated from the matrix X, the matrix P, and the complex conjugate transpose matrix P ^* by an operation of B = P ^* · X · P, and this block diagonal matrix B is converted into a block diagonal matrix of the matrix M. Convert to Y (= P ^* · M · P). The block diagonal matrix means a square matrix in which a 2 × 2 matrix is arranged in a diagonal component and the other elements are zero. Thereafter, a matrix M is generated from the block diagonal matrix Y, the matrix P, and the complex conjugate transpose matrix P ^* by an operation of M = P · Y · P ^* , and a complex conjugate transpose matrix M ^* of the matrix M is generated. A matrix K is generated from the matrix G and the complex conjugate transposed matrix M ^* by the operation of K = G · M ^* . Through the above processing, the matrix G is decomposed into a product (G = K · P · Y · P ^* ) of the matrix K, the matrix P, the block diagonal matrix Y, and the complex conjugate transpose matrix P ^* .

Here, each of these processes can be easily executed only by computation in the Lie group. That is, it is easy to obtain a matrix X satisfying G = K · M and X = M ² from G (described later). It is also easy to generate a matrix P for block diagonalizing the matrix X, generate a complex conjugate transpose matrix P ^* of the matrix P, and obtain a block diagonal matrix B = P ^* · X · P. . Further, the matrix P becomes a unitary matrix and satisfies P · P ^* = I (I is a unit matrix), and B = P ^* · X · P = P ^* · M ² · P = (P ^* · M · P) (P ^{Since **} M ^* P) = Y ² , the block diagonal matrix B can be regularly converted to the block diagonal matrix Y. Further, a matrix M is generated from the obtained block diagonal matrix Y, matrix P, and complex conjugate transpose matrix P ^* by an operation of M = P · Y · P ^* , and a complex conjugate transpose matrix M ^* of the matrix M is obtained. It is also easy to generate and generate the matrix K from the matrix G and the complex conjugate transposed matrix M ^* by the operation of K = G · M ^* .

Further, the product K ′ = K · P of the matrix K and the matrix P generated by the above processing and the complex conjugate transpose matrix P ^* can be decomposed into a matrix smaller in size than the matrix G. That is, in general, if ε, ζεκ or ε, ζεμ, the relationship of ε · ζεκ holds (property 1), so that the relationship X = M ² εκ also holds. Further, X = P · B · P ^* holds, but when X∈κ is satisfied, the relationship of P∈κ and P ^* ∈κ holds as in Non-Patent Document 2. Further, since Kεκ, the relationship of K ′ = K · Pεκ holds from Property 1. As described in Non-Patent Document 2, the matrix K ′, P ^* , which is an element of κ, has a checkered pattern of 0 elements that do not depend on each matrix and elements of some value that depends on each matrix. It becomes an arrayed matrix. Then, by regularly extracting this “element of some value depending on the matrix” from the matrix K ′, P ^* , it can be easily decomposed into a small matrix.

Further, since the matrix M is unitary and satisfies M ^* · M = I, the product of K = G · M ^* and M obtained by the above calculation is K · M = G · M ^* · M = G. This is true even if K and M are not commutative.
Furthermore, the block diagonal matrix Y generated by the above processing is a matrix in which 2 × 2 matrices are arranged diagonally. Such a matrix can be easily converted into a configuration suitable for mounting on an NMR quantum computer by using a conversion matrix W and its complex conjugate transpose matrix W ^* (described later).

As described above, according to the present invention, a unitary matrix can be decomposed into a small matrix only by Lie group operations. Therefore, it is not necessary to calculate the exponential function of the matrix and its inverse function unlike the conventional method using Cartan decomposition. As a result, in the present invention, the unitary matrix can be decomposed at a lower calculation cost than the conventional method using the Cartan decomposition.
Further, the present invention can be applied to a matrix G in which K and M are not commutative, and can be applied to decomposition of an arbitrary unitary matrix.
Furthermore, in the present invention, since the matrix G is decomposed so as to include the block diagonal matrix Y, a part of the decomposition result can be easily replaced with a configuration suitable for mounting an NMR quantum computer.

Hereinafter, the best mode for carrying out the present invention will be described.
[First Embodiment]
<Definition of symbols used>
First, symbols used in this embodiment are defined as follows.
i: Imaginary unit A *: Complex conjugate transposed matrix of matrix A I _s : Unit matrix of s × s 0 _s : Matrix with all components of s × s being 0 diag (a, b, c, d): Diagonal component Is a diagonal matrix in the order of a, b, c, d ∈: the norm of the set の ・ ‖: ・ of the set whose left side is the right side

<Hardware configuration>
FIG. 1 is a block diagram illustrating the configuration of a unitary matrix decomposition apparatus 100 according to this embodiment.
As illustrated in FIG. 1, a unitary matrix decomposition apparatus 100 of this example includes a CPU (Central Processing Unit) 110, an input unit 120, an output unit 130, an auxiliary storage device 140, a RAM (Random Access Memory) 150, and a ROM (Read Only memory) 160 and a bus 170.

  The CPU 110 in this example includes a control unit 111, a calculation unit 112, and a register 113, and executes various calculation processes in accordance with various programs read into the register 113. The input unit 120 is an input port for inputting data, a keyboard, a mouse, and the like. The output unit 130 is an output port for outputting data, a display, and the like. The auxiliary storage device 140 is, for example, a hard disk, an MO (Magneto-Optical disc), a semiconductor memory, or the like, and a unitary matrix decomposition program area 141 that stores a unitary matrix decomposition program for executing the unitary matrix decomposition processing of this embodiment. And a data area 142 for storing various data such as a unitary matrix G to be decomposed. The RAM 150 is an SRAM (Static Random Access Memory), a DRAM (Dynamic Random Access Memory), or the like. It has a data area 152 to be stored. The bus 170 connects the CPU 110, the input unit 120, the output unit 130, the auxiliary storage device 140, the RAM 150, and the ROM 160 so that they can communicate with each other.

<Software configuration>
FIG. 2 is a conceptual diagram illustrating the configuration of the unitary matrix decomposition program 200 stored in the unitary matrix decomposition program areas 141 and 151 of FIG.
As illustrated in FIG. 2, the unitary matrix decomposer 200 in this example, G = K · M (a product of a unitary matrix K∈κ and matrix M∈myu), to produce a matrix X satisfying X = M ² A matrix generation program 210 for generating the matrix P, a diagonalization matrix generation program 220 for generating a matrix P for block diagonalizing the matrix X, and a first complex for generating a complex conjugate transpose matrix P ^* of the matrix P A conjugate transposed matrix generation program 231; a first matrix product operation program 232 for generating a block diagonal matrix B by an operation of B = P ^* · X · P; and a block diagonal matrix B as a block pair of the matrix M A first block diagonal matrix conversion program 233 for converting into an angular matrix Y (= P ^* · M · P), and a second block for generating a matrix M by an operation of M = P · Y · P ^* . Matrix product operation program 2 4, a second complex conjugate transposed matrix generation program 235 for generating a complex conjugate transposed matrix of a matrix M M ^*, the third matrix multiplication for generating the matrix K by the operation of the K = G · M ^* The operation program 236, the second block diagonal matrix conversion program 237 for performing the operation of Y ′ = W · Y · W ^* for the conversion matrix W, and K ′ = K · P and P ^* are larger than those. A matrix decomposition program 238 for decomposing the matrix into a small matrix and a control program 239 for controlling the unitary matrix decomposition process.

Further, the matrix generation program 210 of this example includes a third complex conjugate transpose matrix generation program 211 for generating a complex conjugate transpose matrix G ^* of the matrix G, and X = σ _jz · G ^* · σ _jz · G A fourth matrix product calculation program 212 for generating a matrix X by calculation.
Further, the diagonalization matrix generation program 220 of this example includes an eigenvalue / eigenvector calculation program 221 for calculating eigenvalues and eigenvectors of the matrix X, and an eigenvector u _k (k is a natural number) whose corresponding eigenvalue is a positive imaginary number. ) to the eigenvectors _{u k} + sigma generates _jz · _{u k} an odd-th column element of the matrix P, eigenvectors _{u k -σ jz} · _u k first for generating the even-numbered columns of the elements of the matrix P Element generation program 222, and whether or not the corresponding eigenvector v _t (t is a natural number) corresponding to a real number satisfies σ _jz · v _t = v _t or σ _jz · v _t = −v _t , σ _jz · _v t = _v outputs eigenvector _{v t} that satisfies _t as odd-numbered column of the elements of the matrix P, σ _jz · _v t = even-numbered columns of eigenvectors satisfying the -v _{t v t} matrix P And outputs as an element, if not belonging to _{either, (v t + σ jz ·} v t) / ‖v t + σ jz · v t ‖ (|| · || denotes the norm) of the normalized vector, sigma _jz · v _{t ′} = v _{t ′} (t ′ ≠ t) that is linearly independent from the eigenvector vt _′ is output as an element of the odd-numbered column of the matrix P, and (v _t −σ _jz · v _t ) / ‖v _t -σ _jz · _{v t} ‖ of normalized vector, σ _jz · v _t satisfy _'= -v _t' eigenvector v _{t 'and} the linearly independent ones odd-numbered column of the matrix P a second element generator 223 for outputting as an element, and eigenvector _{v t} that satisfies an eigenvector _{u k} + _{σ jz} · _{u k} and σ _jz · _{v t} = _v t and odd-numbered columns of elements, the eigenvector _{u k} - specific vector to meet the σ _jz · _{u k} and σ _jz · _{v t} = -v t And a matrix configuration program 224 for generating a matrix P and Le v _t as an element of the even-numbered columns.

It should be noted that at least a part of the modules constituting each program may be shared with other programs.
<Cooperation between hardware and software>
The CPU 110 writes the unitary matrix decomposition program 200 stored in the unitary matrix decomposition program area 141 of the auxiliary storage device 140 in the unitary matrix decomposition program area 151 of the RAM 150 according to the read OS (Operating System) program. Similarly, the CPU 110 writes data such as a unitary matrix to be decomposed stored in the data area 142 of the auxiliary storage device 140 into the data area 152 of the RAM 150. The address on the RAM 150 where the unitary matrix decomposition program 200 and data are written is stored in the register 113 of the CPU 110. The control unit 111 of the CPU 110 sequentially reads these addresses stored in the register 113, reads a program and data from the area on the RAM 150 indicated by the read address, causes the calculation unit 112 to sequentially execute the operation indicated by the program, The calculation result is stored in the register 113.

FIG. 3 is a block diagram illustrating a functional configuration realized by reading the unitary matrix decomposition program 200 into the CPU 110 in this way. Note that the arrows in FIG. 3 indicate the data flow, but the arrows corresponding to the data flow in and out of the control unit 495 are omitted.
Here, the memory 300 corresponds to the register 113, the data area 152 of the RAM 150, the data area 142 of the auxiliary storage device 140, and the like. In addition, the matrix generation unit 400, the diagonalization matrix generation unit 410, the first complex conjugate transposed matrix generation unit 420, the first matrix product operation unit 430, the first block diagonal matrix conversion unit 440, the second matrix The product calculation unit 450, the second complex conjugate transposed matrix generation unit 460, the third matrix product calculation unit 470, the second block diagonal matrix conversion unit 480, the matrix decomposition unit 490, and the control unit 495 respectively generate a matrix. Program 210, diagonalization matrix generation program 220, first complex conjugate transposed matrix generation program 231, first matrix product operation program 232, first block diagonal matrix conversion program 233, second matrix product operation program 234 , Second complex conjugate transposed matrix generation program 235, third matrix product operation program 236, second block diagonal matrix conversion program 237, matrix decomposition program Arm 238 and the control program 239 and is formed by respectively read into CPU 110. Further, the third complex conjugate transposed matrix generation unit 401, the fourth matrix product calculation unit 402, the eigenvalue / eigenvector calculation unit 411, the first element generation unit 412, the second element generation unit 413, and the matrix configuration unit 414 A third complex conjugate transposed matrix generation program 211, a fourth matrix product operation program 212, an eigenvalue / eigenvector calculation program 221, a first element generation program 222, a second element generation program 223, and a matrix configuration program 224, Each is configured by being read by the CPU 110.

<Processing>
Next, processing of the unitary matrix decomposition apparatus 100 in this embodiment will be described.
FIG. 4 is a flowchart for explaining the entire processing of the unitary matrix decomposition apparatus 100 in this embodiment. First, the entire process will be described. The following processes are executed under the control of the control unit 495.
First, as preprocessing, the unitary matrix to be decomposed is stored in the memory 300 as an element of the list LG (step S11). Next, the matrix generation unit 400 (FIG. 3) reads from the memory 300 as a unitary matrix G to be decomposed, a matrix of four or more dimensions closest to the head of the list LG (step S12). Note that the size of the matrix G is 2 ^j × 2 ^j . Thereafter, the matrix G is decomposed into Y ′ and G1 to G4 matrices by the processing described below, and these are stored in the memory as elements of the lists LY and LG, respectively (step S13).

[Details of Step S13]
FIG. 5 is a flowchart for explaining details of step S13 in FIG. The details of step S13 in FIG. 4 will be described below with reference to FIG.
The unitary matrix G read from the memory 300 in step S12 is input to the matrix generation unit 400. Storing the matrix generator 400, G = K · M (a product of a unitary matrix K∈κ and matrix M∈μ), to generate a matrix X satisfying X = ^{M 2,} and outputs the matrix X in the memory 300 (Step S21). In this example, first, the matrix G is input to the third complex conjugate transposed matrix generation unit 401. Then, the third complex conjugate transposed matrix generation unit 401 generates the complex conjugate transposed matrix G ^*, and outputs the complex conjugate transposed matrix G ^* to the memory 300 for storage. Next, the fourth matrix product operation unit 402 reads the matrix G and the complex conjugate transpose matrix G ^* from the memory 300. The read matrix G and complex conjugate transpose matrix G ^* are input to the fourth matrix product operation unit 402, and the fourth matrix product operation unit 402 outputs X = σ _jz · G ^* · σ _jz · G.・ (2)
The matrix X is generated by the above operation, and this matrix X is output to the memory 300 and stored.

Incidentally, the calculation result of equation (2) is M ² is evident from the following.
X = σ _jz · G ^* · σ _jz · G
= Θ (G ^* ) ・ G (From the relationship of (1))
= Θ (M ^*・ K *) ・ K ・ M
= Θ (M ^* ) ・ θ (K *) ・ K ・ M
= M ・ K * ・ K ・ M (From the relationship of (1))
= M ² (K is a unitary matrix and K * · K is a unit matrix)
When the process of step S <b> 21 ends, the diagonalization matrix generation unit 410 next reads the matrix X from the memory 300. This matrix X is input to the diagonalization matrix generation unit 410, and the diagonalization matrix generation unit 410 generates a matrix P for block diagonalization of this matrix X, and outputs the generated matrix P to the memory 300. Store (step S22).

[Details of Step S22]
FIG. 6 is a flowchart for explaining details of step S22 in FIG. 7 is a flowchart for explaining details of step S42 in FIG. 6, and FIG. 8 is a flowchart for explaining details of step S43 in FIG.
First, the matrix X is input to the eigenvalue / eigenvector calculation unit 411, and its eigenvalue and eigenvector are calculated.
List E1 = [[imaginary eigenvalue, corresponding eigenvector], ...]
List E2 = [[real eigenvalue, corresponding eigenvector], ...]
The lists E1 and E2 are output to the memory 300 and stored (step S41). Note that the number of imaginary eigenvalues is im, and the number of real eigenvalues is re.

Next, the first element generation unit 412 reads the list E1 from the memory 300. The list E1 is input to the first element generation unit 412. The first element generation unit 412 calculates the eigenvector u _k + σ _jz · u _k for the positive eigenvector u _k (k is a natural number) in the list E1. generating an odd-th column element of the matrix P, generates eigenvectors _{u k -σ jz} · _u k as even-numbered columns of the elements of the matrix P, _jz · the eigenvector _{u k} + _{σ jz} · _{u k} and _u k - [sigma] and outputs to the memory 300 stores as a list E3 and u _k (step S42). In this example (Fig. 7), the first element generator 412 the list E1 is inputted, _first, a _c k = 0 (step S51), substitutes the calculation results for _c k +1 to _{c k} (step S52), still select one of the positive eigenvalues that are not examined from the list E1, and extracts the corresponding eigenvector _{u k} (step S53). The first element generator 412, relative to the eigenvector _{u k,}
E3 [2c _k −1] = u _k + σ _jz · u _k
E3 [2c _k ] = u _k -σ _jz · u _k
Are stored in the memory 300 as elements of the list E3 (step S54). Thereafter, the first element generation unit 412 in this example determines whether or not there is a positive eigenvalue that has not been checked in the list E1 of the memory 300, and if there is, returns to the processing in step S52 and subsequent steps. If not, the process of step S42 (FIG. 6) is terminated. In the case of the processing in this example, E3 represents a pair of eigenvectors corresponding to a pair of complex conjugate eigenvalues as [u ₁ + σ _jz · u ₁ , u ₁ -σ _jz · u ₁ ] [u ₂ + σ _jz · u _2. , U ₂ −σ _jz · u ₂ ]...

When the process of step S <b> 42 ends, the second element generation unit 413 next reads the list E <b> 2 from the memory 300. The list E2 is input to the second element generation unit 413. The second element generation unit 413 determines that the eigenvector v _t is σ _jz · v _t = with _{respect to} the eigenvector v _t (t is a natural number) in the list E2. It is determined whether or not v _t or σ _jz · v _t = −v _t is satisfied, and the eigenvector v _t satisfying σ _jz · v _t = v _t is set as an element of the odd-numbered column of the matrix P, and σ _jz · v _t The eigenvector v _t satisfying = −v _t is set as an element of the even-numbered column of the matrix P, and these are output to the memory 300 as a list E4 and stored (step S43). In this example, in this example (FIG. 8), the second element generation unit 413 to which the list E2 is input first sets c _n = 1 and c _q = 1 (step S61), and is still from the list E2. One eigenvector not checked is selected as v _t (step S62). Next, the second element generation unit 413 determines whether or not this v _t satisfies σ _jz · v _t = v _t (step S63), and if so, E4 [2c _n −1] = v _t Is stored in the memory 300 as an element of the list E4, and calculation of c _n = c _n +1 is performed (step S64). If not satisfied, whether or not this v _t satisfies σ _jz · v _t = −v _t is determined. Judgment is made (step S65). The second element generation unit 413 stores E4 [2c _n ] = v _t in the memory 300 as an element of the list E4 only when σ _jz · v _t = −v _t is satisfied, and c _q = c _q Calculation of +1 is performed (step S66). In addition, when it does not belong to either σ _jz · v _t = v _{t or} σ _jz · v _t = −v _t , the second element generation unit 413 determines that (v _t + σ _jz · v _t ) / ‖v _t + Σ _jz · v _t ‖ is calculated, stored in the memory 300 as an element E4 [2c _n −1] of the list E4, and an operation of c _n = c _n +1 is performed (step S67). In this case, the second element generation unit 413 calculates (v _t −σ _jz · v _t ) / ‖v _t −σ _jz · v _t ‖, which is calculated as an element E4 [2c _q ] of the list E4. Is stored in the memory 300 and c _q = c _q +1 is calculated (step S68). Next, the second element generation unit 413 deletes the linearly dependent element from the list E4 in the memory 300 (step S69).

Thereafter, the second element generation unit 413 determines whether there is an eigenvector that has not been checked yet in the list E3 of the memory 300 (step S70), and if there is, returns to the processing in step S62 and subsequent steps, and exists. If not, the process of step S43 (FIG. 6) is terminated.
When the process of step S43 is completed, the matrix construction unit 414 reads the lists E3 and E4 from the memory 300, takes out the eigenvectors included in the lists E3 and E4 in order from the top, and uses them as a column P = (V ₁ , _{V 2, ..., V im,} W 1, W 2, ..., to generate a _{W re) (V 1, V} 2, ..., element _.W 1 of _{V im} list _{E3, W 2, ..., W} re the The elements of the list E4) are stored in the memory 300 (step S44). This eigenvector _{u k} + sigma and eigenvector _{v t} satisfying _jz · _{u k} and σ _jz · _{v t} = _v t and odd-numbered columns of elements, the eigenvector _{u k -σ jz} · _u k and σ _jz · _v t = This corresponds to generating the matrix P using the eigenvectors v _t satisfying −v _t as elements of even-numbered columns (end of the description of [Details of Step S22]).

When the process of step S22 is completed (returning to FIG. 5), the first complex conjugate transposed matrix generation unit 420 reads the matrix P from the memory 300. The read matrix P is input to the first complex conjugate transpose matrix generation unit 420, and the first complex conjugate transpose matrix generation unit 420 generates a complex conjugate transpose matrix P ^* of the matrix P, and generates the generated complex The conjugate transpose matrix P ^* is output and stored in the memory 300 (step S23).
Next, the first matrix product operation unit 430 reads the matrix X, the matrix P, and the complex conjugate transpose matrix P ^* from the memory 300. These are input to the first matrix product operation unit 430. The first matrix product operation unit 430 generates a block diagonal matrix B by the operation of B = P ^* · X · P, and this block diagonal matrix B Is output and stored in the memory 300 (step S24).

The block diagonal matrix B stored in the memory 300 is read by the first block diagonal matrix conversion unit 440. The read block diagonal matrix B is input to the first block diagonal matrix conversion unit 440, and the first block diagonal matrix conversion unit 440 converts this into a block diagonal matrix Y (= P ^{*) of the} matrix M. (M · P), which is output to the memory 300 and stored (step S25). The conversion from the block diagonal matrix B to block diagonal matrix Y is, for example, a square matrix C aligned in the diagonal portion of the block diagonal matrix B, by replacing the square matrix D that satisfies C = D ² Do. That is, it can be said that the block diagonal matrix B is a block diagonal matrix in which a 2 × 2 matrix is arranged in a diagonal component and the other elements are zero. Further, as described above, the block diagonal matrix B and the block diagonal matrix Y are B = P ^* · X · P = P ^* · M ² · P = (P ^* · M · P) (P ^* · M · P) ) = Y ² is satisfied. Therefore, the conversion from the block diagonal matrix B to the block diagonal matrix Y is performed only by replacing the square matrix C arranged in the diagonal portion of the block diagonal matrix B with the square matrix D (C = D ² is satisfied). Is possible. Thereby, the conversion from the block diagonal matrix B to the block diagonal matrix Y can be performed at a low calculation cost. As the square matrices C and D used for this replacement, the following can be exemplified.

In the equations (3) to (6), θ is a value determined by the components of the block diagonal matrix B. For example, when B = diag (−1, −1, −1, −1,1,1,1,1), square matrices C and D with θ = π and square matrices C and D with θ = 0. This replacement is done.
Also, a set of a plurality of types of square matrices C and D may be used for the conversion from one block diagonal matrix B to the block diagonal matrix Y. For example, by mixing the replacement of C in Equation (3) with D in Equation (4) and the replacement of C in Equation (3) with D in Equation (5), a block diagonal matrix B can be used as a block. Conversion to the diagonal matrix Y may be performed.

Further, here, an example in which replacement is performed by 2 × 2 square matrices C and D is shown, but block diagonal matrix B using 2 ^γ × 2 ^γ (γ is a natural number of 2 or more) square matrices C and D. To block diagonal matrix Y may be performed. For example, in the case of decomposition of a unitary matrix indicating a quantum Fourier transform, a block diagonal matrix B including a block of diag (1, -1, -1, 1) in a diagonal portion (for example, B = diag (1, -1, -1,1,1, -1, -1,1)),

It is desirable to perform conversion from the block diagonal matrix B to the block diagonal matrix Y. This square matrix D is

This is because it is known that such a square matrix D can be realized by a simple quantum circuit.
However, in general, the square matrices C and D are desirably 2 × 2 matrices. That is, the imaginary eigenvalue generated in step S41 of FIG. 6 is always a complex conjugate pair, and the number of elements (im) corresponding to the imaginary eigenvalue of the matrix P is a multiple of 2, but this is 2 ^γ (γ is It is not necessarily a multiple of 2). Therefore, the number of elements corresponding to the eigenvalues of the imaginary block diagonal matrix B are Block Diagonalization by a matrix P also becomes a multiple of two, this is not necessarily a multiple of 2 ^gamma. This is the number of elements corresponding to the eigenvalues of the real also becomes a multiple of two, which means that this is not necessarily a multiple of 2 ^gamma. Therefore, if the block diagonal matrix B is replaced with 2 ^γ × 2 ^γ square matrices C and D, there may be a replacement remaining in the element corresponding to the imaginary eigenvalue and the element corresponding to the real eigenvalue. In this case, square matrices C and D having different sizes for replacing the remaining replacement part are required, and the process becomes complicated. Therefore, when the number of elements corresponding to the imaginary eigenvalues of the block diagonal matrix B and the number of elements corresponding to the real eigenvalues are not clear, the square matrices C and D are desirably 2 × 2 matrices.

When the process of step S25 ends, the second matrix product operation unit 450 then reads the block diagonal matrix Y, the matrix P, and the complex conjugate transpose matrix P ^* from the memory 300. The second matrix product operation unit 450 to which these are input generates a matrix M by an operation of M = P · Y · P ^* , and outputs the matrix M to the memory 300 for storage (step S26).
Next, the second complex conjugate transposed matrix generation unit 460 reads the matrix M from the memory 300. The second complex conjugate transposed matrix generation unit 460 to which the matrix M is input generates a complex conjugate transposed matrix M ^* of the matrix M, and outputs and stores the complex conjugate transposed matrix M ^* in the memory 300 ( Step S27).

Next, the third matrix product operation unit 470 reads the matrix G and the complex conjugate transpose matrix M ^* from the memory 300. These are input to the third matrix product operation unit 470. The third matrix product operation unit 470 generates a matrix K by the operation of K = G · M ^* , and outputs this matrix K to the memory 300 for storage. (Step S28).
Next, the second block diagonal matrix converter 480 reads the block diagonal matrix Y from the memory. The block diagonal matrix Y is input to the second block diagonal matrix converter 480, and the second block diagonal matrix converter 480
Y '= W ・ Y ・ W ^*・ ・ ・ (7)

The matrix Y 'is output to the memory 300 and stored as elements of the list LY (step S29). Note that the transformation matrix W indicated by Equation (8) does not depend on the value of the block diagonal matrix Y. Therefore, the block diagonal matrix Y can be converted into the matrix Y ′ at a low calculation cost. This matrix Y ′ conforms to the definition of the Khaneja-Glaser decomposition, and has a configuration suitable for implementation of an NMR quantum computer (M. Nakahara, Y. kondo, K. Hata, and S. Tanimura, “Demonstrating”). quantum algorithm acceleration with NMR quantum computer, "Internet <http://jp.arxiv.org/abs/quant-ph/0405050>).

Through the processing so far, the matrix G has been decomposed into K, P, Y ′, and P ^* matrices. Here, as described above, K, P, and P ^* are elements of the set κ. The product K ′ = K · P is also an element of the set κ. Thus, it can be seen that the matrix G can be decomposed into products of K′εκ, Yεκ ′, and P ^* εκ. FIG. 9A is a conceptual diagram of a matrix showing this (example of j = 3). In this figure, a blank square indicates an element of 0 in the matrix, and a colored square indicates an element of some value. As shown in this figure, the arbitrary matrix G can be decomposed into Y ′ suitable for implementation of the NMR quantum computer and checkered matrix K ′, P ^* .

Therefore, next, the matrix decomposition unit 490 reads the matrices K and P from the memory 300, regularly extracts the elements of K ′ = K · P, and converts the matrix K ′ into a 2 ^j−1 × 2 ^j−1 matrix G1. And G2 are output to the memory 300 and stored as elements of the list LG (step S30). FIG. 9B is a conceptual diagram showing this decomposition in the matrix K ′ (example of j = 3), and FIG. 9C is a diagram showing a quantum circuit corresponding to the decomposition result. As shown in this figure, the matrix K ′ = G1 ′ · G2 ′ can be easily decomposed into smaller matrices G1 and G2.

Similarly, the matrix decomposition unit 490 reads the complex conjugate transpose matrix P ^* from the memory 300, regularly extracts its elements, and converts this element into the product of 2 ^j−1 × 2 ^j−1 matrices G3 and G4. These are disassembled, output to the memory 300, and stored as elements of the list LG (step S31) (end of [details of step S13]).
When the process of step S13 is completed (returning to FIG. 4), the control unit 495 searches the list LG stored in the memory 300, and determines whether or not the list LG includes a matrix that has not been checked (step LG). S14). Here, if it is determined that the list LG includes a matrix that has not been examined, the control unit 495 returns the process to step S12. On the other hand, when it is determined that there is no unexamined matrix in the list LG, the control unit 495 ends the process. As a result, the process of using the above-described matrices G1, G2, G3, and G4 as the matrix G is recursively repeated and finally decomposed into a matrix that indicates a two-dimensional basic gate.

<Example>
Next, an example in the case of decomposing a unitary matrix indicating a quantum Fourier transform of 3 qubits will be described.
The 8 × 8 matrix G of the list LG is set as the division target (step 12). Here, since the matrix G is a unitary matrix indicating a quantum Fourier transform of 3 qubits, if the (h, k) component of G is written as G [h, k]

It becomes.

Next, X = σ _3z · G ^* · σ _3z · G is calculated (step S21). Here, σ _3z = diag (1, −1, 1, −1, 1, −1, 1, −1), so
d ₁ = diag (1, -1,1, -1,)
It becomes.

When X is diagonalized to obtain eigenvalues and eigenvectors and a matrix P is constructed (steps S22, S41 to S44, S51 to S55, S61 to S67),
It becomes.

Next, when B = P · X · P ^* is calculated (step S24),
B = diag (-1, -1, -1, -1,1,1,1,1,)
It becomes.

Next, Y is obtained by rewriting the 2 × 2 block in the diagonal portion of B according to the equations (3) and (4) (step S25). In the case of this example, rewriting by the equations (3) and (4) is
It becomes.

Next, when M = P · Y · P ^* is calculated (step S26),
It becomes.

Next, when K = G · M ^* is calculated (step S28),
It becomes.

Next, Y is converted into Y ′ = W · Y · W ^* (step S29).
Next, when K ′ = K · P is calculated,
It becomes. And as shown in FIG.
K '= G1' ・ G2 '

And the elements of the colored portion are extracted from G1 'and G2' as shown in FIG. 9B, and 4 × 4 unitary matrices G1, G2 are extracted.

(Step S30).

Next, let P ^{* be the same} as in FIG.

And the elements of the colored portion are extracted from G3 'and G4' as shown in FIG. 9B, and 4 × 4 unitary matrices G3, G4 are extracted.

Configure.
Thereafter, G1 to G4 are set as G, and the processes after step S12 are performed.

[Second Embodiment]
Next, a second embodiment of the present invention will be described.
This embodiment is a modification of the first embodiment. Instead of converting the block diagonal matrix Y into the matrix Y ′ in the first embodiment, the block diagonal matrix Y is decomposed into a matrix indicating a basic gate as it is. Only the difference is from the first embodiment. Below, it demonstrates centering on difference with 1st Embodiment, and abbreviate | omits description about the matter which is common in 1st Embodiment.

<Hardware configuration>
This is the same as in the first embodiment.
<Software configuration>
FIG. 10 is a conceptual diagram illustrating the configuration of the unitary matrix decomposition program 600 of this embodiment. The difference between the unitary matrix decomposition program 600 of the present embodiment and the unitary matrix decomposition program 200 of the first embodiment is that the unitary matrix decomposition program 600 is replaced with the second block diagonal matrix conversion program 237 (FIG. 2). This is a point having a block diagonal matrix decomposition program 637.

<Cooperation between hardware and software>
FIG. 11 is a block diagram illustrating a functional configuration realized by reading the unitary matrix decomposition program 600 into the CPU. The difference from the first embodiment is that a block diagonal matrix decomposition unit 680 is configured instead of the second block diagonal matrix conversion unit (FIG. 3).
<Processing>
The difference from the first embodiment is only the process of step S29 in FIG. That is, in this embodiment, instead of the process of step S29, the block diagonal matrix Y is directly decomposed into a matrix indicating a 2 × 2 basic gate.

FIG. 12 is a conceptual diagram for explaining this processing (example of j = 3).
As shown in this figure, the matrix G is decomposed into K ′ = K · P, a block diagonal matrix Y and a complex conjugate transpose matrix P ^* (FIG. 12A), and the block diagonal matrix Y is converted to FIG. ) As shown in (c), it is decomposed into 2 × 2 matrices U _{1 to} U ₄ . For generalization of this decomposition, see, for example, “Kanezaka Uesaka, Corona Publishing,“ Basic Mathematics of Quantum Computers ”, ISBN 4-339-02376-0”.
It should be noted that the present invention is not limited to the above-described embodiments, and other modifications can be made as appropriate without departing from the spirit of the present invention. In addition, the various processes described above are not only executed in time series according to the description, but may be executed in parallel or individually according to the processing capability of the apparatus that executes the processes or as necessary.

  The unitary matrix separation programs 200 and 600 described above can be recorded on a computer-readable recording medium. The computer-readable recording medium may be any medium such as a magnetic recording device, an optical disk, a magneto-optical recording medium, or a semiconductor memory. Specifically, for example, the magnetic recording device may be a hard disk device or a flexible Discs, magnetic tapes, etc. as optical discs, DVD (Digital Versatile Disc), DVD-RAM (Random Access Memory), CD-ROM (Compact Disc Read Only Memory), CD-R (Recordable) / RW (ReWritable), etc. As the magneto-optical recording medium, MO (Magneto-Optical disc) or the like can be used, and as the semiconductor memory, EEP-ROM (Electronically Erasable and Programmable-Read Only Memory) or the like can be used.

The program is distributed by selling, transferring, or lending a portable recording medium such as a DVD or CD-ROM in which the program is recorded. Furthermore, the program may be distributed by storing the program in a storage device of the server computer and transferring the program from the server computer to another computer via a network.
As an execution form different from the above-described embodiment, the computer may read the program directly from the portable recording medium and execute processing according to the program. Each time is transferred, the processing according to the received program may be executed sequentially. Also, the program is not transferred from the server computer to the computer, and the above-described processing is executed by a so-called ASP (Application Service Provider) type service that realizes the processing function only by the execution instruction and result acquisition. It is good. Note that the program in this embodiment includes information that is used for processing by an electronic computer and that conforms to the program (data that is not a direct command to the computer but has a property that defines the processing of the computer).

  In this embodiment, the present apparatus is configured by executing a predetermined program on a computer. However, at least a part of these processing contents may be realized by hardware.

  As an industrial application field of the present invention, a design support field of an arbitrary unitary transformation quantum circuit constituting a quantum computer can be exemplified. By applying the present invention, an arbitrary unitary transformation quantum circuit can be easily decomposed into basic gates such as CNOT.

The block diagram which illustrated the composition of the unitary matrix decomposition device in a 1st embodiment. The conceptual diagram which illustrated the structure of the unitary matrix decomposition | disassembly program. The block diagram which illustrated the functional composition realized when a unitary matrix decomposition program is read by CPU. The flowchart for demonstrating the whole process of the unitary matrix decomposition | disassembly apparatus in 1st Embodiment. The flowchart for demonstrating the detail of step S12 in FIG. 6 is a flowchart for explaining details of step S22 in FIG. The flowchart for demonstrating the detail of step S42 in FIG. The flowchart for demonstrating the detail of step S43 in FIG. (A) is the conceptual diagram which showed a mode that the matrix G was decomposed | disassembled into the product of K'εκ, Yεκ ', and P ^* εκ. (B) is a conceptual diagram showing the decomposition of the matrix K ′ (example of j = 3). (C) is the figure which showed the quantum circuit corresponding to the decomposition | disassembly result. The conceptual diagram which illustrated the structure of the unitary matrix decomposition | disassembly program of 2nd Embodiment. The block diagram which illustrated the functional composition realized when a unitary matrix decomposition program is read by CPU. The conceptual diagram for demonstrating decomposition | disassembly of the block diagonal matrix Y in 2nd Embodiment. The conceptual diagram for demonstrating Cosine-Sine decomposition | disassembly.

Explanation of symbols

100 unitary matrix decomposition apparatus 200,600 unitary matrix decomposition program

Claims (9)

A unitary matrix decomposition apparatus that decomposes a unitary matrix,
Unitary matrix G is input, G = K · M (a product of a unitary matrix K∈κ and matrix M∈μ), matrix generation means for generating a matrix X satisfying X = M ^2, and outputs the matrix X When,
A diagonalization matrix generating means for receiving the matrix X, generating a matrix P for block diagonalizing the matrix X, and outputting the matrix P;
The matrix P is inputted, a first complex conjugate transposed matrix generating means for generating a complex conjugate transpose matrix P ^* of the matrix P, and outputs the complex conjugate transpose matrix P ^*,
The matrix X, the matrix P, and the complex conjugate transpose matrix P ^* are input, a block diagonal matrix B is generated by an operation of B = P ^* · X · P, and the block diagonal matrix B is output. 1 matrix product computing means;
The block diagonal matrix B is input , and the square matrix C arranged in the diagonal portion of the block diagonal matrix B is replaced with a square matrix D satisfying C = D ^2, thereby obtaining the block diagonal matrix B, First block diagonal matrix conversion means for converting the matrix M into a block diagonal matrix Y (= P ^* · M · P) and outputting the block diagonal matrix Y;
The block diagonal matrix Y, the matrix P, and the complex conjugate transpose matrix P ^* are input, the matrix M is generated by the operation of M = P · Y · P ^* , and the matrix M is output. Product operation means;
The matrix M is entered, a second complex conjugate transposed matrix generating means for generating a complex conjugate transposed matrix M ^* of the matrix M, and outputs the complex conjugate transposed matrix M ^*,
Third matrix product operation means for inputting the matrix G and the complex conjugate transpose matrix M ^* , generating a matrix K by calculating K = G · M ^* , and outputting the matrix K;
A unitary matrix decomposition apparatus. The unitary matrix decomposition apparatus according to claim 1,
The block diagonal matrix Y is input, the matrix representing the control NOT operation and U _CNOT, a matrix representing the Wal Schur Hadamard transform and H, the matrix of the r × r and I _r, the block diagonal matrix Y ^Let 2 ^j × 2 ^j matrix,

And second block diagonal matrix conversion means for calculating Y ′ = W · Y · W ^* and outputting the matrix Y ′ when W ^* is a complex conjugate transposed matrix of the matrix W,
A unitary matrix decomposition apparatus further comprising: The unitary matrix decomposition apparatus according to claim 1,
The matrix generation means is
The matrix G is input, and a third complex conjugate transposed matrix generating means for the complex to produce a conjugate transposed matrix G ^*, and outputs the complex conjugate transposed matrix G ^*,
The matrix G and the complex conjugate transpose matrix G ^* are input,

X = σ _jz · G ^* · σ _jz · G
A fourth matrix product calculating means for generating the matrix X by the calculation of and outputting the matrix X;
A means having
A unitary matrix decomposition apparatus. The unitary matrix decomposition apparatus according to claim 1,
The diagonalization matrix generating means is
Eigenvalue / eigenvector calculating means for inputting the matrix X, calculating its eigenvalue and eigenvector, and outputting the eigenvalue and eigenvector;
Of the eigenvectors calculated by the eigenvalue / eigenvector calculating means, the eigenvector u _k (k is a natural number) whose corresponding eigenvalue is a positive imaginary number,

In case of a, the eigenvector _{u k} + _{σ jz} · _{u k} generated as odd-numbered column of the elements of the matrix P, generates eigenvectors _{u k -σ jz} · _u k as even-numbered columns of the elements of the matrix P, a first element generating means for outputting the eigenvector _{u k} + _{σ jz} · _{u k} and _{u k -σ jz} · _u k,
Of the eigenvectors calculated by the eigenvalue / eigenvector calculation means, for the eigenvector v _t (t is a natural number) whose corresponding eigenvalue is a real number, the eigenvector v _t is σ _jz · v _t = v _t or σ _jz · v _It is determined whether or not _t = −v _t is satisfied, and an eigenvector v _t satisfying σ _jz · v _t = v _t is output as an element of the odd-numbered column of the matrix P, and σ _jz · v _t = −v _t outputs eigenvector _{v t} as even-numbered columns of the elements of the matrix P satisfying, if not belonging to _{either, (v t + σ jz ·} v t) / ‖v t + σ jz · v t ‖ (|| · || Is an element in the odd-numbered column of the matrix P, which is linearly independent of the eigenvector v _{t ′} satisfying σ _jz · v _{t ′} = v _{t ′} (t ′ ≠ t) and output as, _(v t -σ _{jz v t) / ‖v t -σ jz} · v t ‖ of normalized vector, σ _jz · v _t eigenvectors satisfy _'= -v _t' v _{t 'odd} linearly independent ones of the matrix P Second element generating means for outputting as an element of the column;
The eigenvector _{u k} ± _{σ jz} · _{u k} and _{v t} is inputted, the eigenvector _{v t} satisfying the eigenvector _{u k} + _{σ jz} · _{u k} and σ _jz · _{v t} = _v t and odd-numbered columns of elements, the the eigenvector _{v t} that satisfies an eigenvector _{u k -σ jz} · _u k and σ _jz · _{v t} = -v t to generate the matrix P as an element of the even columns, the matrix configuration means for outputting the matrix P,
A means having
A unitary matrix decomposition apparatus. The unitary matrix decomposition apparatus according to claim 4, wherein
The matrix construction means is
The eigenvector _{u k} + _{σ jz} · _{u k} and 2.alpha _k -1 column element (alpha _k is a natural number), and generates the matrix P the eigenvector _{u k -σ jz} · _u k as an element of 2.alpha _k-th column Means,
A unitary matrix decomposition apparatus. The unitary matrix decomposition apparatus according to claim 5,
The square matrices C and D are 2 × 2 matrices,
A unitary matrix decomposition apparatus. The computer includes a matrix generation unit, a diagonalization matrix generation unit, a first complex conjugate transpose matrix generation unit, a first matrix product calculation unit, a first block diagonal matrix conversion unit, a second A unitary matrix decomposition method that is executed by functioning as a unitary matrix decomposition apparatus having matrix product operation means, second complex conjugate transposed matrix generation means, and third matrix product operation means ,
Matrix generation means, on the input unitary matrix G, G = K · M (a product of a unitary matrix K∈κ and matrix M∈myu), to generate a matrix X satisfying X = M ^2, the matrix A procedure for outputting X,
A procedure for generating a matrix P for diagonalizing the matrix X output by the matrix generating means and outputting the matrix P;
And procedures first complex conjugate transposed matrix generation means, wherein the pair generates a keratinization matrix generating means complex conjugate transposed matrix of the matrix P was output P ^*, and outputs the complex conjugate transpose matrix P ^*,
The first matrix product calculating means outputs the matrix X output from the matrix generating means, the matrix P output from the diagonalized matrix generating means, and the above-mentioned output from the first complex conjugate transposed matrix generating means. A block diagonal matrix B is generated by calculating B = P ^* · X · P using a complex conjugate transpose matrix P ^* and outputting the block diagonal matrix B;
The first block diagonal matrix converting means converts the square matrix C arranged in the diagonal portion of the block diagonal matrix B output from the first matrix product calculating means into a square matrix D satisfying C = D ^2. By replacing the block diagonal matrix B with the block diagonal matrix Y (= P ^* · M · P) of the matrix M and outputting the block diagonal matrix Y;
The second matrix product calculating means is configured to output the block diagonal matrix Y output from the first block diagonal matrix converting means, the matrix P output from the diagonalization matrix generating means , and the first complex A procedure for generating a matrix M by performing an operation of M = P · Y · P ^{* on} the complex conjugate transposed matrix P ^* output by the conjugate transposed matrix generating means, and outputting the matrix M;
And procedures second complex conjugate transposed matrix generation means, said second matrix to produce a product operation means complex conjugate transposed matrix of the matrix M which output is M ^*, and outputs the complex conjugate transposed matrix M ^*,
The third matrix product calculating means calculates K = G · M ^{* for} the input matrix G and the complex conjugate transposed matrix M ^* output by the second complex conjugate transposed matrix generating means. To generate a matrix K and output the matrix K;
A unitary matrix decomposition method characterized by comprising: Unitary matrix decomposition program for causing a computer to function as a unitary matrix decomposition apparatus according to any one of claims 1 to 6. A computer-readable recording medium storing the unitary matrix decomposition program according to claim 8 .