量子计算 15 量子电路复杂度
- 1 量子电路复杂度 (Quantum circuit complexity)
- 定义: U U U的量子电路复杂度 C ( U ) = \mathcal{C}(U)= C(U)=实现 U U U电路所需要的最小的量子门数量
- 定理: C ( U ) = Ω ( 4 n ) \mathcal{C}(U)=\Omega(4^n) C(U)=Ω(4n) 对几乎所有的n-qubit U U U
- Proof: Counting argument
- 几乎所有的布尔函数 f : { 0 , 1 } n → { 0 , 1 } f: \{0,1\}^n\rightarrow\{0,1\} f:{0,1}n→{0,1}需要 Ω ( 2 n n ) \Omega(\frac{2^n}{n}) Ω(n2n)个AND/OR/NOT逻辑门
- 定理: C ( U ) = Ω ( exp ( n ) ) \mathcal{C}(U)=\Omega(\exp(n)) C(U)=Ω(exp(n)) 来近似表达n-qubit U U U (仅用有限个量子门,近似通用门)
- The Solovay-Kitaev Theorem O ( 4 n ( log 1 ε ) 3.97 ) O(4^n(\log\frac{1}{\varepsilon})^{3.97}) O(4n(logε1)3.97)
- 2 量子优越性实验 (Quantum Supremacy Experiments)
- 3 量子查询复杂性 (Quantum Query Complexity)
有了通用门的概念,就该讨论量子电路的复杂度了;我们要讨论的是,要用量子电路实现一个n-qubit的酉变换U,需要多少个1-qubit或2-qubit的门电路。
1 量子电路复杂度 (Quantum circuit complexity)
定义: U U U的量子电路复杂度 C ( U ) = \mathcal{C}(U)= C(U)=实现 U U U电路所需要的最小的量子门数量
在上回书,我们讨论了量子通用门
{
CNOT
,
all 1-qubit gates
}
\{\text{CNOT}, \text{ all 1-qubit gates}\}
{CNOT, all 1-qubit gates},对于n-qubit的酉矩阵
U
U
U,其维度为
2
n
×
2
n
2^n\times 2^n
2n×2n,将其使用Givens rotation分解得到
4
n
4^n
4n个二维酉矩阵,建立每个小矩阵的计算量为
O
(
n
)
O(n)
O(n),则对于n-qubit的酉矩阵
U
U
U,其复杂度为:
C
(
U
)
=
O
(
n
4
n
)
\mathcal{C}(U)=O(n4^n)
C(U)=O(n4n) 指数的复杂度是相当可怕的,单几百个量子比特的复杂度就大于宇宙已知粒子的数量了。这个上界能不能更tight一些呢?
定理: C ( U ) = Ω ( 4 n ) \mathcal{C}(U)=\Omega(4^n) C(U)=Ω(4n) 对几乎所有的n-qubit U U U
所以,当量子比特数量增加的时候,量子电路的复杂度也将指数型的增长。
Proof: Counting argument
- Proof I: 所有的 n-qubit 酉变换等价于一个
4
n
4^n
4n维的manifold
每个 2 n × 2 n 2^n\times 2^n 2n×2n的酉矩阵,需要 4 n 4^n 4n个量子幅,每个量子幅有两个实数,但由于酉矩阵的限制,所以自由度还是 4 n 4^n 4n; - Proof II: T个量子门等价于一个
4
T
4T
4T维的manifold
每个1-qubit量子门的维度是 2 × 2 2\times 2 2×2需要4个实数描述; - 因此想要用 4 T 4T 4T维的量子门来覆盖 4 n 4^n 4n的酉矩阵,需要 T = Ω ( 4 n ) T=\Omega(4^n) T=Ω(4n)
几乎所有的布尔函数 f : { 0 , 1 } n → { 0 , 1 } f: \{0,1\}^n\rightarrow\{0,1\} f:{0,1}n→{0,1}需要 Ω ( 2 n n ) \Omega(\frac{2^n}{n}) Ω(n2n)个AND/OR/NOT逻辑门
同样的,n-bit的布尔函数有 2 n 2^n 2n个输入,每个都对应两个不同的输出,因此共有 2 2 n 2^{2^n} 22n个布尔函数;而T个逻辑门,共有 ( n + T ) O ( T ) (n+T)^{O(T)} (n+T)O(T)个;由 2 2 n = ( n + T ) O ( T ) 2^{2^n}=(n+T)^{O(T)} 22n=(n+T)O(T)可证上述结论;
定理: C ( U ) = Ω ( exp ( n ) ) \mathcal{C}(U)=\Omega(\exp(n)) C(U)=Ω(exp(n)) 来近似表达n-qubit U U U (仅用有限个量子门,近似通用门)
The Solovay-Kitaev Theorem O ( 4 n ( log 1 ε ) 3.97 ) O(4^n(\log\frac{1}{\varepsilon})^{3.97}) O(4n(logε1)3.97)
如果要 ε \varepsilon ε近似任意一个n-qubit酉矩阵U,需要 O ( 4 n ( log 1 ε ) 3.97 ) O(4^n(\log\frac{1}{\varepsilon})^{3.97}) O(4n(logε1)3.97)个量子门( G ∈ S → G − 1 ∈ S G\in \mathcal{S}\rightarrow G^{-1}\in \mathcal{S} G∈S→G−1∈S);如果使用一些特殊的"natural"通用门,复杂度会变为 O ( 4 n ( log 1 ε ) 1 ) O(4^n(\log\frac{1}{\varepsilon})^{1}) O(4n(logε1)1)
2 量子优越性实验 (Quantum Supremacy Experiments)
有个方法是,随机选择一些量子门构成一个量子电路 C C C,以产生一个n-qubit的纠缠的量子态 ∣ ψ ⟩ = ∑ x ∈ { 0 , 1 } n α x ∣ x ⟩ |\psi\rangle=\sum_{x\in \{0,1\}^n}\alpha_x|x\rangle ∣ψ⟩=∑x∈{0,1}nαx∣x⟩,然后在 { ∣ 0 ⟩ , ∣ 1 ⟩ } \{|0\rangle,|1\rangle\} {∣0⟩,∣1⟩}基上测量,结果就是从一个n-bit string的分布 D c \mathcal{D}_c Dc的采样结果,而根据玻恩准则string x的概率 P ( x ) = ∣ α x ∣ 2 P(x)=|\alpha_x|^2 P(x)=∣αx∣2,然后通过一些概率检查其完成度。然后再说经典计算机如果从同样的分布 D c \mathcal{D}_c Dc中采样需要 2 n 2^n 2n的时间。
如何建立这个量子电路 C C C呢?就均匀随机的挑选 n 2 n^2 n2个1\2 qubit个门。这虽然不能产生完全随机的 2 n × 2 n 2^n\times 2^n 2n×2n的酉变换,但是看起来是随机的。。。通过这个量子电路得到的量子态 ∣ ψ ⟩ = C ∣ 0 n ⟩ |\psi\rangle=C|0^n\rangle ∣ψ⟩=C∣0n⟩看起来会像是一个 C 2 n \mathcal{C}^{2^n} C2n里面的单位向量,及其量子幅分量会像是服从独立高斯分布。
有可能,最后的结果会因为一些destructive的干涉,让一些结果的可能性比另一些结果更大,这是量子计算里面的特有特点,而为了评价这个量子的结果,即一些采样
x
1
,
…
,
x
k
x_1,\dots,x_k
x1,…,xk,量子电路
C
C
C和
2
n
2^n
2n时间,定义LXEB(linear cross entrophy benchmark)
LXEB
=
2
n
k
∑
i
=
1
k
∣
⟨
0
n
∣
x
i
⟩
∣
2
\text{LXEB}=\frac{2^n}{k}\sum_{i=1}^{k}|\langle0^n|x_i\rangle|^2
LXEB=k2ni=1∑k∣⟨0n∣xi⟩∣2 经典的随机抽样结果会得到LXEB=1;而理想的量子计算机结果会是LXEB=2;
猜想: 没有经典算法可以很快的输出采样使得LXEB略大于1;
Google在2019年做了这个实验,用了53个qubit,超导芯片Sycamore,深度为20的量子电路;得到了LXEB
≈
1.002
\approx1.002
≈1.002;
中国科大重复了这个实验,用了60个qubit,深度为24的量子电路,得到了
≈
1.0007
\approx1.0007
≈1.0007
中国科大还做了玻色子采样来验证量子优越性:
因此,量子优越性现在是否实现,还取决于经典计算机是否能突破目前量子计算机。目前,还没有任何量子计算加速来能用来解决实际问题!
3 量子查询复杂性 (Quantum Query Complexity)
由于确定要建立的 U U U的量子电路复杂度 C ( U ) \mathcal{C}(U) C(U)也超级难,近似于 P = N P P=NP P=NP的问题。因此目前我们讨论量子算法用到的模型为量子查询复杂性。
我们就假设函数 f f f就是个黑箱,我们感兴趣的是需要调用其几次才能了解一些 f f f的性质。
经典示例
要计算 f ( 1 ) f ( 2 ) + ( 1 − f ( 1 ) ) f ( 3 ) f(1)f(2)+(1-f(1))f(3) f(1)f(2)+(1−f(1))f(3),我们仅需要调用两次函数 f f f,第一次查询 f ( 1 ) f(1) f(1),第二次根据情况查询 f ( 2 ) f(2) f(2)或者 f ( 3 ) f(3) f(3)。
要知道 ,这个查询复杂度最多也就是 N = 2 n N=2^n N=2n,因为最多也就 2 n 2^n 2n个输出。
要区别 f f f以及我们调用 f f f的算法或者函数。
XOR Oracle
即用uncomputing来实现可逆变换:
Phase Oracle
∣ x , b ⟩ → ( − 1 ) f ( x ) b ∣ x , b ⟩ |x,b\rangle\rightarrow(-1)^{f(x)b}|x,b\rangle ∣x,b⟩→(−1)f(x)b∣x,b⟩这里的Phase Oracle和签名的XOR Oracle其实等价。
可以看到,XOR oracle把查询结果编码进了answer qubit中,而Phase oracle则将结果编入了phase中。