参考文献：

1. IBM Qiskit 官网
2. Qiskit Documentation
3. Qiskit Benchpress package
4. Qiskit Algorithms package
5. 量子计算：基本概念
6. 常见的几类矩阵（正交矩阵、酉矩阵、正规矩阵等）
7. Qiskit 安装指南-博客园
8. 使用Python实现量子电路模拟：走进量子计算的世界-腾讯云开发者社区-腾讯云
9. 如何在 Python 中使用 qiskit 包进行量子计算机编程？ - 知乎

模拟环境

IBM 的开源库 Qiskit 提供了量子计算中的必要模块，甚至可以在量子真机上实验（需注册账号，但 IP in CN 被拒绝）。运行如下的指令，

pip install qiskit					# qiskit 主体（IBM 团队）
pip install qiskit[visualization]	# 可视化功能（IBM 团队）
pip install qiskit-ibm-runtime		# 量子真机（IBM 团队）
pip install qiskit-aer				# 量子计算模拟器（其他团队）
pip install qiskit-algorithms		# 量子算法实现（其他团队）

目前安装的是 V2.0.2 版本，有不少 V1.x的函数已被弃用。因此中文网络上找到的教程中，很多代码早已无法正常执行。

然后，再安装一些依赖包，

pip install pylatexenc
pip install seaborn

并且，可能需要更新一些包，

pip install --upgrade numpy
pip install --upgrade scipy
pip install --upgrade matplotlib

不知为何，VScode 里的 Jupter 编辑器报错 Could not initialize webview: Error: Could not register service worker: InvalidStateError: Failed to register a ServiceWorker: The document is in an invalid state..}，弄了半天。最后是进 任务管理器 杀死全部相关进程，重启解决。

下面给一个 .py 测试代码，看一下它能否正常执行：

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram

# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)

# Add a H gate on qubit 0
circuit.h(0)

# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)

# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])

# Execute the circuit on the qasm simulator
transpiled_circuit = transpile(circuit, simulator)
job = simulator.run(transpiled_circuit, shots=1024)

# Grab results from the job
result = job.result()

# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)

# Draw the circuit
circuit.draw()

其结果应当为：

Total count for 00 and 11 are: {'00': 492, '11': 532}

功能简介

Qiskit SDK（包名 qiskit）是一个开源的软件开发工具包，用于在扩展的（静态、动态和预定）量子电路、算符和原语层面上与量子计算机协同工作。这个库是 Qiskit 的核心组件，是其名下最大的包，拥有用于量子计算的最广泛工具集，并且许多其他组件都与其交互。 一些最有用的功能包括：

• Circuit-building tools（qiskit.circuit），用于初始化和操作寄存器、电路、指令、门、参数以及控制流对象。
• Circuit library（qiskit.circuit.library），包含大量的电路、指令和门，这些是基于电路的量子计算的关键构建模块。
• Quantum info library（qiskit.quantum_info），这是一个用于处理量子态、算符和量子通道的工具包，采用精确计算（无采样噪声）。使用此模块来指定输入可观测量，并分析来自原语查询的输出保真度。
• Transpiler（qiskit.transpiler），用于转换和调整量子电路，以适应特定的设备拓扑结构，并针对在真实量子处理单元（QPUs）上的执行进行优化。
• Primitives（qiskit.primitives），该模块包含 Sampler 和 Estimator 原语的基本定义和参考实现，不同的量子硬件供应商可以从中派生出自己的实现。

有许多开源项目使用 “Qiskit” 这个名称，但并非 Qiskit 本身的一部分；相反，它们与Qiskit交互，并能提供有价值的额外功能，以补充 Qiskit 的核心工作流程。其中一些项目由 IBM 量子团队维护，而其他项目则得到更广泛的开源社区支持。 一些受欢迎的项目包括：

• Qiskit Aer（qiskit-aer），一个用于带有逼真噪声模型的量子计算模拟器的软件包。它提供了接口，可使用多种不同的模拟方法运行有无噪声的量子电路。由 IBM 量子团队维护。
• qBraid SDK（qbraid），一个对量子软件和硬件供应商均适用、与平台无关的量子运行时框架，旨在简化量子任务的全生命周期管理，从定义程序规范到任务提交，再到结果的后处理和可视化。由 qBraid 维护。
• mthree（mthree），一个用于实现 M3（Matrix-free Measurement Mitigation）的软件包，M3 是一种测量缓解技术，通过降维步骤，然后采用直接 LU 分解或一种通常在 $O(1)$ 步内收敛且可并行计算的预处理迭代方法，求解修正后的测量概率。由 IBM 量子团队维护。

这些扩展项目可以在 Qiskit-ecosystem 中找到。

如何使用

使用 Qiskit 编写量子程序的四个步骤是：

1. Map the problem to a quantum-native format.
2. Optimize the circuits and operators.
3. Execute using a quantum primitive function.
4. Analyze the results.

现在新建一个 .ipynb 文件，学一下如何使用 Qiskit 模拟环境。简单来说，我们用一个长度为 $2^n$ 的复数向量（各个基态的组合系数），来表示一个长度 $n$ 的量子态。每个量子门就是一个形状 $2^n\times 2^n$ 的酉矩阵（幺正矩阵，满足 $A{A}^H=A^{H}A=I$ 即 $A^H=A^{-1}$，其中 $A^H:={\bar{A}}^T$ 是共轭转置），包括：单量子位门（Pauli、Hadamard、Phase、T），双量子位门（CNOT、Swap），三量子位门（Toffoli、Fredkin），以及一般的量子门，等等。

下面的代码来自 这里，展示了在带噪的量子系统中制备 Bell 态的电路及其测量。

1. 首先引入必要的库函数，

   from qiskit import QuantumCircuit
   from qiskit.quantum_info import SparsePauliOp
   from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
   from qiskit_ibm_runtime import EstimatorV2 as Estimator
   from qiskit.quantum_info import Statevector
   

2. 然后创建如下的双量子电路（简单堆砌量子门），它可以构造出 Bell 态，即 $|00⟩\to |{\varphi }^{+}⟩,|01⟩\to |{\psi }^{+}⟩,|10⟩\to |{\varphi }^{-}⟩,|10⟩\to |{\psi }^{-}⟩$，

   # Create a new circuit with two qubits
   qc = QuantumCircuit(2)
   
   # initial state |01>
   state = Statevector.from_label('01')
   qc.initialize(state, [0, 1])
   
   # Add a Hadamard gate to qubit 0
   qc.h(0)
   
   # Perform a controlled-X gate on qubit 1, controlled by qubit 0
   qc.cx(0, 1)
   
   # Return a drawing of the circuit using MatPlotLib ("mpl"). This is the
   # last line of the cell, so the drawing appears in the cell output.
   # Remove the "mpl" argument to get a text drawing.
   qc.draw("mpl")
   

   绘制出的电路如下，

   

3. 定义如下的测量算子，

   # Set up six different observables.
   
   observables_labels = ["IZ", "IX", "ZI", "XI", "ZZ", "XX"]
   observables = [SparsePauliOp(label) for label in observables_labels]
   

4. 将上述电路转化为 ISA（Instruction Set Architecture） 格式，然后放到到量子真机（CN 被禁用）/ 仿真（使用 qiskit-aer 包）环境中，

   #from qiskit_ibm_runtime import QiskitRuntimeService
   
   # If you have not previously saved your credentials, follow instructions at
   # https://docs.quantum.ibm.com/guides/setup-channel#iqp
   # to authenticate with your API token.
   #service = QiskitRuntimeService()
   #backend = service.least_busy(simulator=False, operational=True)
   
   from qiskit_aer import Aer
   backend = Aer.get_backend('qasm_simulator')
   
   # Convert to an ISA circuit and layout-mapped observables.
   pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
   isa_circuit = pm.run(qc)
   
   isa_circuit.draw("mpl", idle_wires=False)
   

   如果用 IBM 真机，应该会得到与上述不同的图像。不过使用 Aer 绘制的电路并没有改变。

5. 多次执行上述电路，并进行相应测量，

   # Construct the Estimator instance.
   
   estimator = Estimator(mode=backend)
   estimator.options.resilience_level = 1
   estimator.options.default_shots = 5000
   
   mapped_observables = [
       observable.apply_layout(isa_circuit.layout) for observable in observables
   ]
   
   # One pub, with one circuit to run against five different observables.
   job = estimator.run([(isa_circuit, mapped_observables)])
   
   # Use the job ID to retrieve your job data later
   print(f">>> Job ID: {job.job_id()}")
   

6. 获得测量结果（期望、标准差），

   # This is the result of the entire submission.  You submitted one Pub,
   # so this contains one inner result (and some metadata of its own).
   job_result = job.result()
   
   # This is the result from our single pub, which had six observables,
   # so contains information on all six.
   pub_result = job.result()[0]
   

7. 最后分析结果，

   # Plot the result
   
   values = pub_result.data.evs
   errors = pub_result.data.stds
   
   # plotting graph
   plt = plot_errorbar(
       x_data=[observables_labels],
       y_data=[values],
       y_err=[errors],
       labels=["result"],
       title="",
       xlabel="Observables",
       ylabel="Values"
   )
   
   plt.show()
   

   这里的 plot_errorbar 详见 这里，其绘制结果如下，

   

可以看到，测量 $Z\otimes Z$ 和 $X\otimes X$ 上的值为 $\pm 1$，其他测量上的值为 $0$，这说明电路的输出是纠缠的两比特，这是 Bell 态的特征。

量子算法

QFT

下面是 QFT 算法的实现，

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_histogram
from qiskit_aer import Aer
from qiskit.quantum_info import Statevector

# QFT 算法
def qft(n):
    """n-qubit QFT"""
    qc_qft = QuantumCircuit(n)
    for i in range(n):
        qc_qft.h(i)
        for j in range(i+1, n):
            qc_qft.cp(np.pi / 2**(j-i), i, j)
        qc_qft.barrier()
    return qc_qft

# 创建 3-qubit 大小的 QFT 电路
qc_qft = qft(3)

# 测量算子
qc_qft.measure_all()

# 绘制量子电路
qc_qft.draw(output='mpl')

# 执行量子电路并获取结果
simulator = Aer.get_backend('qasm_simulator')
transpiled_circuit = transpile(qc_qft, simulator)
job = simulator.run(transpiled_circuit, shots=1000)

result = job.result()
counts = result.get_counts(qc_qft)

print("QFT Measurement results:", counts)
plot_histogram(counts)

Grover

下面是 Grover 算法的实现，对 3-qubit 的函数 $f(x)=1⟺x=|010⟩$ 做搜索，

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector

# 3-qubit Grover搜索算法实现
def build_oracle():
    """构建针对|010⟩的Oracle电路"""
    oracle = QuantumCircuit(3, name="Oracle")
    
    # 对|010⟩取反（Qiskit中量子比特顺序为从右到左）
    oracle.x(0)  # 将第0个量子比特从0变为1
    oracle.x(2)  # 将第2个量子比特从0变为1
    
    # 多控制Z门（MCZ）
    oracle.h(2)
    oracle.mcx([0, 1], 2)  # 控制比特0和1，目标比特2
    oracle.h(2)

    # 恢复取反操作
    oracle.x(0)
    oracle.x(2)
    
    return oracle

def build_diffuser(n_qubits):
    """构建振幅放大部分（扩散算子）"""
    diffuser = QuantumCircuit(n_qubits, name="Diffuser")
    
    # 应用Hadamard门和X门
    for qubit in range(n_qubits):
        diffuser.h(qubit)
        diffuser.x(qubit)
    
    # 多控制Z门（MCZ）
    diffuser.h(n_qubits-1)
    diffuser.mcx(list(range(n_qubits-1)), n_qubits-1)
    diffuser.h(n_qubits-1)
    
    # 恢复Hadamard门和X门
    for qubit in range(n_qubits):
        diffuser.x(qubit)
        diffuser.h(qubit)
    
    return diffuser

def run_grover_algorithm():
    """运行完整的Grover搜索算法"""
    # 创建量子电路
    n_qubits = 3
    qc = QuantumCircuit(n_qubits, n_qubits)
    
    # 步骤1: 初始化所有量子比特到|+⟩状态
    for qubit in range(n_qubits):
        qc.h(qubit)
    qc.barrier()
    
    # 步骤2: 应用Oracle和Diffuser
    # 对于3个量子比特，需要进行π/4 * √(2^3) ≈ 1.11次迭代，取整为1次
    iterations = 1
    oracle = build_oracle()
    diffuser = build_diffuser(n_qubits)
    
    for _ in range(iterations):
        qc.append(oracle, range(n_qubits))
        qc.barrier()
        qc.append(diffuser, range(n_qubits))
        qc.barrier()
    
    # 步骤3: 测量所有量子比特
    qc.measure(range(n_qubits), range(n_qubits))
    
    return qc

# 构建Grover电路
grover_circuit = run_grover_algorithm()

# 绘制电路
print("Grover搜索电路:")
print(grover_circuit.draw())

# 使用模拟器执行电路
shots=1000
simulator = Aer.get_backend('qasm_simulator')
transpiled_circuit = transpile(grover_circuit, simulator)
job = simulator.run(transpiled_circuit, shots=shots)

result = job.result()
counts = result.get_counts(grover_circuit)

# 打印结果
print("\n测量结果:")
for state, count in counts.items():
    print(f"状态 |{state[::-1]}⟩ 出现次数: {count} ({count/shots*100:.2f}%)")

# 可视化结果
plot_histogram(counts)