JP4260725B2 - Eigenvalue calculation device, eigenvalue calculation method, eigenvalue calculation program, and recording medium - Google Patents

Description

  The present invention relates to an eigenvalue calculation apparatus, eigenvalue calculation method, eigenvalue calculation program, and recording medium for calculating an eigenvalue, and more particularly to an eigenvalue calculation apparatus, eigenvalue calculation method, eigenvalue calculation program, and recording medium for calculating an eigenvalue of a unitary matrix.

<Definition of symbols used>
In this specification, it represents a transposed matrix of the matrix A in ^{t A,} representing each conjugate transpose matrix is a matrix obtained by replacing in complex conjugate of all elements of the transposed matrix (also referred to as adjoint matrix) with A ^*. At this time, the Hermite matrix (a symmetric matrix when A is a real matrix) is a matrix where A = A ^* , and the unitary matrix is a matrix where AA ^* = I (provided that I represents a unit matrix).
<Background of the present invention>
The easiest matrix to handle in eigenvalue calculation is the Hermitian matrix. That is, if the Hermitian matrix of interest is converted into a tridiagonal matrix (tridiagonal Hermitian matrix) using the Householder transform, Lanczos method, etc., and its QR method or Sturm method is applied to it, its eigenvalue can be obtained. (For example, refer nonpatent literatures 1 and 2.).

On the other hand, the following method is generally used to calculate the eigenvalues of a general square matrix A. That is, the target square matrix A is transformed into a convenient intermediate form A ′ = U ^* AU (U is a unitary matrix) by unitary similarity transformation that can be realized by a finite number of operations, and the QR method or the like is converted to the intermediate form A ′. The eigenvalue is obtained by applying the iterative calculation (see, for example, Non-Patent Documents 1 and 2). This method is based on the fact that the intermediate form A ′ converges to the upper triangular matrix by iterative calculation such as the QR method, and correct eigenvalues can be calculated as long as this premise is maintained.
Masatake Mori, Masaaki Sugihara, Kazuo Murota, "Iwanami Lecture Applied Mathematics Linear Calculation", Iwanami Shoten, 1994. F. Chatlan, Masao Iri, Mitsuyoshi Inori, “Eigenvalues of Matrix”, Springer Fairlake Tokyo, 1993.

However, when a plurality of eigenvalues possessed by the square matrix A have equal absolute values, the method for obtaining the eigenvalues by applying iterative calculation to the above-described intermediate form A ′ = U ^* AU is not used. The correct eigenvalue may not be obtained. That is, as described above, this eigenvalue calculation method is based on the fact that the intermediate form A ′ converges to the upper triangular matrix by iterative calculation. However, when the square matrix A has a plurality of eigenvalues having the same absolute value, the intermediate form A ′ may not converge to the upper triangular matrix by this iterative calculation, and as a result, a correct eigenvalue may not be obtained. Come.

Here, the absolute values of the eigenvalues of the unitary matrix are all 1. For this reason, when the above-described method is applied to a unitary matrix, a correct eigenvalue may not be calculated.
The present invention has been made in view of such a point, and an object thereof is to provide a technique capable of easily calculating a correct eigenvalue of a unitary matrix.

In the present invention, in order to solve the above problem, first, a Hermitian matrix that is the sum of the input unitary matrix and its conjugate transpose matrix is calculated. Then, the eigenvalue of this Hermite matrix is calculated, the eigenvalue of this Hermite matrix is multiplied by a constant, and the calculation result is output.
Here, as described above, it is easy to calculate the eigenvalues of the Hermitian matrix. In addition, by applying this procedure to the unitary matrix U that is an eigenvalue calculation target or a unitary matrix generated therefrom, information for specifying the real part, the imaginary part, and the degree of overlap of the eigenvalues of the unitary matrix U can be obtained. . For example, when the above procedure is applied to the unitary matrix U that is an eigenvalue calculation target, the output specifies the real part of the eigenvalue of the unitary matrix U and the degree of overlap. Further, when the above procedure is applied to the unitary matrix i · U (i is an imaginary unit), the output specifies the imaginary part of the eigenvalue of the unitary matrix U and its redundancy. When the above procedure is applied to the unitary matrix i · U ² , the output specifies the product of the real part and the imaginary part of the eigenvalue of the unitary matrix U and the degree of overlap. Note that the degree of overlap means the number of overlapping solutions. For example, if the calculated value is 0.2, 0.2, 0.2, 0.4, 0.5, 0.5, and 0.7, the overlap of the value “0.2” is 3. , “0.5” has a degree of overlap of 2.

  In this way, information for specifying the real part, the imaginary part, and the degree of overlap of the eigenvalues of the unitary matrix U can be obtained by the above-described procedure, whereby the eigenvalues of the unitary matrix U can be specified.

  As described above, according to the present invention, the eigenvalue of the Hermitian matrix that is easy to calculate is used to calculate the eigenvalue of the unitary matrix, so that the correct eigenvalue of the unitary matrix can be easily calculated.

Hereinafter, embodiments of the present invention will be described with reference to the drawings.
[First Embodiment]
First, a first embodiment of the present invention will be described.
<Principle>
First, the principle of this embodiment will be described.
FIG. 1 is a block diagram showing a basic configuration of an eigenvalue calculation apparatus 10 of the present embodiment.
As illustrated in FIG. 1, the eigenvalue calculation apparatus 10 of this embodiment includes a Hermitian matrix calculation unit 11, a Hermite matrix eigenvalue calculation unit 12, and a list generation unit 13.

  First, a unitary matrix is input to the Hermitian matrix calculator 11, and the Hermitian matrix calculator 11 calculates and outputs a Hermitian matrix that is the sum of the unitary matrix and its conjugate transpose matrix. Next, this Hermite matrix is input to the Hermite matrix eigenvalue calculation unit 12, and the Hermite matrix eigenvalue calculation unit 12 calculates and outputs the eigenvalue of the Hermite matrix. Then, the eigenvalue of the Hermitian matrix is input to the list generation unit 13, and the list generation unit 13 multiplies the eigenvalue of the Hermitian matrix by a constant using the eigenvalue of the Hermite matrix and outputs the calculation result.

Next, this basic configuration will be described by applying it to the calculation of the eigenvalues of the unitary matrix. In the following, a unitary matrix for obtaining an eigenvalue is an n-by-n unitary matrix U. In this case, U + U ^* is a Hermitian matrix.
[When U is real]
First, the case where the unitary matrix U is real will be described. In this case, U is an orthogonal matrix, U ^* = ^tU , and V = U + U ^* is a real symmetric matrix.
First, a unitary matrix U is input to the Hermitian matrix calculator 11, and the Hermitian matrix calculator 11 calculates a Hermitian matrix V = U + U ^* that is the sum of the unitary matrix U and its conjugate transpose matrix U ^*, and outputs it. To do. Next, the Hermitian matrix V = U + U ^* is input to the Hermitian matrix eigenvalue calculating section 12, and the Hermitian matrix eigenvalue calculating section 12 applies a known routine for obtaining the eigenvalue of the real symmetric matrix to the Hermitian matrix V = U + U ^*. Eigenvalues of the Hermitian matrix V = U + U ^* . Here, for the unitary matrix U is the conjugate transpose matrix U ^* and commutative, the sum of the eigenvalues and the conjugate transpose matrix U ^* of the eigenvalues of the unitary matrix U is equal to the Hermitian matrix V = U + U ^* eigenvalues. In addition, the eigenvalue of the unitary matrix U (for example, α = a + i · b) replaced with a conjugate complex number (ai · b) becomes the eigenvalue of the conjugate transpose matrix U ^* . Therefore, if the real part of the eigenvalue of the unitary matrix U is a _γ (γ = 1, 2,..., N), the eigenvalue of the Hermitian matrix V = U + U ^* is 2a _γ . Here, even if the eigenvalues have a degree of overlap, the same eigenvalues are arranged for the degree of overlap.

The calculated eigenvalue 2a _γ of the Hermitian matrix V = U + U ^* is sent to the list generator 13. First, the list generation unit 13 collects common values among the eigenvalues 2a _γ of the transmitted Hermitian matrix V = U + U ^* , and the eigenvalues 2a _j (1 ≦ j ≦ u, 1 ≦ u ≦ n) and their overlapping degree p. _Create a pair with _j . Further, the eigenvalue 2a _j is multiplied by ½, and a list A = a pair consisting of a real part a _j (1 ≦ j ≦ u, 1 ≦ u ≦ n) of the eigenvalue of the unitary matrix U and its redundancy p _j [(A _j , p _j )] is generated.
Further, the list generation unit 13 uses the relationship that the absolute value of the eigenvalue of the unitary matrix U (the square root of the sum of the square of the real part and the square of the imaginary part) is 1, and the list generation unit 13 uses the relationship of the imaginary part b of the eigenvalue of the unitary matrix U. the absolute value of _j is calculated by ^{_{√ (1-a j 2)}} .

Next, since the absolute value of the eigenvalue of the unitary matrix U is 1, whether this eigenvalue is imaginary is determined by whether -1 <a _j <1 holds.
Here, when -1 <a _j <1, the eigenvalue having the real part a _j is imaginary. Since this unitary matrix U is real, this eigenvalue is always a complex conjugate pair. That is, the eigenvalue having this real part a _j is a pair of a _j + √ (1−a _j ² ) and a _j −√ (1−a _j ² ). That is, the degree of overlap p _j of the real part a _j of the eigenvalue is always an even number.
On the other hand, when -1 <a _j <1 is not satisfied (equivalent to a _j = ± 1), this eigenvalue is real, and the eigenvalue having this real part a _j is a _j . That is, if the real part a _j = ± 1, its eigenvalue is ± 1 (compound order).

From the above, the eigenvalue of the unitary matrix U is obtained, the degree of overlap of the imaginary eigenvalue is (1/2) · p _j , and the degree of overlap of the real eigenvalue (when the eigenvalue is ± 1) is p _j .
[When U is imaginary]
Next, a case where the unitary matrix U is complex will be described. That is, U is a unitary matrix and V = U + U ^* is a Hermitian matrix.
In this case, as in the case where U is real, the real part of the eigenvalue of U and the absolute value of the imaginary part can be obtained by obtaining the eigenvalue of V = U + U ^* using a routine for obtaining the eigenvalue of the Hermitian matrix. However, when U is imaginary, unlike the case where U is real, the eigenvalue having real part a _j is a pair of a _j + √ (1−a _j ² ) and a _j −√ (1−a _j ² ). It does not always become. Therefore, not only the unitary matrix U but also the unitary matrix i · U is input to the eigenvalue calculation apparatus 10 of FIG. 1 to obtain respective lists.

That is, first, a unitary matrix U is input to the eigenvalue calculation apparatus 10, and a list A = [(a _j , p _j )] is generated as in the case where U is real. Further, the absolute value b _j of the imaginary part is obtained by b _j = √ (1−a _j ² ), and a triple list A ′ = [(a _j , b _j , p _j )] is generated.
Next, the unitary matrix i · U is input to the Hermitian matrix calculation unit 11, and the Hermite matrix calculation unit 11 is a Hermitian matrix V that is the sum of the unitary matrix i · U and its conjugate transpose matrix (i · U) ^*. '= I · U + (i · U) ^* is calculated and output. Next, the Hermitian matrix V ′ = i · U + (i · U) ^* is input to the Hermitian matrix eigenvalue calculating unit 12, and the Hermitian matrix eigenvalue calculating unit 12 performs the Hermitian matrix V ′ = i · U + (i · U) ^*. On the other hand, a known routine for obtaining the eigenvalue of the Hermitian matrix is applied to obtain the eigenvalue of the Hermitian matrix V ′ = i · U + (i · U) ^* .

Here, since the unitary matrix is a normal matrix, if the imaginary part b _γ of the eigenvalue of the unitary matrix i · U is assumed, the eigenvalue of the Hermitian matrix V ′ = i · U + (i · U) ^* is −2b _γ . Here, even if the eigenvalues have a degree of overlap, the same eigenvalues are arranged for the degree of overlap.
The calculated Hermitian matrix V ′ = i · U + (i · U) ^* eigenvalue −2b _γ is sent to the list generator 13. The list generation unit 13 first collects common values among the eigenvalues −2b _γ of the transmitted Hermitian matrix V ′ = i · U + (i · U) ^* , and the eigenvalues −2b _k (1 ≦ k ≦ v, 1 ≦ v ≦ n) and its redundancy q _k are generated. Further, the eigenvalue-2b _k is multiplied by-(1/2), and a list B = [(b _k , q _k )] consisting of a pair of the imaginary part b _k of the eigenvalue of the unitary matrix U and its redundancy q _k is _obtained . Create

From the above, the list A ′ = [(a _j , b _j , p _j )] consisting of the real part, imaginary part and multiplicity of the eigenvalues of the unitary matrix U and the list B = [(b _k , q _k )] are generated.
Next, the element (a, b, p) is sequentially extracted from the list A ′ = [(a _j , b _j , p _j )].
1. Here, if a = 0 or there is no element (−a, b, p ′) in the list A ′, it can be seen that the real part is only a, although the imaginary part of the eigenvalue of U is ± b. (There is no real part -a). Therefore, by extracting (b, q) whose first component is b from the list B, for the eigenvalue of U where the real part is a, the imaginary part is b, that is, a + b · i is It can be seen that q exist. In addition, by extracting (−b, q ′) whose initial component is −b from the list B, for the eigenvalue of U where the real part is a, the imaginary part is −b, that is, It can be seen that there are q ′ ab · i.

2. On the other hand, if the list A ′ has an element (−a, b, p ′) (a ≠ 0) and the list B has only one element (b, q), (−b, q ′), this If the first component of the existing element (b, q) or (-b, q ') is b', it is the eigenvalue of U and the real part is ± a, but the imaginary part is only b ' (There is no imaginary part -b '). Therefore, it can be seen that there are p a + b ′ · i and p ′ −a + b ′ · i for the eigenvalue of U whose real part is ± a.
In the case where eigenvalues have not been determined by the processing so far, the list A ′ has a pair of (a, b, p), (−a, b, p ′) (a ≠ 0), and the list B has Only when there is a pair (b, q), (−b, q ′) (b ≠ 0). In this case, the eigenvalue cannot be specified only by the list A ′ and the list B described above.

FIG. 2 is a diagram showing why the eigenvalue cannot be specified at this time.
First, the eigenvalue of i · U matches the value obtained by rotating the eigenvalue of U by an angle of 90 °. Therefore, the real part of the unitary matrix U eigenvalue candidate α1 rotated by 90 ° (i · U eigenvalue) and the other eigenvalue candidate α2 of the unitary matrix U rotated by 90 ° (i · U eigenvalue) ) Cannot match the eigenvalue candidates α1 and α2 from the eigenvalue of i · U + (i · U) ^* . The eigenvalue candidate means all combinations of the real part and the imaginary part of the list A ′ and the list list B.

FIG. 2 is a diagram for explaining this. This figure shows the real part and the imaginary part of the eigenvalues of the unitary matrix U, the horizontal axis is the real axis indicating the real part, and the vertical axis is the imaginary axis indicating the imaginary part.
FIG. 2 shows a case _where the eigenvalue candidates a _k ± b _k · i of the unitary matrix U rotated by 180 ° coincide with other eigenvalue candidates a _j ± b _j · i. In such a situation, the list A ′ has a pair (a, b, p), (−a, b, p ′) (a ≠ 0), and the list B has (b, q), (− This occurs when there is a pair b, q ′) (b ≠ 0).

In this case, the real part a obtained by rotating the eigenvalue candidate a _k −b _k · i of the unitary matrix U by 90 ° is the real part a obtained by rotating the other eigen value candidate −a _j + b _j · i by 90 °. Match. Therefore, even if the eigenvalue of i · U + (i · U) ^* is obtained as −2a, whether this corresponds to the eigenvalue candidate a _k −b _k · i or another eigenvalue candidate −a _j + b _j · i Cannot be distinguished from each other, and the eigenvalue of U cannot be specified.
As described above, in such a case, the unitary matrix W = i · U ² is further input to the eigenvalue calculation apparatus 10 in FIG. 1, and respective lists are obtained.

That is, unitary W is input to Hermite matrix calculation unit 11, and Hermite matrix calculation unit 11 calculates Hermite matrix V ″ = W + W ^* , which is the sum of unitary W and its conjugate transpose matrix W ^*, and outputs it. . Next, the Hermitian matrix V ″ = W + W ^* is input to the Hermitian matrix eigenvalue calculating unit 12, and the Hermite matrix eigenvalue calculating unit 12 obtains an eigenvalue of the Hermitian matrix with respect to the Hermitian matrix V ″ = W + W ^*. To find the eigenvalue of the Hermitian matrix V ″ = W + W ^* .
Here, since the unitary matrix is a normal matrix, due to the commutability of the unitary matrix, if the real part of the eigenvalue of the unitary matrix W is a _u and the imaginary part b _u , the eigenvalue of the Hermitian matrix V ″ = W + W ^* is −4a _γ · b _γ . Here, even if the eigenvalues have a degree of overlap, the same eigenvalues are arranged for the degree of overlap.

The calculated Hermitian matrix V ″ = W + W ^* eigenvalues −4a _γ · b _γ is sent to the list generation unit 13. First, the list generation unit 13 collects common values among the eigenvalues −4a _γ and b _γ of the Hermitian matrix V ″ = W + W ^* that are sent, and the eigenvalues −4 a _g and b _g (1 ≦ g ≦ w, 1 generating a ≦ w ≦ n) paired with its multiplicity r _g. Furthermore, the eigenvalues _{-4a g · b g - (1/4} ) _multiplied, a list consisting of a pair of g · _{b g} and its multiplicity _{r g C = [(a g} · b g, r g) ] Is created.
Thereafter, (a, b, p) and (−a, b, p ′) are extracted from the list A ′, (b, q) from the list B, and (ab, r) from the list C. Here, if the overlapping values of the eigenvalues a + b · i, a−b · i, −a + b · i, and −a−b · i of the unitary matrix U are set to m ₁ , m ₂ , m ₃ , and m ₄ , respectively, From a, b, p) and (−a, b, p ′), it can be seen that m ₁ + m ₂ = p, m ₃ + m ₄ = p ′, and from (b, q), m ₁ + m ₃ = q From (ab, r), it can be seen that m ₁ + m ₄ = r.

From now on, if s = (− p ′ + q + r) / 2,
m ₁ = s
m ₂ = ps
m ₃ = q−s
m ₄ = rs−s
And the degree of overlap is obtained. Accordingly, there are m ₁ a + b · i, m ₂ ab · i, m ₃ −a + b · i, and m ₄ −a−b · i as eigenvalues of the unitary matrix U. I understand that.

<Specific configuration>
Next, a specific configuration of this embodiment is illustrated.
FIG. 3 is a block diagram illustrating the configuration of the eigenvalue calculation apparatus 100 according to this embodiment.
As illustrated in FIG. 3, the eigenvalue calculation apparatus 100 in this example includes a CPU (Central Processing Unit) 110, an input unit 120, an output unit 130, a hard disk device 140, a RAM (Random Access Memory) 150, and a ROM (Read Only Memory). ) 160 and bus 170.

  The CPU 110 is a processor that executes various arithmetic processes in accordance with various input programs, and is connected to a register 111. The input unit 120 is an input port for inputting data, a keyboard, a mouse, and the like, and the output unit 130 is an output port for outputting data, a display, and the like. The hard disk device 140 has an OS program area 141 for storing an OS (Operating System) program such as windows (registered trademark), and an eigenvalue calculation program area 142 for storing an eigenvalue calculation program for executing the eigenvalue calculation of this embodiment. ing. The RAM 150 has an eigenvalue calculation program area 152 for storing an OS program, an eigenvalue calculation program area 152 for storing an eigenvalue calculation program, and a data area 153 for storing a unitary matrix U for obtaining eigenvalues. The bus 170 connects the CPU 110, the input unit 120, the output unit 130, the hard disk device 140, the RAM 150, and the ROM 160 so that they can communicate with each other.

  FIG. 4 is a conceptual diagram illustrating the configuration of the eigenvalue calculation program 200 in this embodiment. As illustrated in this figure, the eigenvalue calculation program 200 includes a Hermitian matrix calculation program 202, a Hermitian matrix eigenvalue calculation program 203, first to third determination programs 211 to 213, first to fourth list generation programs 221 to 224, An eigenvalue element generation program 231 and a product operation program 241 are included. Here, as the Hermitian matrix eigenvalue calculation program 203, for example, a program capable of obtaining the eigenvalues of the Hermitian matrix included in the numerical calculation software MATLAB (registered trademark) can be used. As a routine of the Hermitian matrix eigenvalue calculation program 203, for example, a Hermitian matrix is converted into a tridiagonal matrix (tridiagonal Hermitian matrix) using the Householder transformation or Lanczos method, and QR method or Sturm method is used. Examples of routines that can be applied to find the eigenvalues can be cited (for example, see Non-Patent Documents 1 and 2, Masao Iri, Kazuken Fujino, “Common sense of numerical computation”, Kyoritsu Shuppan, 1985, etc.).

<Specific processing>
Next, specific processing of this embodiment will be exemplified.
5 to 7 are flowcharts for explaining the eigenvalue element generation processing in this embodiment. Hereinafter, the eigenvalue element generation processing of this embodiment will be described with reference to these drawings.
First, the CPU 110 reads the OS program in the OS program area 141 of the hard disk device 140 and the eigenvalue calculation program 200 in the eigenvalue calculation program area 142 and stores them in the OS program area 151 and the eigenvalue calculation program area 152 of the RAM 150. Next, the CPU 110 sequentially reads OS programs from the OS program area 151 of the RAM 150 and executes them, and then reads and executes the first determination program 211 from the eigenvalue calculation program area 142. The CPU 110 (first determination means) that has read the first determination program 211 reads (inputs) the unitary matrix U from the data area 153 of the RAM 150, and determines whether or not the unitary matrix U is an execution column. (Step S1).

Here, if the unitary matrix U is determined to be a real matrix, CPU 110 creates a list of those to half the eigenvalues of U ^{+ t} U A (half a multiplicity of pairs of eigenvalues) (Step S2). That is, first, the CPU 110 reads the Hermite matrix calculation program 202 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The unitary matrix U read from the register 111 is input to the CPU 110 (first Hermite matrix calculation means) into which the Hermitian matrix calculation program 202 has been read. The CPU 110 receives the unitary matrix U and its conjugate transpose matrix. A first Hermitian matrix U + U ^* which is the sum of the first conjugate transposed matrix U ^* (= ^t U / U is real) is calculated and stored in the register 111. Next, the CPU 110 reads the Hermite matrix eigenvalue calculation program 203 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The first Hermite matrix U + U ^* is input from the register 111 to the CPU 110 (first Hermite matrix eigenvalue calculation means) into which the Hermite matrix eigenvalue calculation program 203 is read, and the CPU 110 receives the first Hermite matrix U + U A first eigenvalue which is an eigenvalue of ^* is calculated and output to the register 111 and stored. Next, the CPU 110 reads the first list generation program 221 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The first eigenvalue is input from the register 111 to the CPU 110 (first list generation means) from which the first list generation program 221 is read, and the CPU 110 multiplies the first eigenvalue by 1/2. The real part of the eigenvalue of the unitary matrix U is calculated, and the real part a _{j of} the calculated eigenvalue of the unitary matrix U (1 ≦ j ≦ u, 1 ≦ u ≦ n, the unitary matrix U is an n × n matrix) and its A first list A = [(a _j , p _j )] consisting of a pair with the degree of overlap p _j is generated, output to the register 111 and stored.

When the list A is generated as described above, the CPU 110 next reads and executes the second list generation program 222 from the eigenvalue calculation program area 152 of the RAM 150. The first list A = [(a _j , p _j )] is input from the register 111 to the CPU 110 (second list generation means) into which the second list generation program 222 has been read. When the real part a _j of the list A is not ± 1, the CPU 110 calculates a square root b _j = √ (1− (a _j ) ² ) from the real part a _j , and the first list A = [ The eigenvalue list [(a _j , p _j )] with the element (a, p) replaced by ((a + b · i), p / 2) and ((a−b · i), p / 2) [(a _j + B _j · i), p _j / 2], [(a _j −b _j · i), p _j / 2] (i is an imaginary unit), and the generated eigenvalue list is generated by the bus 170 and the output unit 130. And the process is terminated (step S3).

On the other hand, when it is determined in step 1 that the unitary matrix U is not an execution column, the CPU 110 creates a list A (a pair of ½ times the eigenvalue and the multiplicity) that is ½ times the eigenvalue of U + U ^*. And stored in the register 111 (step S4). This detail is the same as the processing in step 2 described above, except that ^t U is replaced with U ^* .
Next, the CPU 110 reads the second list generation program 222 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The first list A = [(a _j , p _j )] is input from the register 111 to the CPU 110 (second list generation means) from which the second list generation program 222 has been read. The square root b _j = √ (1− (a _j ) ² ) is calculated from the real part a _j of the first list A, and the second list A ′ = [(a _j , b _j , p _j )] is generated. Then, the generated second list A ′ is output to and stored in the register 111 (list memory) (step S5).

Next, the CPU 110 creates a list B (a pair of eigenvalues minus -1/2 times and a multiplicity) obtained by multiplying the eigenvalues of i · U + (i · U) ^* by −½ (step S6). That is, first, the CPU 110 reads the product operation program 241 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (first product operation means) from which the product operation program 241 has been read is supplied with the unitary matrix U and the imaginary unit i (stored in the register 111 in advance) from the register 111. The CPU 110 stores the unitary matrix. The product i · U of U and the imaginary unit i is calculated, and the product i · U is output to the register 111 and stored. Next, the CPU 110 reads the Hermite matrix calculation program 202 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (second Hermite matrix calculation means) into which the Hermitian matrix calculation program 202 has been read is supplied with the product i · U from the register 111, and the CPU 110 is the product i · U and its conjugate transpose matrix. A second Hermitian matrix i · U + (i · U) ^* , which is the sum of the second conjugate transpose matrix (i · U) ^* , is calculated and output to the register 111 and stored. Next, the CPU 110 reads and executes the Hermitian matrix eigenvalue calculation program 203 from the eigenvalue calculation program area 152 of the RAM 150. A second Hermite matrix i · U + (i · U) ^* is input from the register 111 to the CPU 110 (second Hermite matrix eigenvalue calculating means) into which the Hermite matrix eigenvalue calculating program 203 is read. The second eigenvalue, which is the eigenvalue of the second Hermitian matrix i · U + (i · U) ^* , is calculated and output to the register 111 and stored. Next, the CPU 110 reads the third list generation program 223 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. A second eigenvalue is input from the register 111 to the CPU 110 (third list generation means) into which the third list generation program 223 has been read. Then, the CPU 110 multiplies the second eigenvalue by −½ to obtain an imaginary part b _k of the eigenvalue of the unitary matrix U (1 ≦ k ≦ v, 1 ≦ v ≦ n, and the unitary matrix is an n × n matrix) ) To generate a third list B = [(b _k , q _k )] consisting of the pair of the calculated imaginary part b _k and its redundancy q _k, and the generated third list B Is output to and stored in the register 111 (list memory).

Next, the CPU 110 reads the second determination program 212 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (second determination means) into which the second determination program 212 has been read is still from the second list A ′ = [(a _j , b _j , p _j )] in the register 111 (list memory). One element (a, b, p) that has not been examined is extracted and stored in the register 111 (step S7), and whether or not a = 0 and the element (-a, b) is included in the second list A ′. , P ′) exists (step S8).
If it is determined that a = 0 or the element (−a, b, p ′) does not exist in the second list A ′, the CPU 110 loads the eigenvalue element generation program 231 from the eigenvalue calculation program area 152 of the RAM 150. Read and execute. Elements (a, b, p) are input from the register 111 to the CPU 110 (eigenvalue element generation means) from which the eigenvalue calculation program area 152 has been read. Further, the CPU 110 extracts the element (b, q) and the element (−b, q ′) from the third list B = [(b _k , q _k )] in the register 111, and (a + b · i, q) and (a−b · i, q ′) are generated and output to the register 111, and these are replaced with the element (a, b, p) of the register 111. When only one of the element (b, q) or the element (−b, q ′) exists in the third list B = [(b _k , q _k )], the CPU 110 stores the contents in the register 111. From the third list B = [(b _k , q _k )], only one of the element (b, q) or the element (−b, q ′) is extracted, and (a + b · i, q) (element (b , Q)) or (ab-i, q ′) (when element (−b, q ′) exists) is generated and output to the register 111. Replace with element (a, b, p) (step S9).

On the other hand, when it is determined in step S8 that the element (−a, b, p ′) (a ≠ 0) exists in the second list A ′, the CPU 110 reads the third value from the eigenvalue calculation program area 152 of the RAM 150. The determination program 213 is read and executed. The CPU 110 (third determination means) that has read the third determination program 213 reads the element (a, b, p) extracted in step S8 from the register 111, and whether or not b = 0. In addition, it is determined whether or not both the element (b, q) and the element (−b, q ′) exist in the third list B = [(b _k , q _k )] in the register 111 (step S10). ).

Here, when it is determined that the element (b, q) (b ≠ 0) and the element (−b, q ′) are both present in the third list B = [(b _k , q _k )]. Step S12 is executed.
On the other hand, if it is determined that b = 0, the CPU 110 reads the eigenvalue element generation program 231 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. Elements (a, b, p) and (−a, b, p ′) are input to the CPU 110 (eigenvalue element generation means) from which the eigenvalue calculation program area 152 has been read. ) And (−a, p ′) are generated and output to the register 111, and these are replaced with the elements (a, b, p) and (−a, b, p ′) and stored. If it is determined in step S10 that only one of the element (b, q) or the element (−b, q ′) exists in the third list B = [(b _k , q _k )], the eigenvalue The CPU 110 (eigenvalue element generation means) from which the calculation program area 152 has been read includes b ′ which is b or −b determined to exist, and elements (a, b, p) and (−a, b, p ′) is input, and the CPU 110 generates (a + b ′ · i, p) and (−a + b ′ · i, p ′) and outputs them to the register 111, and outputs them to the element (a, b, p). And (-a, b, p ') are replaced and stored (step S11). And after this step S11 processes, it progresses to step S12.

In step S12, whether there is an element that has not been checked yet in the second list A ′ = [(a _j , b _j , p _j )] of the register 111 by the CPU 110 into which the second determination program 212 has been read. Judge whether or not. This is performed, for example, by setting a flag for the element every time the element is extracted in step S7 and searching for the presence or absence of the flag. In step S7, elements are extracted in order from the top of the list A ′ = [(a _j , b _j , p _j )], and depending on whether or not the last element of the list A ′ has been extracted. This determination may be made.

Here, if there is an element that has not been checked yet, the process returns to step S7. If there is no element that has not been checked yet, the CPU 110 into which the second determination program 212 has been read indicates that the list A ′ = [(( _a.sub.j , _b.sub.j , _p.sub.j )] determines whether there is an element that has not been replaced. This determination is performed, for example, by setting a flag for each element and searching for the presence or absence of the flag every time the element is replaced.
Here, if it is determined that there is no element that has not been replaced, the CPU 110 outputs the list A ′ = [(a _j , b _j , p _j )] of the register 111 in which each element is replaced with the bus 170 and the output. The data is output through the unit 130, and the process ends.

On the other hand, when it is determined that there is an element that has not been replaced yet, the CPU 110 executes the following processing. In the following processing, in step S10, the element (b, q) (b ≠ 0) and the element (−b, q ′) are both included in the third list B = [(b _k , q _k )]. This corresponds to the processing when it is determined that it exists.
First, W = i · ^{U 2} and then, W + ^{W *} eigenvalues -1/4 times the list C but (-1/4 times the eigenvalues and multiplicity of pairs) of creating a (step S14). That is, first, the CPU 110 reads the product operation program 241 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (second product operation means) into which the product operation program 241 has been read is supplied with the product i · U and the unitary matrix U from the register 111, and the CPU 110 receives the unitary matrix U and the product i · The product i · U ² with U is calculated and stored in the register 111. Next, the CPU 110 reads the Hermite matrix calculation program 202 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (third Hermitian matrix calculation means) into which the Hermitian matrix calculation program 202 has been read is supplied with the product i · U ² from the register 111, and the CPU 110 receives the product i · U ² and its conjugate transpose matrix. The third Hermitian matrix i · U ² + (i · U ² ) ^* which is the sum of the third conjugate transpose matrix (i · U ² ) ^* is calculated and output to the register 111 and stored. Next, the CPU 110 reads and executes the Hermitian matrix eigenvalue calculation program 203 from the eigenvalue calculation program area 152 of the RAM 150. A third Hermite matrix i · U ² + (i · U ² ) ^* is input from the register 111 to the CPU 110 (third Hermite matrix eigenvalue calculating means) into which the Hermite matrix eigenvalue calculating program 203 is read. The CPU 110 calculates a third eigenvalue that is an eigenvalue of the third Hermite matrix i · U ² + (i · U ² ) ^* , and outputs and stores it in the register 111. Next, the CPU 110 reads the fourth list generation program 223 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. A third eigenvalue is input from the register 111 to the CPU 110 (fourth list generation means) into which the fourth list generation program 223 has been read. Then, the CPU 110 multiplies the third eigenvalue by −1/4 and multiplies the real part a _g (1 ≦ g ≦ w, 1 ≦ w ≦ n) of the eigenvalue of the unitary matrix U by the imaginary part b _g. calculates a _g · _{b g,} a list of the fourth consisting of a pair of the calculated with the product _{a g} · _b g and its multiplicity _{r g C = [(a g} · b g, r g)] to generate the The generated fourth list C is output and stored in the register 111 (list memory).

Next, the CPU 110 reads the eigenvalue element generation program 231 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. Here, the CPU 110 (eigenvalue element generation means) from which the eigenvalue element generation program 231 has been read is first, from the register 111, the second list A ′ = [(a _j , b _j , p _j )] that has not been replaced yet. One pair of elements (a, b, p) and (−a, b, p ′) is extracted from (step S15), and an element (from the third list B = [(b _k , q _k )] ( b, extracts q) (step S16), and a list of the _{4 C = [(a g ·} b g, r g)] corresponding to a · b from element (a · b, r) is extracted (step S17). Note that r = 0 if there is no element (a · b, r) corresponding to a · b. The CPU 110 calculates s = (− p ′ + q + r) / 2, and (a + bi, s), (a−bi, p−s), (−a + bi, q−s), and (−a−bi). , R−s), and the generated (a + bi, s), (a−bi, p−s), (−a + bi, q−s) and (−a−bi, rs) are stored in the register 111. Output, and replace (a, b, p) in the second list A ′ = [(a _j , b _j , p _j )] with (a + bi, s) and (a−bi, p−s), (−a, b, p ′) is replaced with (−a + bi, q−s) and (−a−bi, r−s) and stored in the register 111 (step S18). It should be noted that here, those whose degree of overlap is 0 are excluded from the second list A ′.

Next, the CPU 110 refers to the register 111 and determines whether there is an element of the second list A ′ = [(a _j , b _j , p _j )] that has not been replaced yet (step S19). If it is determined that there is an element that has not been replaced yet, the process returns to step S15. If it is determined that there is no element that has not been replaced, the second list A ′ = [(( a _j , b _j , p _j )] are output via the bus 170 and the output unit 130, and the process is terminated.
Next, examples of the present embodiment will be described.

<Example 1>
The first embodiment is an example where the unitary matrix U is real (orthogonal matrix). In this case, YES is determined in step S1 (FIG. 5), and the process proceeds to step S2. Where U is an orthogonal matrix such as

なお、実際には、Ｕ＋^ｔＵを計算するために^ｔＵを計算したり、１６個の成分をすべての計算したりする必要はなく、δ１≦δ２を満たすＵの（δ１，δ２）成分と（δ２，δ１）成分の和を、ε１≦ε２を満たすＵ＋^ｔＵの（ε１，ε２）成分（右上部分）として求め、それを転置したものをＵ＋^ｔＵの左下成分（ε１≧ε２）とすればよい。もちろん、^ｔＵを計算し、Ｕ＋^ｔＵの成分をすべての計算してもよい。

Actually, it is not necessary to calculate ^t U or calculate all 16 components in order to calculate U + ^t U, and (δ1, δ2) components of U satisfying δ1 ≦ δ2 The sum of the (δ2, δ1) components is obtained as the (ε1, ε2) component (upper right part) of U + ^t U satisfying ε1 ≦ ε2, and the transposed one is the lower left component of U + ^t U (ε1 ≧ ε2) do it. Of course, ^t U may be calculated, and all components of U + ^t U may be calculated.

Routines for determining the eigenvalues of the U ^{+ t} U a Hermitian matrix (or routines to determine the eigenvalues of a real symmetric matrix) when applied to, returned two double root of 1.7364668 and -0.51790682. Therefore, the list A generated in step S2 is
[(0.868233340,2), (−0.25895341,2)]
It becomes.
And in step S3,
[(0.868233340 + 0.49615598 · i, 1), (0.86823340−0.49615598 · i, 1), (−0.25895341 + 0.96588981 · i, 1), (−0.25895341−0.96588981 · i, 1)]
A list of eigenvalues is generated and output.

<Example 2>
The first embodiment is an example when the unitary matrix U is imaginary (not an orthogonal matrix). In this case, NO is determined in step S1 (FIG. 5), and the process proceeds to step S4 (FIG. 6). Where U is a unitary matrix such as

なお、実際には、Ｕ＋Ｕ^＊を計算するためにＵ^＊を計算したり、９個の成分をすべての計算したりする必要はなく、δ１≦δ２を満たすＵの（δ１，δ２）成分と（δ２，δ１）成分の複素共役との和を、ε１≦ε２を満たすＵ＋Ｕ^＊の（ε１，ε２）成分（右上部分）として求め、それを複素共役転置したものをＵ＋Ｕ^＊の左下成分（ε１≧ε２）とすればよい。もちろん、Ｕ^＊を計算し、Ｕ＋Ｕ^＊の成分をすべての計算してもよい（以下同様）。

Actually, it is not necessary to calculate U ^* or calculate all nine components in order to calculate U + U ^*, and (δ1, δ2) components of U that satisfy δ1 ≦ δ2 and ( The sum of the (δ2, δ1) component and the complex conjugate is obtained as the (ε1, ε2) component (upper right part) of U + U ^* satisfying ε1 ≦ ε2, and the result obtained by transposing the complex conjugate transpose is the lower left component of U + U ^* (ε1 ≧ ε2). Of course, U ^* may be calculated, and all components of U + U ^* may be calculated (the same applies hereinafter).

When this U + U ^* is applied to a routine for obtaining eigenvalues of the Hermitian matrix, single roots of 1.85779089, -0.379008660, -1.079090590 are returned. Therefore, the list A generated in step S4 is
[(0.9289954451,1), (−0.189950430,1), (−0.539556955,1)]
The list A ′ generated in step S5 is
[(0.928995445, 0.37019404,1), (-0.18950430, 0.981887989,1), (-0.53955695,0.841968833,1)]
It becomes.

ここでも前と同様に、Ｖ^＊を計算したり、Ｖ＋Ｖ^＊の全ての成分を計算したりする必要はない。
このＶ＋Ｖ^＊エルミート行列の固有値を求めるルーチンにかけると、−１．６８３９３６７，１．９６３７５９８，０．７４０３８８０８という単根が返ってくる。 Next, when the same calculation is performed for V = i · U in step S6, the following is obtained.

As before, even here, you can calculate the V ^*, there is no need or to calculate all of the components of the V + V ^*.
When applied to a routine for obtaining the eigenvalue of this V + V ^* Hermitian matrix, a single root of -1.68369367, 1.96375798, 0.74038808 is returned.

From now on, the list B generated in step S6 is
[(0.841968355, 1), (-0.98187990, 1), (-0.37019404, 1)]
It becomes.
Here, since there is no pair of the form (a, b, m) and (−a, b, m ′) in the list A ′, all elements of the list A ′ are processed in step S9, and the list B is used. , List of eigenvalues of U [(0.928995445-0.37019044 · i, 1), (−0.1895504-0.98187990 · i, 1), (−0.53952695 + 0.84196833 · i, 1)]
Is obtained.

<Example 3>
Finally, an example will be described in which the unitary matrix U is imaginary (not an orthogonal matrix) and U + U ^* has eigenvalues with opposite signs having the same absolute value.
In this case, NO is determined in step S1 (FIG. 5), and the process proceeds to step S4 (FIG. 6). Where U is a unitary matrix such as

なお、実際には、Ｕ＋Ｕ^＊を計算するためにＵ^＊を計算したり、９個の成分をすべての計算したりする必要はなく、δ１≦δ２を満たすＵの（δ１，δ２）成分と（δ２，δ１）成分の複素共役との和を、ε１≦ε２を満たすＵ＋Ｕ^＊の（ε１，ε２）成分（右上部分）として求め、それを複素共役転置したものをＵ＋Ｕ^＊の左下成分（ε１≧ε２）とすればよい。

Actually, it is not necessary to calculate U ^* or calculate all nine components in order to calculate U + U ^*, and (δ1, δ2) components of U that satisfy δ1 ≦ δ2 and ( The sum of the (δ2, δ1) component and the complex conjugate is obtained as the (ε1, ε2) component (upper right part) of U + U ^* satisfying ε1 ≦ ε2, and the result obtained by transposing the complex conjugate transpose is the lower left component of U + U ^* (ε1 ≧ ε2).

When this U + U ^* is applied to a routine for obtaining eigenvalues of the Hermitian matrix, single roots of -1.2000000, 0.56000000, 1.2000000 are returned. Therefore, the list A generated in step S4 is
[(−0.60000000,1), (0.28000000,1), (0.60000000,1)]
The list A ′ generated in step S5 is
[(−0.60000000, 0.80000000, 1), (0.28000000, 0.96000000, 1), (0.60000000, 0.80000000, 1)]
It becomes.
Next, when the same calculation is performed for V = i · U in step S6, the following is obtained.

ここでも前と同様に、Ｖ^＊を計算したり、Ｖ＋Ｖ^＊の全ての成分を計算したりする必要はない。
このＶ＋Ｖ^＊エルミート行列の固有値を求めるルーチンにかけると、１．６００００００，−１．９２０００００，−１．６００００００という単根が返ってくる。

As before, even here, you can calculate the V ^*, there is no need or to calculate all of the components of the V + V ^*.
When applied to a routine for obtaining eigenvalues of this V + V ^* Hermitian matrix, single roots of 1.6000000, -1.9200000000, and -1.6000000 are returned.

From now on, the list B generated in step S6 is
[(-0.80000000,1), (0.96000000,1), (0.80000000,1)]
It becomes.
Thereafter, the processing after step S7 is performed, but for the element of list A ′ (0.28000000, 0.96000000, 1), the processing of step S9 is performed. Then, using the element (0.96000000,1) of the list B, the element (0.28000000, 0.96000000,1) of the list A ′ is replaced with (0.28000000 + 0.96000000 · i, 1). As a result, at this stage, list A ′ becomes
[(−0.60000000, 0.80000000, 1), (0.28000000 + 0.96000000 · i, 1), (0.60000000, 0.80000000, 1)]
It becomes.

For the pair of elements (−0.60000000, 0.80000000,1) and (0.60000000,0.80000000,1) of list A ′, (−0.80000000,1) Since there is an element of (0.80000000, 1) (step S10), the process is not performed and remains at this point.
Since there is an element A ′ that could not be replaced, the determination in step S13 is YES, and the process proceeds to step S14 (FIG. 7).
In step S14, the same calculation is performed for W = V · U as follows.

ここでも前と同様、Ｗ^＊を計算したり、Ｗ＋Ｗ^＊のすべての成分を計算したりする必要はない。
このＷ＋Ｗ^＊をエルミート行列の固有値を求めるルーチンにかけると、単根−１．０７５２０００と、二重根−１．９２０００００が返ってくる。これから、ステップＳ１４で求まるリストＣは、
［（０．２６８８００００，１），（０．４８００００００，２）］
となる。

As before Again, W to or calculation ^*, W + W ^* of it is not necessary or to calculate all the components.
When this W + W ^* is applied to a routine for obtaining eigenvalues of the Hermitian matrix, a single root of -1.0752000 and a double root of -1.9200,000 are returned. From now on, the list C obtained in step S14 is:
[(0.26888000, 1), (0.48000000, 2)]
It becomes.

Next, a pair (a, b, p), (−a, b, p ′) not yet replaced is taken from the list A ′ (step S15). There are only one pair (−0.60000000, 0.80000000, 1) and (0.60000000, 0.80000000, 1) that are not replaced here. That is, p = 1 and p ′ = 1.
Since there are (0.80000000,1) and (−0.80000000,1) in the list B, (0.60000,0.80000000,1) is extracted as (b, q) in step S16, and q = 1

Also, ab = −0.48000000, but list C
[(0.26888000, 1), (0.48000000, 2)]
Since there is no match for (−0.48000000, r), r = 0 (step S17).
Therefore, s = (− p ′ + q + r) / 2 = 0, ps = 1, rs = 0,
(-0.60000000, 0.80000000, 1)
Is
(-0.60000000-0.80000000 · i, 1)
In addition,
(0.60000000, 0.80000000, 1)
Is
(0.60000000 + 0.80000000 · i, 1)
(Step S18), the list A ′ is
[(−0.60000000−0.80000000 · i, 1), (0.28000000 + 0.96000000 · i, 1), (0.60000000 + 0.80000000 · i, 1)]
Then, the process ends.

[Second Embodiment]
Next, a second embodiment of the present invention will be described.
In this embodiment, a routine for obtaining eigenvalues of the Hermitian matrix is used only twice at most. In the following description, differences from the first embodiment will be mainly described.
<Principle>
First, the principle of this embodiment will be described.
The basic configuration of this embodiment is the same as that of the eigenvalue calculation apparatus 10 of FIG.

[When U is real]
The processing when the unitary matrix U is real is exactly the same as in the first embodiment.
[When U is complex]
When the unitary matrix U is complex, first, the eigenvalue of U + U ^* is obtained as in the first embodiment.
First, as in the first embodiment, the unitary matrix U is input to the eigenvalue calculation apparatus 10, and the list A = [(a _j , p _j )] is generated as in the case where U is real. Further, an imaginary part b _j is obtained by b _j = √ (1-a _j ² ), and a triple list A ′ = [(a _j , b _j , p _j )] is generated.

Here, if the list A ′ = [(a _j , b _j , p _j )] has a pair (a, b, p), (−a, b, p ′) (a ≠ 0, ± 1). Otherwise, as described in the first embodiment, the imaginary part of all eigenvalues of U is determined by obtaining eigenvalues of i · U + (i · U) ^* for i · U. Since this process is the same as that of the first embodiment, a description thereof will be omitted.
In the following, the list A ′ = [(a _j , b _j , p _j )], which is different from the first embodiment, is _added to (a, b, p), (−a, b, p ′). Processing when there is a pair (a ≠ 0, ± 1) will be described.

Β · U obtained by multiplying the unitary matrix U by a complex number β = exp (i · θ) having an absolute value of 1 is also a unitary matrix. In this embodiment, this unitary matrix β · U is input to the eigenvalue calculation apparatus 10 to obtain a new list. However, in this case, the eigenvalue candidates a _j ± b _j · i (possible eigenvalue values) of the unitary matrix U taken arbitrarily are rotated by 2θ so that they do not overlap with other eigenvalue candidates. θ must be selected. Hereinafter, the reason will be described.
First, the eigenvalue of β · U matches the value obtained by rotating the eigenvalue of U by the angle θ. Therefore, the real part of the eigenvalue candidate α1 of the unitary matrix U rotated by θ (the eigenvalue of β · U) and the other real part candidate α2 of the unitary matrix U rotated by θ (the eigenvalue of β · U) If the real part matches, the eigenvalue candidates α1 and α2 cannot be distinguished from the eigenvalues of β · U + (β · U) ^* .

FIG. 8 is a diagram for explaining this. This figure shows the real part and the imaginary part of the eigenvalues of the unitary matrix U, the horizontal axis is the real axis indicating the real part, and the vertical axis is the imaginary axis indicating the imaginary part.
FIG. 8 shows a case _where the eigenvalue candidates a _k ± b _k · i of the unitary matrix U are rotated by 2θ and coincide with other eigen value candidates a _j ± b _j · i. In this case, the real part a obtained by rotating the eigenvalue candidate a _k -b _k · i of the unitary matrix U by θ coincides with the real part a obtained by rotating the other eigenvalue candidates a _j + b _j · i by θ. Therefore, even if the eigenvalue of β · U + (β · U) ^* is obtained as 2a, it corresponds to the eigenvalue candidate a _k −b _k · i or to another eigenvalue candidate a _j + b _j · i Cannot be distinguished, and the eigenvalue of U cannot be specified.

The following can be exemplified as a convenient method for determining θ that does not cause such a problem.
[Random selection]
In the first example, a complex number β = exp (i · θ) having an absolute value of 1 is randomly generated, and it is checked whether all eigenvalue candidates overlap with each other by 2θ rotation. If this is the case, this is a method of re-acquiring θ. In general, an eigenvalue candidate rotated by 2θ rarely overlaps with other eigenvalue candidates. In addition, the amount of processing to check whether there is an overlap in 2θ rotation is considerably smaller than the processing amount of the routine for obtaining eigenvalues of the Hermitian matrix. Therefore, even with such a method, the processing amount can be reduced and the processing speed can be increased as compared with the first embodiment.

[Method of setting 2θ smaller than minimum angle between eigenvalue candidates]
The second example is a method that can reliably select a suitable θ by setting 2θ smaller than the minimum angle between eigenvalue candidates. In this case, first, all eigenvalue candidates a + b · i whose imaginary part is positive are rearranged in descending order of a. This corresponds to arranging a + b · i in ascending order of declination. Next, a · b′−a ′ · b is calculated from all adjacent pairs a + b · i and a ′ + b ′ · i. This corresponds to obtaining the sine value of the angle between a + b · i and a ′ + b ′ · i. Then, if 1/2 of the minimum value (the multiple roots are handled together and not 0) is m, the minimum angle between adjacent pairs is ψ, and sinθ = m, 2θ <ψ Meet.

Because if θ ≠ 0, pay attention to cos θ <1,
sin2θ = 2sinθ · cosθ <2sinθ = 2m = sinψ
That's why.
That is, θ where sin θ = m is a suitable θ. Then, by setting m ′ = √ (1−m ² ) and setting β = m ′ + m · i, a complex number β having an absolute value of 1 without the inconvenience of the angle as described above can be obtained. Note that the processing amount of the method of setting 2θ smaller than the minimum angle between the eigenvalue candidates is considerably smaller than the processing amount of the routine for obtaining the eigenvalue of the Hermitian matrix. Therefore, even with such a method, the processing amount can be reduced and the processing speed can be increased as compared with the first embodiment.

After setting appropriate β as described above, the unitary matrix β · U is input to the Hermitian matrix calculation unit 11 of the eigenvalue calculation apparatus 10 (FIG. 1), and the Hermitian matrix calculation unit 11 receives the unitary matrix β · U. And a Hermitian matrix V ′ = β · U + (β · U) ^* , which is the sum of γ and its conjugate transpose matrix (β · U) ^* , are output. Next, the Hermitian matrix V ′ = β · U + (β · U) ^* is input to the Hermitian matrix eigenvalue calculating unit 12, and the Hermitian matrix eigenvalue calculating unit 12 receives the Hermite matrix V ′ = β · U + (β · U) ^*. On the other hand, a known routine for obtaining the eigenvalue of the Hermitian matrix is applied to obtain the eigenvalue of the Hermitian matrix V ′ ″ = β · U + (β · U) ^* . Here, since the real parts of the eigenvalue candidates a + b · i and a−b · i rotated by θ are a · m′−b · m and a · m ′ + b · m, respectively, the Hermitian matrix V ′ ″ The real part of the eigenvalue is 2 (a · m′−b · m) and 2 (a · m ′ + b · m) with respect to the real part a and the imaginary part b of the unitary matrix U. Here, even if the eigenvalues have a degree of overlap, the same eigenvalues are arranged for the degree of overlap.

The calculated Hermitian matrix V ′ ″ is sent to the list generator 13. First, the list generation unit 13 summarizes common values among the eigenvalues of the transmitted Hermite matrix V ′ ″, and further, a value c _h (1 ≦ h ≦ x, 1 ≦ x) obtained by multiplying the eigenvalue by ½. ≦ n) and the duplication degree z _h are generated, and a list D = [(c _h , z _h )] is generated.
Then, the imaginary part of the eigenvalue of the unitary matrix is determined by using the list A ′ = [(a _j , b _j , p _j )] and the list D = [(c _h , z _h )].
<Specific configuration>
Next, a specific configuration of this embodiment is illustrated.

The configuration of the eigenvalue calculation apparatus of this embodiment is the same as that of the first embodiment shown in FIG. However, only the configuration of the eigenvalue calculation program is different from that of the first embodiment.
FIG. 9 is a conceptual diagram illustrating the configuration of the eigenvalue calculation program 300 in this embodiment. As illustrated in this figure, the eigenvalue calculation program 300 includes a Hermitian matrix calculation program 202, a Hermitian matrix eigenvalue calculation program 203, first and second determination programs 211 and 212, first and fifth list generation programs 221, 321, An eigenvalue element generation program 231 and a product operation program 241 are included. In the eigenvalue calculation program 300, items that are the same as those in the first embodiment are denoted by the same reference numerals as in FIG.

<Specific processing>
Next, specific processing of this embodiment will be exemplified.
10 to 12 are flowcharts for explaining the eigenvalue element generation processing in this embodiment. Hereinafter, the eigenvalue element generation processing of this embodiment will be described with reference to these drawings. In the following description, only the process when U is imaginary will be described. Since the process performed when U is real and the process performed when U is real are the same as those in the first embodiment, Description is omitted.

First, the CPU 110 creates a first list A = [(a _j , p _j )] (a pair of eigenvalue ½ times multiplicity) related to the eigenvalue of U + U ^* multiplied by ½, Store in the register 111 (step S20). This process is the same as the process in step 4 described above.
Next, the CPU 110 calculates a square root b = √ (1− (a) ² ) for each element (a, p) in the first list, and sets (a, p) to (a, b, p). The second list A ′ = [(a _j , b _j , p _j )] replaced with is created and stored in the register 111 (list memory) (step S21). This process is the same as the process in step 5 described above.

Next, the CPU 110 reads the second determination program 212 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 into which the second determination program 212 has been read includes elements (a, b, p) and (−a, b, −p ′) (a ≠ 0, ± 1) in the second list A ′ of the register 111. It is determined whether there is a pair (step S22).
If it is determined that there is no pair of elements (a, b, p) and (−a, b, −p ′) (a ≠ 0, ± 1) in the second list A ′, the CPU 110 Create a third list B = [(b _k , q _k )] (a pair of eigenvalues -1/2 times and multiplicity) of e · U + (i · U) ^* eigenvalues multiplied by −½ Then, the generated third list B is output to and stored in the register 111 (list memory) (step S23). This process is the same as step S6 described above.

Next, the CPU 110 reads the second determination program 212 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (second determination means) into which the second determination program 212 has been read is still from the second list A ′ = [(a _j , b _j , p _j )] in the register 111 (list memory). One element (a, b, p) that has not been examined is extracted and stored in the register 111 (step S24).
Next, the CPU 110 reads the eigenvalue element generation program 231 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. Elements (a, b, p) are input from the register 111 to the CPU 110 (eigenvalue element generation means) from which the eigenvalue calculation program area 152 has been read. Further, the CPU 110 extracts the element (b, q) and the element (−b, q ′) from the third list B = [(b _k , q _k )] in the register 111, and (a + b · i, q) and (a−b · i, q ′) are generated and output to the register 111, and these are replaced with the element (a, b, p) of the register 111. If only one of the element (b, q) or the element (−b, q ′) is present in the third list B = [(b _k , q _k )], the CPU 110 stores the contents in the register 111. From the third list B = [(b _k , q _k )], only one of the element (b, q) or the element (−b, q ′) is extracted, and (a + b · i, q) (element (b , Q)) or (ab-i, q ′) (when element (−b, q ′) exists) is generated and output to the register 111. Replace with element (a, b, p) (step S25).

Next, whether or not there is an element that has not yet been checked in the second list A ′ = [(a _j , b _j , p _j )] of the register 111 by the CPU 110 into which the second determination program 212 has been read. Determine whether. If it is determined that there is an element that has not been checked yet, the process returns to step S24. If it is determined that there is no element that has not been checked, the second list A ′ replaced as described above. = [(A _j , b _j , p _j )] is output through the bus 170 and the output unit 130, and the process is terminated.
On the other hand, if it is determined in step S22 that the second list A ′ has a pair of elements (a, b, p) and (−a, b, −p ′) (a ≠ 0, ± 1), The CPU 110 reads the complex number setting program 362 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The complex number setting program 362 in this example is a program for generating a suitable complex number β by the above-described “method of setting 2θ smaller than the minimum angle between eigenvalue candidates”. The CPU 110 (complex number setting means) into which the complex number setting program 362 has been read follows the above-mentioned “method of setting 2θ smaller than the minimum angle between eigenvalue candidates” and complex numbers β = m ′ + m · i (i is an imaginary unit, (M ′) ² + m ² = 1) is set, and this is output to the register 111 and stored. That is, first, the CPU 110 sorts the elements (a, b, p) of the second list A ′ = [(a _j , b _j , p _j )] in the register 111 in the order of a _j . 6 list A ″ is generated and stored in the register 111 (step S27). In addition, the CPU 110 applies a · b ′ to all pairs of adjacent elements (a, b, p) and (a ′, b ′, p ′) of the sixth list A ″ in the register 111. -A ′ · b is calculated, 1/2 of the minimum value is calculated as m, m ′ = √ (1−m ² ) is calculated, and complex number β = m ′ + m · i is set. The data is output to and stored in the register 111 (step S28).

Next, the CPU 110 deletes the elements (a, b, p) (except for a = 1, −1) of the sixth list A ″ in the register 111 (a, b, p, a · m′−b). (M, a · m ′ + b · m) and this sixth list A ″ is stored in the register 111 (step S29).
Next, the CPU 110 creates a list D (a pair of ½ times the eigenvalue and the degree of overlap) obtained by halving the eigenvalue of β · U + (β · U) ^* (step S30). That is, first, the CPU 110 reads the product operation program 241 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The unit 110 and the complex number β are input from the register 111 to the CPU 110 (third product calculation means) into which the product calculation program 241 has been read. The CPU 110 calculates the product β of the unitary matrix U and the complex number β. Calculate U and output to register 111 for storage.

Next, the CPU 110 reads the Hermite matrix calculation program 202 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The product β · U is input from the register 111 to the CPU 110 (fourth Hermitian matrix calculation means) into which the Hermitian matrix calculation program 202 has been read. The fourth Hermitian matrix β · U + (β · U) *, which is the sum of the four conjugate transpose matrices (β · U) *, is calculated and output to the register 111 and stored. Next, the CPU 110 reads the Hermite matrix eigenvalue calculation program 203 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (fourth Hermitian matrix eigenvalue calculating means) into which the Hermitian matrix eigenvalue calculating program 203 has been read is inputted with the fourth Hermitian matrix β · U + (β · U) * from the register 111. The fourth eigenvalue, which is the eigenvalue of the fourth Hermitian matrix β · U + (β · U) *, is calculated and output to the register 111 and stored. Next, the CPU 110 reads the fifth list generation program 321 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The fourth eigenvalue is input from the register 111 to the CPU 110 (fifth list generation means) into which the fifth list generation program 321 has been read. Then, the CPU 110 calculates a value c _h (1 ≦ h ≦ x, 1 ≦ x ≦ n) obtained by halving the fourth eigenvalue, and calculates the calculated value c _h and the degree of overlap z _h . A fifth list D = [(c _h , z _h )] is generated, and the generated fifth list D is output and stored in the register 111 (list memory).

Next, the CPU 110 reads the eigenvalue element generation program 231 from the eigenvalue calculation program area 152 of the RAM 150 and executes it. The CPU 110 (eigenvalue element generation means) into which the eigenvalue element generation program 231 has been read first starts with the elements (a, b, p, a · m′−b ·) of the sixth list A ″ not yet checked from the register 111. m, a · m ′ + b · m) is read (step S31). Next, the CPU 110 determines whether or not a of the read element (a, b, p, a · m′−b · m, a · m ′ + b · m) is 1 or −1 ( Step S32a). If a is 1 or −1, the read element (a, b, p, a · m′−b · m, a · m ′ + b · m) is replaced with (a, p). Is stored in the register 111 and the process proceeds to step S33. On the other hand, if a is not 1 or −1, the CPU 110 adds the element (a · m′−b · m, z) or the fifth list D = [(c _h , z _h )] of the register 111 or Whether or not (a · m ′ + b · m, z ′) exists is searched (step S32c). If it is determined that it does not exist, the process proceeds to step S33, and if it is determined that it exists, it further specifies which one is present (step S32d). If it is determined that the elements (a · m′−b · m, z) and (a · m ′ + b · m, z ′) exist, the elements (a + b · i, z) and (a− b · i, z ′) and the element (a, b, p, a · m′−b · m, a · m ′ + b · m) is replaced with these two and output to the register 111, Store (step S32e). If it is determined that only the element (a · m′−b · m, z) exists, the element (a + b · i, z) is generated and the element (a, b, p, a · m ′) is generated. (−b · m, a · m ′ + b · m) is replaced with this and output to and stored in the register 111 (step S32f). If it is determined that only the element (a · m ′ + b · m, z ′) exists, the element (a−b · i, z ′) is generated and the element (a, b, p, a) is generated. (M′−b · m, a · m ′ + b · m) is replaced with this and output and stored in the register 111 (step S32g). Then, the process proceeds to step S33.

In step S33, the CPU 110 determines whether there is an element of the sixth list A ″ that has not been checked from the register 111 (step S33). Here, if it is determined that there is an element that has not been checked yet, the process returns to step S31. If it is determined that there is no element that has not been checked, the sixth list A in which the element of the register 111 is replaced. '' Is output through the bus 170 and the output unit 130, and the process ends.
FIG. 13 is a flowchart showing processing when the complex number setting program 362 is a program for generating a suitable complex number β by the above-described “random selection method”. In this case, steps S41 to S48 are executed instead of the above-described steps S27 to S33.

In step S41, the second list A ′ = [(a _j , b _j , p _j )] is input from the register 111 to the CPU 110 (complex number setting means) from which the complex number setting program 362 has been read. Then, a complex number β = m ′ + m · i is randomly generated (step S41), and a temporary list [(a _j · m′−b _j · m, a _j · m ′ + b _j · m)] is generated, Store in the register 111 (step S42). Then, the CPU110, the temporary list of register _{111 [(a j · m'-} b j · m, a j · m '+ b j · m)] searching, the temporary list _{[(a j} · m' _{-b j · m, a j ·} m '+ b j · m)] duplicate element is not or is determined (step S43). If it is determined that there is an overlapping element, the process returns to step S41. On the other hand, if it is determined that there is no overlapping of elements, the complex number β = m ′ + m · i randomly generated in step S41 is output to the register 111 and stored.

Next, the CPU 110 deletes the elements (a, b, p) (except for a = 1, −1) of the second list A ′ in the register 111 (a, b, p, a · m′−b · m, a · m ′ + b · m), and this sixth list A ″ is stored in the register 111 (step S44).
Next, the CPU 110 creates a list D (a pair of ½ times the unique value and the degree of overlap) obtained by halving the unique value of β · U + (β · U) ^* (step S45). This process is the same as step S30.
Next, the CPU 110 (eigenvalue element generation means) into which the eigenvalue element generation program 231 has been read is not yet checked from the register 111, but the elements (a, b, p, a · m′−b ·) of the second list A ′. m, a · m ′ + b · m) is read (step S46), and the element (a, b, p, a · m′−b · m, a · m ′ + b · m) is obtained by the same processing as in step S32. Is replaced (step S47). Then, the CPU 110 determines whether there is an element of the second list A ′ that has not been checked from the register 111 (step S48). If it is determined that there is an element that has not been checked yet, the process returns to step S46, and if it is determined that there is no element that has not been checked, the second list A in which the element of the register 111 is replaced. 'Is output through the bus 170 and the output unit 130, and the process ends.

<Example 4>
This embodiment is an example in which the method of this embodiment is applied to the unitary matrix U of the above-described third embodiment. In this embodiment, the complex number β is determined by using [a method of setting 2θ smaller than the minimum angle between eigenvalue candidates].
First, according to the same calculation as in Example 3, the list A is
[(−0.60000000,1), (0.28000000,1), (0.60000000,1)]
(Step S20),
List A '
[(−0.60000000, 0.80000000, 1), (0.28000000, 0.96000000, 1), (0.60000000, 0.80000000, 1)]
(Step S21).

Here, since there is a pair of (−0.60000000, 0.80000000, 1) and (0.60000000, 0.80000000, 1) in the list A ′, the process proceeds to step S27 (FIG. 11).
A list A ″ in which the elements of A ′ are rearranged in descending order of the first component is
[(0.60000000, 0.80000000, 1), (0.28000000, 0.96000000, 1), (−0.60000000, 0.80000000, 1)]
(Step S27).

Next, when ab′−a′b is calculated for all pairs of elements (a, b, p), (a ′, b ′, p ′) adjacent in the list A ″,
Since 0.35200000 and 0.80000000, 1/2 of the smaller 0.35200000 is taken, and m = 0.17600000 is set. From this, m ′ = √ (1−m ² ) = √ (1-0.176000000 ² ) = √0.969002400 = 0.98439017
And
β = 0.98439017 + 0.176000000i
(Step S28).

ここでも前と同様、Ｖ^＊を計算したり、Ｖ＋Ｖ^＊のすべての成分を計算したりする必要はない。
Ｖ＋Ｖ^＊をエルミート行列の固有値を求めるルーチンにかけると、−０．８９９６６８２０，０．２１３３３８５０，０．８９９６６８２０という単根が返ってくる。
これから、リストＤは、
［（−０．４４９８３４１０，１），（０．１０６６６９２５，１），（０．４４９８３４１０，１）］
となる（ステップＳ３０）。 Therefore, the list A ″ is rewritten as follows (step S29).
[(0.60000000, 0.80000000, 0.449883410, 0.731414310), (0.28000000, 0.96000000, 0.106669250.4445925), (−0.60000000, 0.80000000, −0.731414310, -0.44983410)]
Next, in step S30, V = β · U is calculated in the same manner as before.

As before, even here, you can calculate the V ^*, there is no need or to calculate all of the components of the V + V ^*.
When V + V ^* is applied to a routine for obtaining eigenvalues of the Hermitian matrix, single roots of −0.89966820, 0.213333850, and 0.89966820 are returned.
From now on, list D becomes
[(-0.449883410,1), (0.1066625,1), (0.449883410,1)]
(Step S30).

Thereafter, in steps S31 to S33, the elements of the list A ″ are replaced while referring to the list D. First, list A ″ elements (0.60000000, 0.80000000, 0.449883410, 0.731414310)
Since there is an element (0.44983410,1) in the list D and there is no element having 0.731414310 as the first component (step S32c), it is replaced with (0.60000000 + 0.80000000 · i, 1) ( Step S32f).

In addition, the element of the list A ″ (0.28000000, 0.96000000, 0.1066625, 0.444558925)
Since there is an element (0.1066625,1) in the list D and there is no element having 0.44458925 as the first component (step S32c), it is replaced with (0.28000000 + 0.96000000 · i, 1) ( Step S32f).
In addition, the element of the list A ″ (−0.60000000, 0.80000000, −0.731414310, −0.449883410)
Since there is an element (−0.44983410,1) in list D and there is no element having −0.731414310 as the first component (step S32c), (−0.60000000000−0.80000000000 · i) It is replaced (step S32f).

This completes the replacement of list A ''.
[(0.60000000 + 0.80000000 · i, 1), (0.28000000 + 0.96000000 · i, 1), (−0.60000000000−0.80000000 · i, 1)]
Is output and the process is terminated.
The present invention is not limited to the embodiments described above. For example, in the first embodiment, it is determined whether or not U is real (step S1). In the case of real, the eigenvalue of U is obtained by the processing of steps S2 and S3. Regardless of whether U is real or imaginary without providing a function, the process after step S4 may be performed to obtain the eigenvalue of U.

In step S29 and step S44 in the second embodiment, the elements (a, b, p) (except for a = 1, −1) of the sixth list A ″ are deleted (a, b, p, a · m′−b · m, a · m ′ + b · m), and using the element after the replacement, the determination in step S32c is performed. However, in step S32c, this element is not replaced. C = a · m′−b · m or c = a · m ′ + b · m may be calculated from the element (a, b, p), and the determination in step S32c may be performed using this c.
Since p = z + z ′ is satisfied, only c = a · m′−b · m is calculated in step S32c, and when (c, z) exists in the list D, q = z is set, If it does not exist, q = 0 may be set, and the (eigenvalue, overlap) of U may be output as (a + b · i, q) (a−bi, p−q).

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. Further, in this specification, an apparatus is a logical set configuration of a plurality of functions, and is not limited to one in which each function is in the same housing. Needless to say, other modifications are possible without departing from the spirit of the present invention.
The eigenvalue calculation program 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, as the magnetic recording device, a hard disk device, a flexible Discs, magnetic tapes, etc. as optical disks, DVD (Digital Versatile Disc), DVD-RAM (Random Access Memory), CD-ROM (Compact Disc Read Only Memory), CD-R (Recordable) / RW (ReWritable), etc. An MO (Magneto-Optical disc) or the like can be used as a magneto-optical recording medium, and an EEP-ROM (Electronically Erasable and Programmable-Read Only Memory) or the like can be used as a semiconductor memory.

The program is distributed by selling, transferring, or lending a portable recording medium such as a DVD or CD-ROM in which the eigenvalue calculation 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.
In each of the above-described embodiments, for example, a program recorded on a portable recording medium or a program transferred from a server computer is temporarily stored in its own hard disk device 140, and processing according to this program is described above. It is executed as follows. However, each time the program is transferred from the server computer to the eigenvalue calculation apparatus, the processing according to the received program may be executed sequentially. In addition, the above-described processing is executed by a so-called ASP (Application Service Provider) type service that realizes processing functions only by the execution instruction and result acquisition without transferring the program from the server computer to the eigenvalue calculation apparatus. It is good also as composition to do. 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.

  The present invention can be applied to eigenvalue calculation in the design of a quantum circuit of a quantum computer (for example, Hiromi Murakami, Yasuto Kawano, Hiroshi Sekikawa, “Generation of Quantum Circuit Using Cartan Decomposition”, 10th Quantum Information Technology (Refer to Research Materials, Electronic Information Society, Quantum Information Technology Timed Research Special Committee, May 2004.)

It is the block diagram which showed the basic composition of the eigenvalue calculation apparatus in this form. In the first embodiment, there is a pair (a, b, p), (−a, b, p ′) (a ≠ 0) in the list A ′, and (b, q), It is a figure for demonstrating the reason an eigenvalue cannot be specified when there exists a pair of (-b, q ') (b ≠ 0). It is the block diagram which illustrated the composition of the eigenvalue calculation device in a 1st embodiment. It is the conceptual diagram which illustrated the structure of the eigenvalue calculation program in 1st Embodiment. It is a flowchart for demonstrating the eigenvalue element production | generation process in 1st Embodiment. It is a flowchart for demonstrating the eigenvalue element production | generation process in 1st Embodiment. It is a flowchart for demonstrating the eigenvalue element production | generation process in 1st Embodiment. It is a figure which shows the case where rotation each (theta) is inappropriate in 2nd Embodiment. It is the conceptual diagram which illustrated the structure of the eigenvalue calculation program 300 in 2nd Embodiment. It is a flowchart for demonstrating the eigenvalue element production | generation process in 2nd Embodiment. It is a flowchart for demonstrating the eigenvalue element production | generation process in 2nd Embodiment. It is a flowchart for demonstrating the process of step S32 in FIG. It is a flowchart for demonstrating the eigenvalue element production | generation process in 2nd Embodiment.

Explanation of symbols

10,100 eigenvalue calculation device 11 Hermitian matrix calculation unit 12 Hermitian matrix eigenvalue calculation unit 13 list generation unit

Claims (12)

An eigenvalue calculation device for calculating an eigenvalue of a unitary matrix,
A Hermitian matrix calculating means for inputting a unitary matrix and calculating and outputting a Hermitian matrix that is the sum of the unitary matrix and its conjugate transpose matrix;
Hermitian matrix eigenvalue calculating means for inputting the Hermitian matrix and calculating and outputting the eigenvalue of the Hermitian matrix;
List generation means for receiving eigenvalues of the Hermitian matrix, multiplying the eigenvalues of the Hermitian matrix by a constant, and outputting the operation results;
An eigenvalue calculation apparatus characterized by comprising: An eigenvalue calculation device for calculating an eigenvalue of a unitary matrix U, comprising:
A first determination unit that receives the unitary matrix U and determines whether the unitary matrix U is an execution column;
A first Hermite matrix that receives the unitary matrix U and calculates and outputs a first Hermite matrix U + U ^* that is the sum of the unitary matrix U and the first conjugate transpose matrix U ^* that is the conjugate transpose matrix. A calculation means;
The first is a Hermitian matrix U + U ^* is input, a first Hermitian matrix eigenvalue calculation means which calculates and outputs the first eigenvalue is the first of a Hermitian matrix U + U ^* eigenvalues,
The first eigenvalue is input, the real part of the eigenvalue of the unitary matrix U is calculated by multiplying the first eigenvalue by 1/2, and the real part a _j (1 ≦ 1) of the calculated eigenvalue of the unitary matrix U j ≦ u, 1 ≦ u ≦ n, the unitary matrix U is an n × n matrix) and its redundancy p _j and a first list A = [(a _j , p _j )] is generated First list generation means for outputting;
If the unitary matrix U is determined to be a real matrix, the first list _{A = [(a j, p} j)] is inputted, the square root from the real part _{a j b j = √ (1-} ( a _j ) ² ), and the eigenvalue list [(a _j + b _j · i), p _j / 2], [(a _j −b _j · i), p _j / 2] (i is an imaginary unit) Second list generation means for generating and outputting the generated eigenvalue list;
An eigenvalue calculation apparatus characterized by comprising: An eigenvalue calculation device for calculating an eigenvalue of a unitary matrix U, comprising:
A first Hermite matrix that receives the unitary matrix U and calculates and outputs a first Hermite matrix U + U ^* that is the sum of the unitary matrix U and the first conjugate transpose matrix U ^* that is the conjugate transpose matrix. A calculation means;
The first is a Hermitian matrix U + U ^* is input, a first Hermitian matrix eigenvalue calculation means which calculates and outputs the first eigenvalue is the first of a Hermitian matrix U + U ^* eigenvalues,
The first eigenvalue is input, the real part of the eigenvalue of the unitary matrix U is calculated by multiplying the first eigenvalue by 1/2, and the real part a _j (1 ≦ 1) of the calculated eigenvalue of the unitary matrix U j ≦ u, 1 ≦ u ≦ n, the unitary matrix U is an n × n matrix) and its redundancy p _j and a first list A = [(a _j , p _j )] is generated First list generation means for outputting;
The first list A = [(a _j , p _j )] is input, and the square root b _j = √ (1− (a _j ) ² ) is calculated from the real part a _j , and the second list A ′ is calculated. = [(A _j , b _j , p _j )] and a second list generation means for outputting the generated second list A ′;
First product operation means for inputting the unitary matrix U and the imaginary unit i, calculating and outputting a product i · U of the unitary matrix U and the imaginary unit i,
The product i · U is input, and a second Hermitian matrix i · U + (i · U) which is the sum of the product i · U and a second conjugate transpose matrix (i · U) ^* which is the conjugate transpose matrix thereof. ) Second Hermite matrix calculating means for calculating and outputting ^* ,
The second Hermitian matrix i · U + (i · U) ^* is input, and a second eigenvalue that is an eigenvalue of the second Hermitian matrix i · U + (i · U) ^* is calculated and output. Hermitian matrix eigenvalue calculating means,
The second eigenvalue is input, the second eigenvalue is multiplied by -1/2, and the imaginary part b _k of the unitary matrix U (1 ≦ k ≦ v, 1 ≦ v ≦ n, the unitary matrix is n × n matrix), a third list B = [(b _k , q _k )] consisting of a pair of the calculated imaginary part b _k and its redundancy q _k is generated, and the generated first Third list generation means for outputting a list B of 3;
An eigenvalue calculation apparatus characterized by comprising: The eigenvalue calculation apparatus according to claim 3, wherein
The second list A ′ = [(a _j , b _j , p _j )] and the third list B = [(b _k , q _k )] are input and a list memory for storing them;
One element (a, b, p) is extracted from the second list A ′ = [(a _j , b _j , p _j )] in the list memory, and whether or not a = 0 and Second determination means for determining whether or not the element (−a, b, p ′) exists in the second list A ′;
When the second determination means determines that a = 0 or the element (−a, b, p ′) does not exist in the second list A ′, the element (a, b, p) Is extracted from at least one of the element (b, q) and the element (−b, q ′) from the third list B = [(b _k , q _k )] in the list memory; Eigenvalue element generating means for generating and outputting at least one of (a + b · i, q) and (ab−i, q ′);
An eigenvalue calculation apparatus characterized by comprising: The eigenvalue calculation apparatus according to claim 4, wherein
In the second determination means, if it is determined that the element (−a, b, p ′) (a ≠ 0) is present in the second list A ′, whether or not b = 0, and A third determination is made as to whether or not both the element (b, q) and the element (−b, q ′) exist in the third list B = [(b _k , q _k )] in the list memory. Determination means,
The eigenvalue element generation means includes
If it is determined by the third determination means that b = 0, the elements (a, b, p) and (−a, b, p ′) are input, and (a, p) and (−a , P ′) and output,
In the third determination means, it is determined that only one of the element (b, q) or the element (−b, q ′) exists in the third list B = [(b _k , q _k )]. In this case, b ′ which is b or −b determined to exist, and the elements (a, b, p) and (−a, b, p ′) are input, and (a + b ′ · i, p ) And (−a + b ′ · i, p ′) are generated and output.
An eigenvalue calculation device characterized by that. The eigenvalue calculation apparatus according to claim 5, wherein
Second product operation means for inputting the product i · U and the unitary matrix U, calculating and outputting a product i · U ² of the unitary matrix U and the product i · U;
The product i · U ² is input, and a third Hermitian matrix i · U ² that is the sum of the product i · U ² and a third conjugate transpose matrix (i · U ² ) ^* that is the conjugate transpose matrix thereof. Third Hermite matrix calculating means for calculating and outputting + (i · U ² ) ^* ;
The third Hermite matrix i · U ² + (i · U ² ) ^* is input, and a third eigenvalue that is an eigenvalue of the third Hermite matrix i · U ² + (i · U ² ) ^* is calculated. A third Hermitian matrix eigenvalue calculating means for outputting
The third eigenvalue is input, and the third eigenvalue is multiplied by −1/4 to obtain a real part a _g (1 ≦ g ≦ w, 1 ≦ w ≦ n) and an imaginary part b of the eigenvalue of the unitary matrix U. calculating a product _{a g} · _b g and _g, a fourth list of consisting calculated with the product _{a g} · _b g from the multiplicity _{r g} and the pair _{C = [(a g · b} g, r g) And a fourth list generation means for outputting the generated fourth list C;
Have
The list memory is
Furthermore, the fourth list C is stored,
The eigenvalue element generation means includes
In the third determination means, the element (b, q) (b ≠ 0) and the element (−b, q ′) are added to the third list B = [(b _k , q _k )] in the list memory. Are determined to exist together,
A pair of the element (a, b, p) and (−a, b, p ′) is extracted from the second list A ′ = [(a _j , b _j , p _j )] in the list memory. Then, the element (b, q) is extracted from the third list B = [(b _k , q _k )], and from the fourth list C = [(a _g · b _g , r _g )]. The element (a · b, r) corresponding to a · b is extracted, s = (− p ′ + q + r) / 2 is calculated, and (a + bi, s), (a−bi, p−s), (− a + bi, q−s) and (−a−bi, rs−), and the generated (a + bi, s), (a−bi, ps), (−a + bi, q−s) and (− a-bi, rs).
An eigenvalue calculation device characterized by that. An eigenvalue calculation device for calculating an eigenvalue of a unitary matrix U, comprising:
A first Hermite matrix that receives the unitary matrix U and calculates and outputs a first Hermite matrix U + U ^* that is the sum of the unitary matrix U and the first conjugate transpose matrix U ^* that is the conjugate transpose matrix. A calculation means;
The first is a Hermitian matrix U + U ^* is input, a first Hermitian matrix eigenvalue calculation means which calculates and outputs the first eigenvalue is the first of a Hermitian matrix U + U ^* eigenvalues,
The first eigenvalue is input, the real part of the eigenvalue of the unitary matrix U is calculated by multiplying the first eigenvalue by 1/2, and the real part of the eigenvalue of the unitary matrix a _j (1 ≦ j ≦ u, 1 ≦ u ≦ n) and the first list generating means for generating and outputting a first list A = [(a _j , p _j )] consisting of pairs of the duplication degree p _j ;
The first list A = [(a _j , p _j )] is input, and the square root b _j = √ (1− (a _j ) ² ) is calculated from the real part a _j , and the second list A ′ is calculated. = [(A _j , b _j , p _j )], and the second list generation means for outputting the generated second list A ′;
Complex number setting means for setting and outputting a complex number β = m ′ + m · i (i is an imaginary unit, (m ′) ² + m ² = 1);
Third product operation means for inputting the unitary matrix U and the complex number β, and calculating and outputting a product β · U of the unitary matrix U and the complex number β;
The product β · U is input, and a fourth Hermitian matrix β · U + (β · U) which is the sum of the product β · U and its fourth conjugate transpose matrix (β · U) ^*. ) Fourth Hermite matrix calculating means for calculating and outputting ^* ,
The fourth Hermitian matrix β · U + (β · U) ^* is input, and a fourth eigenvalue that is an eigenvalue of the fourth Hermitian matrix β · U + (β · U) ^* is calculated and output. Hermitian matrix eigenvalue calculating means,
The fourth eigenvalue is input, and a value c _h (1 ≦ h ≦ x, 1 ≦ x ≦ n, the unitary matrix is an n × n matrix) is calculated by halving the fourth eigenvalue. A fifth list D = [(c _h , z _h )] consisting of a pair of the value c _h and its redundancy z _h is output, and the generated fifth list D is output. Generating means;
The second list A ′ = [(a _j , b _j , p _j )] and the fifth list D = [(c _h , z _h )] are input, and a list memory for storing them;
Information indicating m ′, m, a, b is input, and the element (a · m′−b · m, z) or (a · m ′ + b · m, z ′) exists in the fifth list D If the element (a · m′−b · m, z) exists in the fifth list D, (a + b · i, z) is generated and output. When (a · m ′ + b · m, z ′) exists, eigenvalue element generation means for generating and outputting (a−b · i, z ′),
An eigenvalue calculation apparatus characterized by comprising: The eigenvalue calculation apparatus according to claim 7, wherein
The complex number setting means includes:
A sixth list A ″ is generated by rearranging the elements of the second list A ′ = [(a _j , b _j , p _j )] in the order of the size of a _j , and the sixth list A ′ A · b′−a ′ · b is calculated for all pairs of adjacent elements (a, b, p) and (a ′, b ′, p ′) of ′, and ½ of the minimum value Is a means for calculating m ′ = √ (1−m ² ) and setting and outputting the complex number β = m ′ + m · i.
An eigenvalue calculation device characterized by that. The eigenvalue calculation apparatus according to claim 7, wherein
The complex number setting means includes:
The second list A ′ = [(a _j , b _j , p _j )] is input, a complex number β = m ′ + m · i is randomly generated, and a temporary list [(a _j · m′−b _j M, a _j · m ′ + b _j · m)], and the temporary list [(a _j · m′−b _j · m, a _j · m ′ + b _j · m)] has duplicate elements. A means for outputting the randomly generated complex number β = m ′ + m · i when there is no overlapping of elements.
An eigenvalue calculation device characterized by that. A unitary matrix eigenvalue calculation method for executing a computer by causing a computer to function as an eigenvalue calculation device having Hermitian matrix calculation means, Hermitian matrix eigenvalue calculation means, and list generation means ,
Hermitian matrix calculation means calculates and outputs a Hermitian matrix that is the sum of the input unitary matrix and its conjugate transpose matrix;
Hermite matrix eigenvalue calculating means calculates and outputs eigenvalues of the Hermitian matrix for the Hermitian matrix output from the Hermitian matrix calculating means ;
A list generating means multiplying the eigenvalue of the Hermitian matrix output from the Hermitian matrix eigenvalue calculating means by a constant, and outputting the calculation result;
An eigenvalue calculation method characterized by comprising:   An eigenvalue calculation program for causing a computer to function as the eigenvalue calculation apparatus according to claim 1.   A computer-readable recording medium storing the eigenvalue calculation program according to claim 11.

Images