自学内容网 自学内容网
自学内容网 > 正文

量子奇异值阈值算法

🕗 发布于 2024-11-19 20:41 算法  阈值算法  量子奇异阈值分解  奇异值分解  

        特征值分解只适用于方阵，如何扩展到任意形状的矩阵呢？奇异值分解能够解决此问题。量子奇异值阈值算法在奇异值分解的基础上将小的特征值设置为0，从而将小的特征值及其对应的特征向量去掉，进而降低矩阵的秩，达到降维的目的。

奇异值阈值算法

     假设A是一个M\times N的矩阵，A 的秩记为rank(A)=R。A的奇异值分解是指存在满足UU^{T}=I和VV^{T}=I的矩阵U=(u_{0},u_{1}...u_{M-1})\in R^{M\times M}和V=(v_{0},v_{1}...v_{M-1})\in R^{N\times N}

以及对角矩阵\Lambda =diag(\lambda _{1},\lambda _{2},...\lambda _{R-1},0,0,0)\in R^{M\times N}，使得下式成立

                                                                 A=U\Lambda V^{T}                                                            (1)    

其中\lambda _{1},\lambda _{2},...\lambda _{R-1}为A 的奇异值，u0...和v0...分别为左右奇异量，则A的分解为

                                ​​​​​​​            A=U_{R}\Lambda _{R}V_{R}^{T}=\sum_{R=0}^{R-1}\lambda _{r}u_{r}v_{r}^{T}                                             (2)    

实验

实验中为了简化线路的设计与实现，假设A是方阵，进而可以设置\tilde{A}=A此时奇异值就是特征值，左右奇异值向量就是特征向量。使用的矩阵为

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​            A=\begin{pmatrix} 1.5 & 0.5\\ 0.5 & 1.5 \end{pmatrix}                        

其奇异值\lambda _{1} = 2和\lambda _{1} = 1，对应的左右奇异向量分别为

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​                        |u_{0}\rangle= |v_{0}\rangle=\frac{1}{\sqrt{2}}(1,1)^{T}                                                (3)    

和

        ​​​​​​​        ​​​​​​​        ​​​​​​​                               |u_{1}\rangle= |v_{1}\rangle=\frac{1}{\sqrt{2}}(1,-1)^{T}                                             (4) 

则算法输入为矩阵A的归一化形式：

        ​​​​​​​        ​​​​​​​        |\varphi \rangle = \frac{1.5}{\sqrt{5}}|00\rangle+ \frac{0.5}{\sqrt{5}}|01\rangle+ \frac{0.5}{\sqrt{5}}|10\rangle+\frac{1.5}{\sqrt{5}}|11\rangle=\frac{1}{2\sqrt{5}}(3,1,1,3)^{T}           (5) 

假设阈值\tau =0.8，使得矩阵A的两个特征值在U_{\lambda ,\tau }执行前后的比例从

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​    \frac{\lambda _{1}}{\lambda _{2}}=\frac{2}{1}

变成

        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​​​        ​​​​​\frac{1-\tau /\lambda _{1}}{1-\tau /\lambda _{2}}=\frac{3}{1}

第一步：制备初始态

        ​​​​​​​        ​​​​​​​        ​​​​​​​        |q_{1}q_{2}q_{3}q_{4}q_{5}\rangle=\frac{1}{\sqrt{5}}(2|u_{0}\rangle|v_{0}\rangle+1|u_{1}\rangle|v_{1}\rangle)|000\rangle                              (6) 

第二步：利用相位估计将矩阵A 的特征值提取到q_{1}和q_{2}上，量子态演化为

        ​​​​​​​             ​​​​​​​          ​​​​​​​|q_{1}q_{2}q_{3}q_{4}q_{5}\rangle=\frac{1}{\sqrt{5}}(2|u_{0}\rangle|v_{0}\rangle|01\rangle+1|u_{1}\rangle|v_{1}\rangle|10\rangle)|0\rangle                     (7) 

这里，将算子e^{iAt}张量上单位矩阵I_{2\times 2}将其扩展到4*4的矩阵，其实只需要将e^{iAt}作用到q_{3}即可。

第三步：通过CNOT门将矩阵A的特征值由|01\rangle和|10\rangle变为|11\rangle和|10\rangle，完成对奇异值的阈值变换，此时量子态演化为

        ​​​​​​​        ​​​​​​​        ​​​​​​​      |q_{1}q_{2}q_{3}q_{4}q_{5}\rangle=\frac{1}{\sqrt{5}}(2|u_{0}\rangle|v_{0}\rangle|11\rangle+1|u_{1}\rangle|v_{1}\rangle|10\rangle)|0\rangle

这一步很关键，使得特征值由|01\rangle=|2\rangle和|10\rangle=|1\rangle，变成了|11\rangle=|3\rangle和|10\rangle=|1\rangle。

第四步：对q_{0}进行受控旋转，将新的奇异值相关的信息提取到q_{0}的概率幅上

第五步：执行第二步和第三步的逆操作，解除q_{1}和q_{2}与其他量子的纠缠。

        在qasm仿真中添加measure语句会改变最终的测量结果，与理论值有略微的偏差，而不加测量语句，通过自动测量，仿真值与理论值基本吻合。原因还没有找到，但是可以猜测，通过measure语句，当某一条线路已经没有量子逻辑门了，测量便直接进行，而其他的线路仍有量子逻辑门，可能是这样的测量导致了偏差，而统一在所有逻辑门执行完成后测量的值与理论值基本吻合略微好。然而，测量得到的00001，01001，10001，11001的振幅分别为0.0003，0.00009，0.00008，0.00042。特征值比例为3：1，与理论有一定误差。

 

#量子奇异值阈值分解
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile
from qiskit_aer import Aer
import numpy as np
from qiskit.visualization import plot_histogram

from math import pi
from qiskit.visualization import plot_histogram
# 创建一个量子电路，包含 4 个量子比特和 4 个经典比特
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi

qreg_q = QuantumRegister(5, 'q')
creg_c = ClassicalRegister(5, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)

circuit.h(qreg_q[3])
circuit.h(qreg_q[2])
circuit.h(qreg_q[1])
circuit.x(qreg_q[3])
circuit.cu(0.635, 0, 0, 0, qreg_q[3], qreg_q[4])
circuit.x(qreg_q[3])
circuit.cu(2.5, 0, 0, 0, qreg_q[3], qreg_q[4])
circuit.cu(-pi / 2, -pi / 2, pi / 2, 0, qreg_q[2], qreg_q[3])
circuit.u(3 * pi / 4, 0, 0, qreg_q[2])
circuit.cx(qreg_q[1], qreg_q[3])
circuit.swap(qreg_q[1], qreg_q[2])
circuit.h(qreg_q[2])
circuit.cu(-pi / 2, 0, 0, 0, qreg_q[1], qreg_q[2])
circuit.h(qreg_q[1])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.cu(-pi / 16, 0, 0, 0, qreg_q[1], qreg_q[0])
circuit.cu(-pi / 32, 0, 0, 0, qreg_q[2], qreg_q[0])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.h(qreg_q[1])
circuit.cu(pi / 2, 0, 0, 0, qreg_q[1], qreg_q[2])
circuit.h(qreg_q[2])
circuit.swap(qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[1], qreg_q[3])
circuit.h(qreg_q[1])
circuit.u(-3 * pi / 4, 0, 0, qreg_q[2])
circuit.cu(-pi / 2, pi / 2, -pi / 2, 0, qreg_q[2], qreg_q[3])
circuit.h(qreg_q[2])
circuit.measure(qreg_q[0], creg_c[0])
circuit.measure(qreg_q[1], creg_c[1])
circuit.measure(qreg_q[2], creg_c[2])
circuit.measure(qreg_q[3], creg_c[3])
circuit.measure(qreg_q[4], creg_c[4])
# Draw the circuit
circuit.draw(output='mpl')

 


原文地址：https://blog.csdn.net/m0_54373077/article/details/143801123

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

自学内容网
Copyright © 2015-2024