- IBM Q Experience 介绍
- 量子世界
- Quantum Composer
- 运行你的量子曲谱(Quantum Score)
- 结果
- 量子比特奇怪又奇妙的世界
- 量子比特(Qubit)
- 产生叠加态 (Superposition)
- 量子比特相位 (Qubit Phase) 介绍
- 高级单量子比特门
- 布洛赫球(Bloch Sphere)
- 退相干(Decoherence)
- 多量子比特,量子门,以及纠缠态(Entangled State)
- 多量子比特
- 纠缠和贝尔实验
- GHZ 态
- 量子算法
- 基本线路标识和更大的线路
- Grover 算法
- Deutsch-Jozsa 算法
- 学习平衡噪音
- 量子相位估计
- Shor 算法
- 量子纠错
- 量子重复码
- 稳定测量
量子计算就在当下。 虽然今天的量子处理器尺寸适中,但复杂性不断增长。 构建并参与新的量子学习者社区的时机已经成熟,因此我们改变了我们对计算的思考方式。 我们 IBM Q Experience 的目的是让你通过阅读本用户指南,编写自己的实验,在仿真中运行它们以及通过 IBM Cloud 在世界上第一个完全可控的量子处理器上执行它们来了解量子世界。
IBM Q Experience 有以下几个部分组成:
- 一套教程(本用户指南)将引导你从简单的单量子比特实验(第 II 部分)的基础知识到更复杂的多量子比特实验(第 III 部分),然后转向量子算法领域更先进的想法 (第 IV 节)和量子纠错(第 V 节);
- Quantum Composer,是一个图形用户界面工具,你可以在其中创建自己的量子线路(我们称之为量子曲谱 quantum score),就像作曲家创作乐谱一样;
- 一个测试你的量子曲谱的模拟器;
- 能够访问 IBM Q 实验室中运行的真实量子处理器,你的量子曲谱将在其中执行;
- 一个量子社区,你可以分享和讨论你的量子曲谱,想法和经验。
请注意,IBM Quantum Experience 是一个 “活的实验”,我们不断对其进行更新。我们希望我们的用户可以通过提供反馈来帮助我们改进其功能并改进整体界面。在社区论坛中,请告诉我们你的改进意见,也请分享你遇到的任何很酷的曲谱和结果!如果你发现任何错误,请通过我们的错误跟踪器报告,可通过每页右下角的小错误图标访问。
为了确保每个人都有机会通过云端使用我们的实验室中的真实设备,我们建立了一个 Units 货币系统。 如果你已创建 IBM Q Experience 帐户,则可以完全访问我们的模拟功能以及先前在真实设备运行的缓存结果,以及花费少量的 Units 在量子处理器硬件上运行真实实验。 阅读完用户指南后,你将获得额外的 Units 奖励以进行更多实时实验。该系统允许我们的实验队列顺利运行。当你的 Units 用完时,一旦你查看完成的执行结果,你将得到补充。
我们实验室的量子处理器需要经常校准;在这些短时间内,你将收到 “Down for Calibration” 通知。如果我们需要执行维护,将显示 “Down for Maintenance” 消息。在这两种情况下,模拟都可供你继续学习和设计新实验。
对于那些希望直接创建自己的实验的人,可以直接跳到 Quantum Composer 章节。如果你希望首先提高对量子世界的理解,请继续阅读本用户指南,从量子世界章节开始。
今天的计算机使用标准(作为物理学家会说,“经典”)计算模型执行计算和处理信息,其可以追溯到图灵和冯诺依曼。在这个模型中,所有信息都可以简化为比特,可以取 0 或 1 的值——所有处理都可以通过简单的逻辑门(AND、OR、NOT、NAND)一次作用于一个或两个比特来执行。在计算的任何一点,经典计算机的状态完全取决于其所有比特的状态,因此具有 n 个比特的计算机可以是
与此同时,量子计算机的力量在于其更为丰富的各种状态。量子计算机也有比特——但不是 0 和 1,它的量子比特,或 qubits,可以表示 0、1 两者的线性组合,这是一种称为叠加的属性。这本身并不特别,因为计算机的比特介于 0 和 1 之间只是一台模拟(analog)计算机,几乎没有普通数字(digital)计算机那么强大。然而,量子计算机利用一种特殊的叠加,允许同时表示指数个逻辑状态,所有从
人们可能会认为理解量子计算或量子物理学的难度在于 “hard math” ......但从数学上讲,量子概念只比高中代数复杂一点。量子物理很难是因为像爱因斯坦的相对论一样,它需要内化简单但反直觉的思想。相对论的奇怪之处在于时间和空间相互关联的概念,而常识告诉我们它们应该是独立作用。如果你一开始直接跳到时间和空间,来对新人解释相对论,你可能会得到一个茫然的凝视作为回报。更好的开始方式就像爱因斯坦所做的那样,通过解释相对论来自一个简单的物理原理:对于所有匀速移动的观察者来说,光速是相同的。这个谦虚的想法然后变得非常深刻,并且通过不可阻挡的逻辑引出爱因斯坦时空。
量子物理学的反直觉思想是:
- 处于确定状态的物理系统仍可以随机行为。
- 两个相隔太远而不能相互影响的系统仍然可以表现出,各自随机,但以某种方式强关联。
不幸的是,与相对论不同,这些结论并没有单一的简单物理原理。我们所能做的最好的事情就是将量子力学提炼成一些抽象的数学定律,从中可以推导出所有观察到的量子粒子(和量子计算机中的量子比特)的行为。而且,与相对论一样,我们必须避免试图用经典术语来描述量子概念。
Quantum Composer 是我们用于编程量子处理器的图形用户界面。熟悉量子计算的人可能会将 composer 视为使用定义好的门和测量操作构建量子线路的工具。对于那些不熟悉的人,我们将解释一些关键部分。
首次单击上面的 “Composer” 选项卡时,你可以选择运行实际量子处理器还是自定义量子处理器。在自定义处理器中,门可以放置在任何地方,而在实际处理器中,拓扑结果由我们实验室中运行的物理设备设置(请注意,这限制了一些双量子比特门的可用性)。
进入 “Composer” 选项卡后,你就可以开始制作自己的量子线路!
使用 Composer,你可以创建一个量子线路,我们有时将其称为量子曲谱,因为它在某些方面类似于乐谱。时间从左到右进行。每条线代表一个量子比特(以及该量子比特随时间发生的变化)。每个量子比特具有不同的频率,如音符。量子门由方框表示,它们播放不同长度,幅度和相位的频率。仅在一条线上的门被称为单量子比特门。用垂直线连接两个量子比特的门被称为 CNOT 门;这些双量子比特门的功能类似于传统数字逻辑中的异或门。CNOT 门实心点端的量子比特控制
Quantum Composer 的库(位于量子比特面板的右侧)包含许多不同类别的门:单量子位门,例如黄色的空操作;绿色的泡利算子,代表比特翻转(X,相当于经典的NOT);相位翻转(Z);以及组合的比特翻转和相位翻转(Y)。我们还提供 Clifford 操作,这些是蓝色的门,例如
如果你勇气可嘉,可以点击 “高级” 按钮查看另一组门操作和子程序。这些当你继续阅读下去会得到解释。
要使用 Composer,只需将量子门拖到量子比特面板上即可放置它们。双击方框来删除。要放置 CNOT 门,首先拖动到目标量子比特上($\oplus$ 符号将出现),然后单击控制量子比特(将出现一个实心点)。请注意,在实际量子处理器上,测量门后面无法添加更多的门; 此功能将在未来添加。
加载下面的量子线路并尝试模拟,或开始编写自己的。 如果可能,我们将提供 OpenQASM 版本的线路,以及使用 QISKit 开源框架运行它的 Python 代码。
第一个曲谱
// My First Score
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[2];
creg c[2];
// Quantum Circuit
// Pauli operations
x q[0];
y q[1];
z q[0];
barrier q;
// Clifford operations
h q;
s q[0];
sdg q[1];
cx q[0],q[1];
barrier q;
// non-Clifford operations
t q[0];
tdg q[1];
barrier q;
// measurement operations
measure q -> c;QISKit 例子
# my_first_score.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(2)
c = ClassicalRegister(2)
# Build the circuit
my_first_score = QuantumCircuit(q, c)
# Pauli operations
my_first_score.x(q[0])
my_first_score.y(q[1])
my_first_score.z(q[0])
my_first_score.barrier(q)
# Clifford operations
my_first_score.h(q)
my_first_score.s(q[0])
my_first_score.s(q[1]).inverse()
my_first_score.cx(q[0],q[1])
my_first_score.barrier(q)
# non-Clifford operations
my_first_score.t(q[0])
my_first_score.t(q[1]).inverse()
my_first_score.barrier(q)
# measurement operations
my_first_score.measure(q, c)
# Execute the circuit
job = execute(my_first_score, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(my_first_score))现在我们已经熟悉了 Composer,让我们来看看如何运行量子曲谱。
当你开始实验时,系统会提示你为其命名,以便稍后识别。你还将看到两个选项:Real Quantum Processor 或 Custom Topology。在这两种情况下,你都可以通过将量子门拖到曲谱上,添加测量门,然后点击 “运行” 要执行曲谱。
如果选择 “Custom Topology”,你唯一的选择是在模拟器中运行曲谱。这是因为自定义处理器允许任意连接;相反,真实设备受到物理连接的限制。选择自定义拓扑时,会出现一个对话框,要求你选择分配给不同寄存器的量子比特和经典比特数。我们将最大的量子比特数设置为 20。你的线路的执行很快(除非量子位数很大),然后可以在结果中查看输出(参见下一节)。 尝试下面的 “单 Qubit 测量”。
// Single Q Measurement
OPENQASM 2.0
include "qelib1.inc"
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
measure q -> c;
QISKit 例子
# single_q_measurement.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
single_q_measurement = QuantumCircuit(q, c)
single_q_measurement.measure(q, c)
# Execute the circuit
job = execute(single_q_measurement, backend='local_qasm_simulator',shots=1024)
result = job.result()
# Print the result
print(result.get_counts(single_q_measurement))如果选择 “Real Quantum Processor”,当你点击 “运行” 时,你编写的曲谱将被放入实验队列中,当你在我们实验室的真实量子计算机上执行时,你将收到电子邮件通知。
你必须在 IBM Q Experience 帐户中拥有 Units 才能使用真实量子处理器。如果你尝试运行的曲谱是之前已经运行的,你将可以选择立即查看缓存执行的结果(不需要 Units),或者花费 Units 将曲谱作为新的重新运行(意味着它将进入实验队列,完成后你将收到电子邮件通知)。
请注意,本用户指南中的许多示例都有以前的执行可供你查看和试验。
点击 “运行” 后,你的曲谱进度将显示在 composer 下方的 “Quantum Scores” 选项卡中,并按执行日期排序。一旦结果出来后,你将可以从此选项卡中查看它们。你还可以在等待结果返回时重新编辑曲谱并在模拟器上执行。
在我们的系统中(标准的),测量是在计算基础上进行。在测量之后,量子比特的信息变成经典比特。 如果在态
运行给定的具有 n 个测量的量子线路,测量结果将是
直方图/条形图表示很容易理解。条形的高度表示在实验期间该结果发生的占比。仅包括至少发生过一次的那些结果。如果所有条形图都太小而无法显示,则将它们收集到称为 “other values” 的单个条形图中。一般来说这不是问题,因为好的量子线路不应该有很多结果;只有在终态是一个大叠加态的线路才会产生许多结果,而这将需要指数测量。
在本节中,我们将向您介绍量子比特。量子比特(发音为 “cue-bit” )是量子信息的物理载体;换句话说,它是一个量子版本的比特,量子计算围绕着它进行。
在这个章节你将看到量子比特。你还将看到一些数学符号,包括线性代数中的一些概念。量子比特是由两个层次组成的量子系统,标记为
量子比特并不总是必须在
当测量或观察量子系统时会发生有趣的事情。量子测量由波尔规则(Born rule)描述。特别的地方是,如果处于某个态的量子比特
这里我们描述的是量子比特的抽象概念。你在 IBM Q Experience 中与之交互的原型量子计算机使用的是比特称为超导传输量子比特(superconducting transmon qubit),其由在硅衬底上图案化的诸如铌和铝的超导材料制成。物理上,为了使这个超导量子比特像量子比特的抽象概念一样,该设备必须处于极低的温度。在 IBM Quantum Lab 中,我们将温度保持在如此冷(在稀释制冷机中为 15 mK),因此没有环境噪音或热量来激发超导量子比特。一旦我们的系统足够冷,经过几天,超导量子比特将平衡到基态
要了解 “基态” 的含义,请尝试在模拟模式下运行下面的曲谱文件(或查看真实设备上的一些缓存运行结果)。这里,量子比特初始为基态
单量子比特测量
// Single Q Measurement
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
measure q -> c;
QISKit 例子
# single_q_measurement.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
single_q_measurement = QuantumCircuit(q, c)
single_q_measurement.measure(q, c)
# Execute the circuit
job = execute(single_q_measurement, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(single_q_measurement))你可能已经猜到了,我们还需要能够将量子比特放在其他态。为此,我们需要量子门(quantum gate)的概念。 单量子比特门是
最简单的量子门是不同翻转门,记为
在 Composer 中,它由绿色的方框给出,中间有一个 X。 尝试运行下面的示例文件,你是否发现,与上面的示例不同,量子比特最终处于激活态
激活态
// Excited State
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
x q[1];
measure q -> c;
QISKit 例子
# excited_state.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
excited_state = QuantumCircuit(q, c)
excited_state.x(q)
excited_state.measure(q, c)
# Execute the circuit
job = execute(excited_state, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(excited_state))到目前为止,我们的系统表现得像经典的比特。要想超越经典行为,我们必须探索如何实现叠加。产生叠加的操作是 Hadamard 门,$H$。在 Composer 中,这是标记为
下面给出一个进行叠加的简单曲谱。首先放置
// Superposition State
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
measure q -> c;
QISKit 例子
# superposition_state.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
superposition_state = QuantumCircuit(q, c)
superposition_state.h(q)
superposition_state.measure(q, c)
# Execute the circuit
job = execute(superposition_state, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(superposition_state))你发现没有,结果一半时候是 0,一半时候是 1。实际上,就像翻转一枚硬币一样,结果接近 50/50(由于噪音和误差,在真实设备上运行会得到的不是理想的结果)。
然而,量子随机性是非常不同的。我们来看看是怎么样的。再次运行实验,但是这次有两个串联的
//Superposition State in X Basis
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
h q;
measure q -> c;
QISKit 例子
# superposition_state_xbasis.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
superposition_state_xbasis = QuantumCircuit(q, c)
superposition_state_xbasis.h(q)
superposition_state_xbasis.barrier()
superposition_state_xbasis.h(q)
superposition_state_xbasis.measure(q, c)
# Execute the circuit
job = execute(superposition_state_xbasis, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(superposition_state_xbasis))这一次,结果令人惊讶。与经典情况不同,结果不是随机的,而是以很高的概率在
在我们给出数学解释之前,让我们再考虑两个实验。第一个将量子比特置于激发态,然后应用
//Negative Superposition State
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
x q;
h q;
measure q -> c;
QISKit 例子
# negative_superposition_state.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
negative_superposition_state = QuantumCircuit(q, c)
negative_superposition_state.x(q)
negative_superposition_state.h(q)
negative_superposition_state.measure(q, c)
# Execute the circuit
job = execute(negative_superposition_state, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(negative_superposition_state))第二个实验包括:首先准备激发态量子比特,应用
x 基上的负叠加态
//Negative Superposition State X Basis
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
x q;
h q;
barrier q;
h q;
measure q -> c;
QISKit 例子
# negative_superposition_state_xbasis.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
negative_superposition_state_xbasis = QuantumCircuit(q, c)
negative_superposition_state_xbasis.x(q)
negative_superposition_state_xbasis.h(q)
negative_superposition_state_xbasis.barrier()
negative_superposition_state_xbasis.h(q)
negative_superposition_state_xbasis.measure(q, c)
# Execute the circuit
job = execute(negative_superposition_state_xbasis, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Print the result
print(result.get_counts(negative_superposition_state_xbasis))应用此门到
应用此门到
这些矩阵直接导致上面所见的量子随机性。你还了解了量子叠加,并且这些叠加可以有一个符号。我们希望你从本章中掌握的主要信息是:
- 处于确定状态的物理系统仍可以行为随机
这是量子世界章节里两个原则中的第一个。这个需要成为你的新直觉,因为它使量子系统不同于经典系统。
在前两节中,我们讨论了比特翻转和 Hadamard 门。这些允许我们产生单量子比特态
单量子比特态另一种满足这些条件的表示可以写成
其中
如果我们的系统从初态
//Quantum Phase exp 0
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
// None
barrier q;
h q;
measure q -> c;
//Quantum Phase exp 1
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
barrier q;
h q;
sdg q;
measure q -> c;
//Quantum Phase exp 2
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
t q;
barrier q;
h q;
measure q -> c;
//Quantum Phase exp 3
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
t q;
t q;
barrier q;
h q;
measure q -> c;
//Quantum Phase exp 4
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
t q;
t q;
t q;
barrier q;
h q;
measure q -> c;
//Quantum Phase exp 5
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
t q;
t q;
t q;
t q;
barrier q;
h q;
measure q -> c;
//Quantum Phase exp 6
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
t q;
t q;
t q;
t q;
t q;
barrier q;
h q;
measure q -> c;
//Quantum Phase exp 7
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
t q;
t q;
t q;
t q;
t q;
t q;
t q;
barrier q;
h q;
measure q -> c;
QISKit 例子
# quantum_phase.py
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuits
circuits = []
pre = QuantumCircuit(q, c)
pre.h(q)
pre.barrier()
middle = QuantumCircuit(q, c)
meas_x = QuantumCircuit(q, c)
meas_x.barrier()
meas_x.h(q)
meas_x.measure(q, c)
exp_vector = range(0,8)
for exp_index in exp_vector:
circuits.append(pre + middle + meas_x)
middle.t(q)
# Execute the circuits
shots = 1024
job = execute(circuits, backend = 'local_qasm_simulator', shots=shots, seed=8)
result = job.result()
# Print the result
for exp_index in exp_vector:
data = result.get_counts(circuits[exp_index])
try:
p0 = data['0']/shots
except KeyError:
p0 = 0
try:
p1 = data['1']/shots
except KeyError:
p1 = 0
print('exp {}: [{}, {}] X length = {}'.format(exp_index, p0, p1, p0-p1))在这里,QISKit 为我们提供了一个很好的优势,因为我们可以简单地循环不同的线路。
结果总结在下表中,其中 X 长度是概率 0 减去概率 1 的结果。你可以将其视为 x 测量的长度。
注意:要获取这些值,您可能需要将 shot 数设置为远大于 1024。
你可能已经注意到还有其他门:${ Y,Z,S,S^\dagger,T^\dagger }$,以及 Composer 中提供的 CNOT(我们将在后面介绍)。所有这些门都可以从
以及
每组门的属性用不同颜色表示。所有绿色量子门称为泡利组,可以由门
现在我们已经很好地理解了标准门,我们可以定义第三个测量基,环($Y$)基:$\lvert \circlearrowright \rangle = \frac{1}{\sqrt{2}}(\lvert 0 \rangle + i\lvert 1 \rangle)
要在此基上进行测量,我们必须旋转计算基($Z$)为环基($Y$)。为此,在测量之前先用
//Quantum Phase exp 0
OPENQASM 2.0;
include "qelib1.inc";
// Register declarations
qreg q[1];
creg c[1];
// Quantum Circuit
h q;
barrier q;
// None
barrier q;
sdg q;
h q;
measure q -> c;
QISKit 例子
# quantum_phase_meas_y.py
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuit
circuits = []
pre = QuantumCircuit(q, c)
pre.h(q)
pre.barrier()
middle = QuantumCircuit(q, c)
meas_y = QuantumCircuit(q, c)
meas_y.barrier()
meas_y.s(q).inverse()
meas_y.h(q)
meas_y.measure(q, c)
exp_vector = range(0,8)
for exp_index in exp_vector:
circuits.append(pre + middle + meas_y)
middle.t(q)
# Execute the circuits
shots = 1024
job = execute(circuits, backend = 'local_qasm_simulator', shots=shots, seed=8)
result = job.result()
# Print the result
for exp_index in exp_vector:
data = result.get_counts(circuits[exp_index])
try:
p0 = data['0']/shots
except KeyError:
p0 = 0
try:
p1 = data['1']/shots
except KeyError:
p1 = 0
print('exp {}: [{}, {}] Y length = {}'.format(exp_index, p0, p1, p0-p1))我们准备实验高级量子门了!可以在 Composer 中的门列表上方找到它。当你尝试时,有三个橙色的门
单量子比特态的另一个方便的表示是
其中
如前所述,单量子比特门由 2×2 酉矩阵
一般酉矩阵必须能够将
这是单量子比特酉矩阵的最一般形式。
第一个物理门,$u1$,是相位门,由下式给出
该门允许我们编程连续的量子相位
第二个门是
通过这个门,Hadamard 门由
第三道门是
QISKit 例子
# example_u3.py
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuits
circuits = []
middle = QuantumCircuit(q, c)
meas = QuantumCircuit(q, c)
meas.barrier()
meas.measure(q, c)
exp_vector = range(0,50)
exp_theta = []
theta = 0.0
for exp_index in exp_vector:
delta_theta = 2*np.pi/len(exp_vector)
theta = theta + delta_theta
exp_theta.append(theta)
middle.u3(delta_theta,0,0,q)
circuits.append(middle + meas)
# Execute the circuits
shots = 1024
job = execute(circuits, backend = 'local_qasm_simulator', shots=shots, seed=8)
result = job.result()
# Plot the result
exp_data = []
exp_error = []
for exp_index in exp_vector:
data = result.get_counts(circuits[exp_index])
try:
p0 = data['0']/shots
except KeyError:
p0 = 0
exp_data.append(p0)
exp_error.append(np.sqrt(p0*(1-p0)/shots))
plt.errorbar(exp_theta, exp_data, exp_error)
plt.xlabel('theta')
plt.ylabel('Pr(0)')
plt.grid(True)
plt.show()可视化工具对于理解量子线路中发生的事情非常重要。Bloch Sphere 是一个标准工具,它将量子比特以三维物体的形式表示出来。我们提醒读者,这个工具不会帮助你思考多个量子比特,因为它无法展示纠缠。单是,它对于理解单个量子比特非常有用。
如上一节所述,单量子比特态可写为
每个期望值
如你所见,需要进行一系列测量以重建完整的 Bloch 向量,然后可以将其合成。这种类型的重建通常被称为态断层扫描(state tomography)。有效运行断层扫描的步骤需要一次运行批量的量子曲谱,这个可以由更高级的 QISKit 设置。
# quantum_phase_bloch.py
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
from qiskit.tools.visualization import plot_bloch_vector
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuits
pre = QuantumCircuit(q, c)
pre.h(q)
pre.barrier()
meas_x = QuantumCircuit(q, c)
meas_x.barrier()
meas_x.h(q)
meas_x.measure(q, c)
meas_y = QuantumCircuit(q, c)
meas_y.barrier()
meas_y.s(q).inverse()
meas_y.h(q)
meas_y.measure(q, c)
meas_z = QuantumCircuit(q, c)
meas_z.barrier()
meas_z.measure(q, c)
bloch_vector = ['x', 'y', 'z']
exp_vector = range(0, 21)
circuits = []
for exp_index in exp_vector:
middle = QuantumCircuit(q, c)
phase = 2*np.pi*exp_index/(len(exp_vector)-1)
middle.u1(phase, q)
circuits.append(pre + middle + meas_x)
circuits.append(pre + middle + meas_y)
circuits.append(pre + middle + meas_z)
# Execute the circuit
job = execute(circuits, backend = 'local_qasm_simulator', shots=1024)
result = job.result()
# Plot the result
for exp_index in exp_vector:
bloch = [0, 0, 0]
for bloch_index in range(len(bloch_vector)):
data = result.get_counts(circuits[3*exp_index+bloch_index])
try:
p0 = data['0']/1024.0
except KeyError:
p0 = 0
try:
p1 = data['1']/1024.0
except KeyError:
p1 = 0
bloch[bloch_index] = p0-p1
plot_bloch_vector(bloch)真正的量子计算机必须处理退相干或由于环境干扰(噪声)而导致的信息丢失。我们在前一节中介绍的 Bloch 向量形式足以描述退相干过程下的系统状态。 到目前为止我们研究的纯态有一个长度为 1 的 Bloch 向量,接触 Bloch 球的表面,并且可以用密度矩阵形式表示为
以及 Bloch 球内的 Bloch 向量
能量弛豫和
一个重要的退相干过程称为能量弛豫(energy relaxation),由激发态
下面是一个用于测量
# t1.py
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, register
import Qconfig
register(Qconfig.APItoken, Qconfig.config['url'])
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuits
pre = QuantumCircuit(q, c)
pre.x(q)
pre.barrier()
meas = QuantumCircuit(q, c)
meas.measure(q, c)
circuits = []
exp_vector = range(1,51)
for exp_index in exp_vector:
middle = QuantumCircuit(q, c)
for i in range(45*exp_index):
middle.iden(q)
circuits.append(pre + middle + meas)
# Execute the circuits
shots = 1024
job = execute(circuits, 'ibmqx4', shots=shots, max_credits=10)
result = job.result()
# Plot the result
exp_data = []
exp_error = []
for exp_index in exp_vector:
data = result.get_counts(circuits[exp_index-1])
try:
p0 = data['0']/shots
except KeyError:
p0 = 0
exp_data.append(p0)
exp_error.append(np.sqrt(p0*(1-p0)/shots))
plt.errorbar(exp_vector, exp_data, exp_error)
plt.xlabel('time [45*gate time]')
plt.ylabel('Pr(0)')
plt.grid(True)
plt.show()去相位和
去相位(Dephasing)是另一个退相干过程,与能量松弛不同,它只影响叠加态。时间常数
下面是用于测量
# t2_ramsey.py
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, register
import Qconfig
register(Qconfig.APItoken, Qconfig.config['url'])
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuits
pre = QuantumCircuit(q, c)
pre.h(q)
pre.barrier()
meas_x = QuantumCircuit(q, c)
meas_x.barrier()
meas_x.h(q)
meas_x.measure(q, c)
circuits = []
exp_vector = range(1,51)
phase = 0.0
for exp_index in exp_vector:
middle = QuantumCircuit(q, c)
phase = phase + 6*np.pi/len(exp_vector)
middle.u1(phase,q)
for i in range(5*exp_index):
middle.iden(q)
circuits.append(pre + middle + meas_x)
# Execute the circuits
shots = 1024
job = execute(circuits, 'ibmqx4', shots=shots, max_credits=10)
result = job.result()
# Plot the result
exp_data = []
exp_error = []
for exp_index in exp_vector:
data = result.get_counts(circuits[exp_index-1])
try:
p0 = data['0']/shots
except KeyError:
p0 = 0
exp_data.append(p0)
exp_error.append(np.sqrt(p0*(1-p0)/shots))
plt.errorbar(exp_vector, exp_data, exp_error)
plt.xlabel('time [5*gate time]')
plt.ylabel('Pr(+)')
plt.grid(True)
plt.show()# t2_echo.py
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, register
import Qconfig
register(Qconfig.APItoken, Qconfig.config['url'])
# Define the Quantum and Classical Registers
q = QuantumRegister(1)
c = ClassicalRegister(1)
# Build the circuits
pre = QuantumCircuit(q, c)
pre.h(q)
pre.barrier()
meas_x = QuantumCircuit(q, c)
meas_x.barrier()
meas_x.h(q)
meas_x.measure(q, c)
circuits = []
exp_vector = range(1,51)
for exp_index in exp_vector:
middle = QuantumCircuit(q, c)
for i in range(15*exp_index):
middle.iden(q)
middle.x(q)
for i in range(15*exp_index):
middle.iden(q)
circuits.append(pre + middle + meas_x)
# Execute the circuits
shots = 1024
job = execute(circuits, 'ibmqx4', shots=shots, max_credits=10)
result = job.result()
# Plot the result
exp_data = []
exp_error = []
for exp_index in exp_vector:
data = result.get_counts(circuits[exp_index-1])
try:
p0 = data['0']/shots
except KeyError:
p0 = 0
exp_data.append(p0)
exp_error.append(np.sqrt(p0*(1-p0)/shots))
plt.errorbar(exp_vector, exp_data, exp_error)
plt.xlabel('time [31*gate time]')
plt.ylabel('Pr(+)')
plt.grid(True)
plt.show()超导量子比特的退相干研究进展
由于



