跳到内容

肖的算法

介绍

肖的算法可能是最著名的量子算法。首次出版于1994年,它通常是推动了量子计算发展的兴趣高涨,我们近来一直享受。就像西蒙的算法,肖的实际上是一个混合动力算法:它涉及到一些经典预处理,然后一个量子子例程,然后一些古典后处理。这也是迭代:它可以采取几轮算法来找到正确的答案。

它解决的问题很简单:

一些非优质整数\ (N \),找到一个比1大的整数和不足\ (N \)将它均匀。

更正式,它解决的问题是找到一个整数\ \ ()这样\ (N / a = b \),在那里\ (1 < < N \)\ (b \)也是一个整数。

这个问题被称为整数分解问题,计算,是极难解经典计算机。对于每一个您增加的大小\ (N \)需要两倍的时间,找到一个解决方案。整数分解是一个指数级的困难问题;它分为NP算法。

这个属性的问题使得它非常有用的密码学和安全。许多我们今天使用非对称密钥加密算法,如RSA,依靠这个财产提供安全:如果你有\ \ (),很容易检查它是否分歧\ (N \)很快,但如果你有\ (N \),这是不切实际的\ \ ()没有只是猜测和尝试随机数,直到你找到它。

今天这种加密使用无处不在!例如,HTTPS协议使用它来确保你所有的网络流量,这样人们在运输过程中不能捕获它,读它,监视你。真的:去任何HTTPS网站,点击旁边的小锁图标在您的浏览器URL,看看连接细节。你会看到这样的:

你会看到类似的东西TLS_ECDHE_RSA_WITH_AES_12_GCM_SHA256的事情——如果它包括短语RSAECDHECDSA使用非对称加密,那么它的。

肖的算法很重要的原因是它使用一个量子计算机在多项式时间内解决整数分解。换句话说,它可以快速有效地与经典计算机——曾经几年千的五次方现在需要10秒。把它从一个NP到一个问题P问题。

实事求是地说,这意味着一个足够强大的量子计算机可以使用这个算法将非对称加密,所以有人用一个机器可以读你所有的互联网流量。这意味着他们可以窃取你的密码,进入你的银行信息,猫的视频上传到Youtube在您的帐户…和几乎其他任何涉及你的身份的安全。你可以想象一下,这对安全状况有相当深远的影响我们今天使用的几乎所有通信技术。

完全如何它是一个非常复杂的问题,但我们要通过整个的事情,一步一步。在本节中,您将拥有你所需要的一切为了实现肖在代码的算法。

毫无疑问,这是最后的老板的量子算法。一旦你学会如何做到这一点,你将能够理解和实现任何量子算法。

首先,让我们谈谈模幂运算

模幂运算函数

模块化求幂指函数,这种形式:

\ [y = x ^ \ mod b \]

在哪里\ \ (),\ (b \),\ \ (x),\ (y \)都是整数,在哪里\ \ (mod {} \)指的是模运算符\ (x y \ \ mod)仅仅意味着“分\ \ (x)通过\ (y \),并返回剩余部分作为输出”。作为一个简单的例子,让\ (a = 11 \)\ (b = 21 \);的输出函数看起来像这样:

\[开始\ displaylines{\{对齐}11 ^ 0 \ mod 21 & = 1 \ \ ~ \ \ 11 ^ 1 \ mod 21 & = 11 \ \ ~ \ \ 11 ^ 2 \ mod 21 & = 16 ~ \ \ \ \…结束\{对齐}}\]

是模块化的本质功能,其余不能比模量(你值除以)所以每个输出将受到规则的约束le y < b \ (0 \ \)。实际的术语x \ \ (^)可能是绝对巨大的并采取数十亿字节存储,但是\ \ (mod b \)意味着最后结果总是小于\ (b \)。因为这个性质,我们有很多非常有效的经典算法快速计算为任意值,即使是大得离谱的值\ \ (x)

二进制替代技术

我们旅程的第一步肖的算法是将这个函数表示为一个量子电路。具体地说,我们想要实现这一目标设置:

\[\刃{x, y} = {modexp} \文本(\ \ {x}, {0}, a, b) \]

所以modexp将四个参数:

  • 一个输入寄存器的值\ \ (x)(可叠加)
  • 一个将输出寄存器\ (y \)
  • 的值\ \ ()这是一个经典的整数,而不是一个量子位注册吗
  • 的值\ (b \)这是一个经典的整数,而不是一个量子位注册吗

注意,这不是一个就地操作像QFT;这使用其他方法,有两个不同的输入和输出寄存器和计算将缠绕在一起。

描述如何实现它,我们要在一个整洁的小技巧,从一个有趣的事实,我们提出在刚开始上课的时候,当我们走过去的先决条件。让我们来谈谈二进制数一次。

回想一下,在高位优先符号,可以将任意二进制数分解如下:

\ [x = x_0 \ cdot 2 ^ {n} + x_1 \ cdot 2 ^ {2} +……+间{n} \ cdot 2 ^ 0 \]

例如,13号在二进制小数可以这样写:

\ [\ displaylines{\{对齐}开始13 & = 8 + 4 + 1 \ \ ~ \ \ & = 1 \ cdot 8 + 1 \ cdot 4 + 0 \ cdot 2 + 1 \ cdot 1 \ \ ~ \ \ & = 1 \ cdot 2 ^ 3 + 1 \ cdot 2 ^ 2 + 0 \ cdot 2 ^ 1 + 1结束\ cdot 2 ^ 0 \{对齐}}\]

因此,13是1101的二进制版本。

现在,让我们重写模幂运算函数取代\ \ (x)这个二进制扩展:

\[开始\ displaylines{\{对齐}y & = ^ x \ mod b \ \ ~ \ \ & = ^ {x_0 \ cdot 2 ^ {n} + x_1 \ cdot 2 ^ {2} +……+间{n} \ cdot 2 ^ 0} \ mod b \结束{对齐}}\]

使用产品的倡导者,我们可以把一系列的乘法是这样的:

\ [= ^ {x_0 \ cdot 2 ^ {n}} \ cdot ^ {x_1 \ cdot 2 ^ {n}} \ cdot…\ cdot ^{间{n} \ cdot 2 ^ 0} \ mod b \]

现在,因为模运算符分配这样,我们可以重写:

\[= \离开(^ {x_0 \ cdot 2 ^ {n}} \ mod b \) \ cdot \离开(^ {x_1 \ cdot 2 ^ {n}} \ mod b \) \ cdot \离开(…左\)\ cdot \(^{间{n} \ cdot 2 ^ 0} \ mod b \) \ mod b \]

正如你所看到的,我们整个乘方转换成一系列的乘法。为了节省空间,所以只有一个寄存器(即输入是一样的这是一个输出就地乘法),我们可以设置的输入1最初是这样的:

\[= \左(\左(左1 \ cdot \ (^ {x_0 \ cdot 2 ^ {n}} \ mod b \) \ mod b \右)左\ cdot \ (^ {x_1 \ cdot 2 ^ {n}} \ mod b \) \ mod b \右)……\]

太棒了!现在我们需要做的模块化的乘法。如果我们有一个办法,我们可以计算出模幂运算的功能。我们会在一分钟内,但是现在,让我们展示另一个整洁的技巧。

量子模幂运算

看看会发生什么时这些术语之一\ (x_i \)是0:

\ [\ displaylines{{对齐}\ \开始刃{r ^ \ '} & = \离开(\刃{r} \ cdot ^ {0 \ cdot 2 ^ {n-i-1}} \ mod b \) \ mod b \ \ ~ \ \ & = \离开(\刃{r} \ cdot ^ 0 \ mod b \) \ mod b \ \ ~ \ \ & = \离开(\刃{r} \ cdot 1 \ mod b \) \ mod b \ \ ~ \ \ & = \离开(\刃{r} \ mod b \) \ mod b \ \ ~ \ \ & = \刃{对齐}}{r} \结束\]

我们知道r \(\刃{}= \刃{r} \ mod b \)开始,由于初始值是1,每个乘法之后都是模块化的。因此,对于比特\ (x_i = 0 \)模块化的乘法词实际上不会做任何事情。

把这变成一个算法,我们需要的是这样的一种机制:

如果量子位是0,不要做任何事情;如果量子位是1,做一个就地模块化的乘法

我们确实有这样的一种机制控制操作!

我们正在寻找的是一个控制模乘法操作。如果我们有一个满足这种形式的量子版本:

\[\刃{r ^ \ '} = \离开(\刃{r} \ cdot c \) \ mod b \]

然后我们可以使用它在这个电路:

这是电路量子模幂运算

这里要注意几件事情:

  • 输入注册\ \(刃{x} \)持有价值\ \ (x)的指数\ (y = x ^ \ mod b \)
  • 输出寄存器\ \(刃{o} \)从值1,根据需要,然后链一堆控制模乘法(控制输入的每个量子位\ \ (x))。
  • 每个模乘法是参数化的\ (c \)——这是预先计算的经典计算机和传递到函数。每个模块的实际电路乘法会有所不同,因为它取决于此\ (c \)价值。
  • 因为这个使用一个迭代ModMul对于每一个输入,它与输入的大小尺度线性\ \ (x)在比特——换句话说,这是指数增长更快比计算模指数为经典,因为如果你把大量的输入\ \ (x)成一个统一的叠加,量子可以计算所有可能的值。

请注意

为了实现这一点,我们必须实现的ModMul函数。这当然是可行的(事实上,问#有一个实现的函数库),但它遵循相同的概念,因为你刚刚看到的。最终归结为不同的模块,并为了这个类,我们将跳过它。如果你有兴趣,我们鼓励你看其背后的理论在你自己的。

好的,我们有一个量子模幂运算的功能。这涉及到如何整数分解吗?我们将到达那里,但接下来我们谈谈时期发现。

找到模幂运算的时间

模幂运算函数有一个有趣的特点:如果\ \ ()\ (b \)互质(也就是说,他们不共享任何常见的因素除了1),函数的输出周期(周期性-它有一个模式永远重复)。

继续前面的例子中,假设\ (a = 11 \)\ (b = 21 \)。11和21是互质,因为他们没有任何因素共同之处。这是模幂运算值的表我们经历的值\ \ (x):

\ \ (x) x \ \(^ 11日国防部21 \)
0 1
1 11
2 16
3 8
4 4
5 2
6 1
7 11
8 16
9 8

\ (a = 11 \)\ (b = 21 \)模式(1、11、16、8、4、2)重复,直到永远。这个模式包含6项,所以我们说函数x \ \(^ 11日国防部21 \)周期6(也称为订单6)。

更普遍的是,模块化exponentation的周期函数的最小值\ (p \)满足方程:

\ [^ p \ b mod = 1, \ qquad p > 0 \]

这是因为模幂运算时总是从1开始指数为0;因此,任何的价值\ (p \)大于0,结果在一个1表示的开始一个新的序列的重复。一旦你达到重复,你知道前面的值是0\ (p - 1 \)(这是\ (p \)总值),因此\ (p \)告诉你的数量条款的序列。

这适用于任何值\ \ ()\ (b \),只要他们互质。另外一个例子,如果我们离开\ (b = 21 \)但不同的价值\ \ (),这是一个表的时间值:

\ \ ()
0 推荐- - - - - -
1 推荐- - - - - -
2 6
3 推荐- - - - - -
4 3
5 6
6 推荐- - - - - -
7 推荐- - - - - -
8 2
9 推荐- - - - - -

的行推荐- - - - - -在的地方\ \ ()不互质21。

现在,正常情况下,发现是一个模块化exponentation的周期函数指数级的困难问题。没有简单的方法来做;除非一些优化,你只需要经过的每个值\ \ (x)并检查是否模块化指数是1。对于非常大的价值\ \ ()\ (b \)这可以采取一个非常,非常长时间。这么久,事实上,这是不现实的一个经典计算机上解决,找到这个函数的周期是一个np难问题。

至少,它

量子相位估计

让我们在早些时候我们的例子\ (a = 11 \)\ (b = 21 \),并运行它通过我们的量子模幂运算的功能。和其他东西一样,我们就集合\ \(刃{x} \)成一个统一的叠加使用所有可能的值\ (H_{所有}\)操作。假设\ \ (x)是一个\ (n \)量子位注册,那么结果是这样的:

\ [\ displaylines{{对齐}\ \开始刃{x} & = 0 \ \ ~ \ \ H_{所有}(\刃{x}), \ qquad \刃{x} & = \压裂{1}{\ sqrt {2 ^ n}} \ sum_ {i = 0} ^ {2 ^ n - 1} \刃{我}\ \ ~ \ \ & = \压裂{1}{\ sqrt {2 ^ n}}左(\ \刃{0}+ \刃{1}+ \刃{2}+……+ \刃{2 ^ n - 1} \) \{对齐}}结束\]

现在,让我们来运行模块化exponentation:

\ [\ displaylines{{对齐}\ \开始刃{x, y} & = \压裂{1}{\ sqrt {2 ^ n}} \ sum_ {i = 0} ^ {2 ^ n - 1} \刃{0}我\ \ ~ \ \ \文字{ModExp} (\ {x}, \刃{0}),\ qquad \刃{x, y} & = \压裂{1}{\ sqrt {2 ^ n}} \ sum_ {i = 0} ^ {2 ^ n - 1} \刃{我11 ^ \ mod 21} \ \ ~ \ \ & = \压裂{1}{\ sqrt {2 ^ n}}左(\ \刃{0,1}+ \刃{1,11}+ \刃{2,16}+ \刃{3 8}+……结束\)\{对齐}}\]

太好了!我们现在有模幂运算函数计算。如您所料,由此产生的叠加周期性的组件:输出寄存器包含6个元素的重复模式。输出寄存器本身不包含任何时期的信息;它有六个可能的最有可能的结果(1、11、16、8、4或2),输入寄存器本身不包含任何信息周期;它只是一个等可能叠加所有可能的状态。事实上,时间信息捕获在输入和输出之间的关系一旦纠缠在一起。

量子场论节中,我们演示了如何反量子场论可以用来恢复如果一波,波的频率编码到一个寄存器的振幅叠加。在这里,我们将做一些类似的事情。有点不同,因为振幅不含一波以同样的方式;他们都有相同的值在一些州,在其他和0值(例如,\(\刃{0,14}\)不属于叠加)。

我们要做的是:

也就是说,我们要运行模幂运算电路上面覆盖的输入一个完整的叠加,然后逆QFT的运行只输入寄存器。最后,我们做一个测量的输入寄存器来获得某种结果。

从根本上讲,逆QFT会把整个国家从:

\[开始\ displaylines{\{对齐}\刃{x, o} & = \压裂{1}{\ sqrt {2 ^ n}} \ sum_ {= 0} ^ {2 ^ n - 1} \刃{,11 ^ \ mod 21} \ \ ~ \ \ & = \压裂{1}{\ sqrt {2 ^ n}}左(\ \刃{0,1}+ \刃{1,11}+ \刃{2,16}+ \刃{3 8}+……结束\)\{对齐}}\]

:

\[\刃{x, o} = \压裂{1}{2 ^ n} \ sum_ {b = 0} ^ {2 ^ n - 1} \ sum_ {= 0} ^ {2 ^ n - 1} e ^{2 \π\ cdot b / 2 ^ n} \ cdot \刃{b, 11 ^ \ mod 21} \]

这将导致很多原始statevector量子干涉的。大多数的州去狼狈地影响,使得它们的振幅几乎是零。然而,有几个关键州,会的有建设性的影响,使得它们的振幅是极高的比别人。

假设我们输入寄存器,\ \(刃{x} \),有9个量子位。与一个统一的叠加,其值的范围从0到511(总共512值)。如果我们这么做,那么这是每个国家的产生概率后运行上面的电路:

马上,你可以看到一些有趣的东西:时间x \ \(^ 11日国防部21 \)6,有6等间隔和大规模概率值吗\ \(刃{x} \)后逆量子场论。这不是一个巧合。虽然我们不能立即计算“山峰”的数量在这个图表(因此得到6)数量,我们可以做一些非常聪明的计算这个数字,从而返回模幂运算的周期函数。

这种技术被称为将军的名字量子相位估计。背后的理论为什么IQFT导致干扰产生这些山峰是相当复杂的描述没有潜水严重到数学;如果你是好奇,我们鼓励您进一步探索的主题。为了这篇介绍性的类,我们要强调这一事实将导致这个干涉图样,并描述如何利用它。

持续的分数

我们称这些严重放大状态特殊的国家,表示我\ \ ()th一\ (s_i \)。特殊状态放大了这个算法遵循这个方程:

\ [s_i = \压裂{2 ^ n \ cdot我}{p}, le我< p \ qquad 0 \ \]

在这里\ (p \)模幂运算的周期函数(这就是我们想找),我\ \ ()是一个整数,然后呢\ (n \)在输入寄存器量子位的数量。为我们的x \ \(^ 11日国防部21 \)的例子中,使用\ (n = 9 \),这是一个表的所有特殊状态:

我\ \ () \ (s_i \) \ \(刃{x_i} \)
0 0 0
1 85.333…… 85年
2 170.666…… 171年
3 256年 256年
4 341.333…… 341年
5 426.666…… 427年

注意,因为\ \(刃{x} \)是一个整数,它最终将被四舍五入到最接近的值对应的特殊状态。这就是为什么在上面的照片中,值85,171,341,和427年有一个概率低于0到256——他们是圆的,所以它们的振幅分布在最近的整数,而不是集中在一个值。

因此,一个更精确的方程\ \(刃{x_i} \)如下:

\[\刃{x_i} \大约\压裂{2 ^ n \ cdot我}{p}, le我< p \ qquad 0 \ \]

如果用它,我们可以将所有的已知量在左边:

\[\压裂{\刃{x_i}} {2 ^ n} \大约\压裂{我}{p} \]

因此,当我们测量\ \(刃{x_i} \),我们有一个好的近似的价值\ \(压裂{我}{p} \)。这并没有告诉我们\ (p \)没错,但它可以用来恢复用一些聪明的技巧。虽然之前,让我们来讨论得到的一种方式实际的价值\ \(压裂{我}{p} \)而不只是一个近似值。幸运的是,有一个有效的方法在经典计算机上。它涉及到持续的分数

连分数是采用这种形式:

\ [x = a_0 + \ \压裂压裂{1}{a_1 + {1} {a₂+ \压裂{1}{a_3 +……}}}\]

任何数量,理性或非理性的,可以用这种形式表示的。无理数,这个过程将继续,直到永远。有理数,这个过程可能会持续一段时间但终将结束。这很好,因为我们的\ \(压裂{我}{p} \)价值绝对是一个理性的号码。

在持续的分数,\ \ (a_i)在每个层次中被称为值连分式的系数。他们都是整数。

如果我们从一个典型的有理数\ (P / Q \),有一种简单的迭代算法获得每一个系数:

  1. 开始通过调用\ (P_0 \)分子用于第一个迭代,\ (Q_0 \)分母第一次迭代。集\ (P_0 = P \)\ (Q_0 =问\)
  2. 计算\ (P_0 / Q_0 \)(在整数运算,所以删除任何剩余)。这将是第一个系数,\ (a_0 \)。更正式,\ (a_0 = \ lfloor P_0 / Q_0 \ rfloor \)
  3. 计算剩余,\ (r_0 \),因为\ (r_0 = P_0 \ mod Q_0 \)
  4. 运行下一个迭代。集\ (P_1 = Q_0 \)\ (Q_1 = r_0 \)
  5. 重复步骤2\ (P_1 \)\ (Q_1 \)获取下一个系数,\ (a_1 \)
  6. 重复步骤3和4\ (P_1 \)\ (Q_1 \)获得\ (P_2 \)\ (Q_2 \)
  7. 继续这个过程,直到\ (r_i = 0 \)。此时,发现在这个迭代系数将是最后一个。

作为一个例子,让我们运行这个算法的分数\ \ (45/16)发现连分式形式:

步骤(我\ \ ()) \ (P_i \) \ (Q_i \) \ \ (a_i) \ (r_i \)
0 45 16 2 13
1 16 13 1 3
2 13 3 4 1
3 3 1 3 0

这告诉我们,的连分数表示\ \ (45/16)是:

\[\压裂{45}{16}= 2 + \压裂{1}{1 + \压裂{1}{4 + \压裂{1}{3}}}\]

太棒了!如果我们已经知道这是有用的\ (P \)\(问\),但回到我们最初的问题——我们不。我们有一个近似,但不是真正的价值观。找到模块化exponentations时期,我们需要那些真正的价值观。我们可以使用类似的技术上面,称为找到连分式的收敛

连分式的收敛

的收敛继续分数近似的持续的分数仅仅停留在一定的系数,而不是继续。

我们的标签我\ \ ()th收敛,\ (v_i \)。作为一般规则,这种形式的收敛将:

\ [\ displaylines {v_0 = a_0 \ \ ~ \ \ v_1 = a_0 + \压裂{1}{a_1} \ \ ~ \ \ v_2 = a_0 + \压裂{1}{a_1 + \压裂{1}{a₂}}} \]

继续\ \ (45/16)示例中,第一个是收敛的\ [2 \),第二个是\(2 + \压裂{1}{1}= 3 \),第三个是\(2 + \压裂{1}{1 + \压裂{1}{4}}= 14/5 = 2.8 \),第四个是实际的价值\ (45/16 = 2.8125 \)。正如您可以看到的,实际上的收敛振荡在实际值越来越接近它。有时他们更小,有时他们大,但是当你添加更多的条款,他们倾向于收敛对实际值(假设这是一个有理数)。因此,名称为的收敛

这是一个简单的算法来计算分子\ (n_i \)和分母\ (d1 \)每个的收敛的:

  1. 从初始值开始\ (n_ {2} = 0 \),\ (d_ {2} = 1 \),\ (n_ {1} = 1 \),\ (d_ {1} = 0 \)
  2. 计算分子\ (n_0 \)第一个收敛\ (v_0 \):\ (n_0 = a_0 \ cdot n_ {1} + n_ {2} \)。计算分母\ (d0 \)第一个收敛\ (v_0 \):\ (d0 = a_0 \ cdot d_ {1} + d_ {2} \)
  3. 重复这个过程,\ \ (n_i = a_i cdot n_张{}+ n_{我2}\)\ \ (d1 = a_i cdot d_张{}+ d_{我2}\)
  4. 继续,直到\ (d1 \)大于任意截止(在一分钟内讨论),或直到你遇到最后一个系数。

让我们把这个应用到\ \ (45/16)示例展示它是如何工作的:

步骤(我\ \ ()) 系数(\ \ (a_i)) 分子(\ (n_i \)) 分母(\ (d1 \)) 价值
2 - - - - - - 0 1 - - - - - -
1 - - - - - - 1 0 - - - - - -
0 2 2 1 \ \(压裂{2}{1}= 2 \)
1 1 3 1 \ \(压裂{3}{1}= 3 \)
2 4 14 5 \ \(压裂{14}{5}= 2.8 \)
3 3 45 16 \ \(压裂{45}{16}= 2.8125 \)

好了。现在,回到我们最初的问题联系起来的发现\ (p \)模幂运算的时期!

要做到这一点,我们将在步骤4中设置截止\ (b \),这是原来的模值用于模幂运算。如果分母变大,我们将会停止。这是因为我们知道\ (p \)、分母必须小于\ (b \)——这段时间总是会小于这个值被模会!如果我们有一个分母比,我们冲出真正的的价值\ (p \),可以检索它,简单地看我们打捞筒前的最后收敛。

回到我们的x \ \(^ 11日国防部21 \)例子中,我们有6特殊状态:0,85,171,256,341,427。让我们来做一个例子,341年我们测量输入寄存器,这对应\ \(压裂{我}{p} = \压裂{4}{6}\)所以我= 4 \ \ ()。这意味着我们将使用341年\ (P_0 \),512年\ (Q_0 \),停止如果收敛分母比21:

步骤(我\ \ ()) \ (P_i \) \ (Q_i \) \ \ (a_i) \ (r_i \) 分子(\ (n_i \)) 分母(\ (d1 \))
2 - - - - - - - - - - - - - - - - - - - - - - - - 0 1
1 - - - - - - - - - - - - - - - - - - - - - - - - 1 0
0 341年 512年 0 341年 0 1
1 512年 341年 1 171年 1 1
2 341年 171年 1 170年 1 2
3 171年 170年 1 1 2 3
4 170年 1 170年 0 341年 512年

\(两者\)demoninator 512,太大了。这意味着真正的的价值\ \(压裂{我}{p} \)是由\ (v_3 \);换句话说,我们知道,如果我们测量\ (341 \)在输入寄存器中我\ \ ()2,\ (p \)是3 !我们发现这段时间!

…或have we?

事实证明,这变得更接近正确的答案,但不幸的是它只给出了降低分数形式的实际价值。因为最初的在这个例子\ \ (4/6)降低版本\ \ (2/3)这是我们落在这里。我们得到的价值为分母可以\ (p \),或者它可能只是一个因素\ (p \)。幸运的是,很容易测试如果我们发现周期;我们只需要快速计算\ (^ p \ b mod = 1 \)。如果是,我们发现这段时间的定义!如果不是,我们必须做更多的工作。

请注意

如果你测量0输入寄存器中,你必须取消整个测量和整个量子子程序再次尝试得到一个不同的值。这是因为0总是可以解决的\ (^ p \ b mod = 1 \),但实际上它并不告诉你周期是什么;这是一个虚假的回答而不是有益的。

聚合的因素

到目前为止,我们已经成功地使用量子子例程来检索的一个特殊时期的州内模幂运算隐藏,我们利用连分式的收敛找到的一个因素。我们这么近…我们只需要找到时间本身。

虽然这让人咋舌,我们实际上非常接近终点线。结果是我们需要做的就是找到更多的因素\ (p \),我们可以使用一个有效的迭代算法逐步越来越接近\ (p \)随着每一个新的因素。

让我们演示如何处理一个例子。说我们有一些值\ \ ()\ (b \),这样的周期\ (^ x \ mod b \)是24。24有几个因素:2、3、4、6、8、12、24本身。我们可以测量任何这些使用过程到目前为止。

假设该算法运行一次,计算2期-称之为\ (d_{老}\)。然后,我们第二次运行它,并计算3 -称之为\ (d_{新}\)。这告诉我们,2和3都是实际的因素。我们可以使用这些信息来计算更大的因素的最小公倍数的两个因素:

\[因子= \ lcm (d_{老},d_{新})= \压裂{d_{老}\ cdot d_{新}}{\肾小球囊性肾病(d_{老},d_{新})}\]

在哪里肾小球囊性肾病\ (\ \)最大公约数函数,它可以有效的计算欧几里得算法。大多数现代框架有一个肾小球囊性肾病()或者一个gcf ()函数,它可以为你这样做。

在这个示例中,新的因素将是:

\[\压裂{2 \ cdot 3}{肾小球囊性肾病(2,3)}= \压裂{6}{1}= 6 \]

所以现在我们知道,2、3和6的因素。这仍然是不足以获得实际的时期,所以我们再次运行整个事情寻找一个新的因素。假设我们这次我们得到8。

\[因子= \压裂{d_{老}\ cdot d_{新}}{\肾小球囊性肾病(d_{老},d_{新})}= \压裂{6 \ cdot 8}{\肾小球囊性肾病(6、8)}= \压裂{48}{2}= 24 \]

和,我们发现它!在现实中,我们只是保持运行这个子程序,逐步收集越来越多的因素,直到我们有足够的找到真正的时期。

算法总结

这是一个很多工作要得到这么远。在继续之前,让我们总结的步骤期间发现肖的算法的一部分。

目标:发现的时期\ (^ x \ mod b \)

假设:

  • \ \ ()\ (b \)是互质。

步骤:

  1. 量子子程序运行。
    1. 准备一个“输出”登记\ \(刃{o} = \刃{0}\)的大小\ \(米)\ \(米)需要足够大\ (b \)(\ (b \)是被分解),所以呢\ (m = \ lceil \ log_2 (b + 1) \ rceil \)量子位。
    2. 准备一个“输入”登记\ \(刃{x} = \刃{0}\)的大小\ (n \)。一个好的经验法则为其大小两倍输出寄存器,所以\ \ (n = 2米)量子位。
    3. \ \(刃{x} \)成一个完整的统一的叠加\ (H_{所有}\)
    4. 模幂运算功能,运行\ \(刃{x} \)作为输入,\ \(刃{o} \)作为输出,参数化\ \ ()\ (b \)
      1. 应用X的最后一个量子位\ \(刃{o} \),所以\ \(刃{o} = \刃{1}\)
      2. 从第一个量子位的索引开始输入,所以\ (i = 0 \)
        1. 计算的值\ (^ {2-n-i} \ mod b \)经典。调用这个值\ (c \)
        2. 应用控制ModMul函数,量子位\ (x_i \)是控制,\ \(刃{o} \)是目标,\ (c \)是乘数,\ (b \)模量。
      3. 重复步骤二的量子位\ \(刃{x} \),所以le我< n \ (0 \ \)
    5. 逆QFT上运行\ \(刃{x} \)
    6. 测量所有的量子位\ \(刃{x} \)并将其转换为一个整数(x ^ \ ' \ \)
  2. 如果\ (x ^ \ ' = 0 \)再次,丢弃它并运行步骤1。
  3. 找到最接近的连分式收敛\ (x ^ \ ' / 2 ^ n \)
    1. 从初始值开始\ (n_ {2} = 0 \),\ (d_ {2} = 1 \),\ (n_ {1} = 1 \),\ (d_ {1} = 0 \),\ (P_0 = x ^ \ ' \),\ (Q_0 = 2 ^ n \),\ (i = 0 \)
    2. 计算= \ \ (a_i lfloor P_i / Q_i \ rfloor \)通过整数运算(删除任何剩余)。
    3. 计算剩余,\ (r_i = P_i \ mod Q_i \)
    4. 计算收敛的分母\ \ (d1 = a_i cdot d_张{}+ d_{我2}\)(我们不需要分子,所以我们可以忽略它)。
    5. 准备下一次迭代的值:增量我\ \ (),设置张\ (P_i = Q_ {} \),并设置张\ (Q_i = r_ {} \)
    6. 重复步骤a e直到\ (r_i = 0 \),或通用电气\ (d1 \ b \)。返回的最大价值\ (d1 \)这还不到\ (b \)
  4. 检查是否\ (^ {d_i} \ b mod = 1 \)。如果是,那么\ (d1 = p \),我们正在寻找。返回它。如果不是这样,\ (d1 \)p是一个因素。
  5. \ (d_{老}= d_i \)。再次运行步骤1 - 4的另一个因素,并调用它\ (d_{新}\)
  6. 计算一个更大的因素\ (p \)\(因子= d_{老}\ cdot d_{新}/ \肾小球囊性肾病(d_{老},d_{新})\)
  7. 检查是否\(因子= p \)在步骤4中使用的测试。如果是,返回它。如果不是,集\ \ (d_{老}=因素)并再次运行步骤1 - 7。

整数分解的关系

在这一点上,我们已经找到了\ (p \)表达式的\ (^ x \ mod b \)。这很棒,但我们仍然没有想出如何与最初的问题,肖的算法来解决:整数分解问题。

回想一下,整数分解的问题是这样的:

一些非优质整数\ (b \),找到一个整数\ (b_0 \)均匀地将它;\ (b / b_0 = b_1 \),在那里\ (b_1 \)也是一个整数。

让我们一起把这两个。

我们解决的方程是:

\ [^ p \ mod b = 1 \]

使用模运算的规则,我们可以这样写:

\ [^ p - 1 \ mod b = 0 \]

这意味着\ (^ p - 1 \)是均匀除以\ (b \);没有剩余的。换句话说,\ (b \)是一个因素\ (^ p - 1 \)。更正式,因为所有的这些数量是整数,我们可以状态:

\ [^ p - 1 = zb \]

在哪里\ (z \)一些未知的乘法器,但也是一个整数。

使用我们的x \ \(^ 11日国防部21 \)这个例子,让我们工作(知道周期是6):

\ [\ displaylines {11 ^ 6 - 1 = 1771560 \ \ ~ \ \ 1771560 / 21 = 84360} \]

因此\ \ (z = 84360)

让我们利用整数的另一个有趣的性质:每个整数都可以表示为两个小的整数倍数;更正式,\ (z = z_0 \ cdot z_1 \)。当然,其中一个整数可能只是如果\ (z \)是质数,但方程仍然有效。

如果我们利用这个性质,我们可以重写\ (z \)\ (b \)这种方式:

\ [^ p - 1 = z_0 z_1 b_0 b_1 \]

现在,\ (b \)是我们想要的因素。我们可以告诉是否总理(有很有效的经典测试),如果我们对它感兴趣,然后我们知道这是一个组合。我们也知道这是奇怪的,因为如果它甚至我们可以这么说\ (b_0 = 2 \)完成了整个过程。因此,我们知道的是\ (2 < b_0 < b \)\ (2 < b_1 < b \)

这是有趣的部分魔法发生的地方。让我们重写这一点:

\[(^{\压裂{p} {2}}) ^ 2 - 1 = z_0 z_1 b_0 b_1 \]

在此之前的形式\ (x ^ 2 - y ^ 2 \)我们可以使用的因素不同的方块公式:

\[(^{\压裂{p}{2}} + 1)(^{\压裂{p} {2}} - 1) = z_0 z_1 b_0 b_1 \]

这表明,数量\(^{\压裂{p} {2}} + 1 \)可以任意组合的产品\ (z_0 \),\ (z_1 \),\ (b_0 \),\ (b_1 \)。这同样适用于\(^{\压裂{p} {2}} - 1 \),有任何遗留下来的。

如果我们得到幸运\ (b_0 \)数量出现在其中一个,\ (b_1 \)出现在其他,然后分裂\ (b \)的因素分成单独的数量。我们可以有效地使用检索它们肾小球囊性肾病算法!

例如,假设\(^{\压裂{p} {2}} + 1 = z_0 b_0 \)\(^{\压裂{p} {2}} - 1 = z_1 b_1 \):

\ [\ displaylines{\肾小球囊性肾病\离开(b, ^{\压裂{p}{2}} + 1 \右)= \肾小球囊性肾病\离开(b_0 \ cdot b_1, z_0 \ cdot b_0 \右)= b_0 \ \ ~ \ \ \肾小球囊性肾病\离开(b, ^{\压裂{p}{2}} - 1 \右)= \肾小球囊性肾病\离开(b_0 \ cdot b_1, z_1 \ cdot b_1 \右)= b_1} \]

就这样,我们现在知道\ (b_0 \)\ (b_1 \)这样,有吗使用的模幂运算整数因子\ (b \)!

现在,重要的是要注意,这并不总是工作。它只能当\ (b_0 \)\ (b_1 \)是分开的,我们不知道是这种情况,直到我们试一试。

幸运的是,有一个非常快速测试我们可以运行是否触及这个问题。我们只需要检查\ (b \)\(^{\压裂{p} {2}} + 1 \)\(^{\压裂{p} {2}} - 1 \)均匀:

左\[\(^{\压裂{p} {2}} + 1 \) \ mod b = 0,左\ qquad \(^{\压裂{p} {2}} - 1 \) \ mod b = 0 \]

如果这些表达式是正确的,那么我们知道,其中一个包含\ (b_0 \)\ (b_1 \),这行不通,所以我们必须尝试别的东西。幸运的是自\ (p \)是函数的时期我们知道二模方程不能是真实的(否则时期\ \ ()国防部\ (b \)将是一个不到\ (p \))。因此,足够的检查,第二个方程不成立。

请注意

从实现的角度看,通常更容易检查\(^{\压裂{p} {2}} \ mod b \)等于\ (b - 1 \)——这种方式我们可以使用古典模幂运算,这是非常快的。

总而言之,这项技术将揭示的因素\ (b \)以下两个条件:

  1. \ (p \)必须是偶数,所以呢\ (p / 2 \)是一个整数。
  2. \(^{\压裂{p} {2}} \ mod b \)不得\ (b - 1 \)

因此,真正的任务是选择的价值\ \ ()在最初的模幂运算函数,这些条件都是真的。没有简单的方法来确定这个提前,所以我们只需要插入随机数字,直到我们找到一个工作。典型的策略是选择随机数\ (2 < < b \),或者从3开始迭代,直到我们得到一个好。

例子介绍

为了演示整个过程,我们走过一个大家熟悉的例子。说我们想因子数量21。让我们使用迭代策略,开始= 4 \ \ ()

  1. = 4 \ \ ()
  2. 使用量子子例程,我们确定的时期\ (4 ^ x \ mod 21 \)是3。3甚至没有,所以我们不能使用它。
  3. = 5 \ \ ()
  4. 使用量子子例程,我们如果确定时期\ (5 ^ x \ mod 21 \)是6。6是偶数,所以我们可以继续。
  5. \(5 ^{\压裂{6}{2}}\ mod 21 = 20 \),等于\ (b - 1 \),所以我们不能使用它。做数学,\ (5 ^ 3 + 1 \)= 126 6和21日给因素不是有用的;这是一个情况的例子\ (b_0 \)\ (b_1 \)不是分开的,所以我们不能使用这个找到21的因素。
  6. 6和7不coprime 21岁,所以我们不能使用它们。请注意,如果我们检查6 \ \肾小球囊性肾病(21日)\)7)\ \肾小球囊性肾病(21日\)我们会立即找到21的因素,可以返回。肖的算法认为,从一开始肾小球囊性肾病()检查每一个新的猜的\ \ ()以防你得到幸运。为了这个例子中,我们继续。
  7. = 8 \ \ ()
  8. 使用量子子例程,我们如果确定时期\ (^ 8 x \ mod 21 \)是2。2是偶数,所以我们可以继续。
  9. \(8 ^{\压裂{2}{2}}\ mod 21 = 8 \)。这不是1到20,所以我们可以继续。
  10. \ \(\肾小球囊性肾病\左(21日离开(8 ^{\压裂{2}{2}}\ mod 21 \右)+ 1 \右)= 3 \),所以的因素之一是3。另一个因素是\ (21 / 3 = 7 \)

虽然尝试了几个,该算法能够因子21在这个非常聪明的时尚。

完整的算法

你已经结束了。所有的上下文设置,所有的步骤都解释道。您已经准备好构建肖的算法。

这是整个事情的主要步骤:

  1. 选择一个整数\ (b \)您想要的因素。运行它通过原始测试以确保它不是'。如果是复合(非优质),然后继续。
  2. 如果\ (b \)的因素是偶数,2和吗\ (b / 2 \)。返回。
  3. 选择一个随机数字\ \ (),在那里\ (2 < < b \)猜的可能因素\ (b \)。或者,如果你喜欢迭代的方法,开始= 3 \ \ ()和增量。
  4. 检查\ \ ()\ (b \)coprime:如果\ \(\肾小球囊性肾病(a, b)东北1 \),他们有一个共同的因素。的因素\ (b \)肾小球囊性肾病的结果和吗\ (b \)除以这个数。返回这些因素。
  5. 如果\ \ ()\ (b \)coprime,那么\ (^ x \ mod b \)是周期性的。使用量子时期发现子例程检索时间\ (p \)
    1. 如果周期反复发现子例程措施0,这段时间可能是少数2或3和你可能只是不走运。考虑设置一个阈值,例如,3在你放弃之前,猜的\ \ ()和尝试不同的一个更大的时期。
  6. 检查是否\ (p \)是奇数。如果是,那么它不能用于保理。从步骤3重新开始选择一个不同的值\ \ ()
  7. 检查是否\(^{\压裂{p} {2}} \ mod b \)是1或\ (b - 1 \)。如果是,它不能用于保理,因为它将给的因素\ (b \)1,不是有用的。从步骤3重新开始选择一个不同的值\ \ ()
  8. 计算的因素\ (b_0 = \肾小球囊性肾病\左左(b \(^{\压裂{p} {2}} \ mod b \右)+ 1 \ \)\ (b_1 = \肾小球囊性肾病\左左(b \(^{\压裂{p} {2}} \ mod b \右)- 1 \)\)
  9. 执行一个检查通过验证\ (2 < b_0 < b \),\ (2 < b_1 < b \),\ (b_0 \ cdot b_1 = b \)

现在你知道该算法是如何工作的,值得花一点时间退后一步,看看大局。虽然步骤简单,想出这个算法背后的理论花了相当大的独创性和横向思维。虽然这可能是最著名的主要的量子算法,肯定不会是最后一次。谁知道聪明的花招会有人想出接下来带来一个经典intractible问题转化为现实的领域利用量子计算机吗?

不管它是什么,放心,现在你装备精良的写一个实现的软件。一旦量子计算机的出现足以运行它,您将能够做到这一点。

实验室9

你现在准备好应对未来实验室。在实验室9中,你要写肖的大部分算法,从第五步从上面的那样。


最后更新:2022年7月1日