Qiskit 与 Python 量子编程实战

# 创建虚拟环境（推荐）
python -m venv qiskit-env
source qiskit-env/bin/activate  # Linux/macOS
# qiskit-env\Scripts\activate  # Windows

# 安装 Qiskit
pip install qiskit qiskit-ibm-runtime

# 验证安装
python -c "import qiskit; print(qiskit.__version__)"

from qiskit_ibm_runtime import QiskitRuntimeService

# 保存令牌（首次）
QiskitRuntimeService.save_account(
    channel="ibm_quantum",
    token="YOUR_TOKEN_HERE",
    set_as_default=True,
)

# 后续直接使用
service = QiskitRuntimeService()
print("可用后端:", [b.name for b in service.backends()])
# 输出类似：['ibm_brisbane', 'ibm_sherbrooke', 'ibm_kyiv', ...]

from qiskit import QuantumCircuit
import matplotlib.pyplot as plt

# 创建一个 2 量子比特、2 经典比特的电路
qc = QuantumCircuit(2, 2)

# 第一步：在第一个量子比特上应用 H 门（创建叠加态）
qc.h(0)

# 第二步：应用 CNOT 门（以量子比特 0 为控制，量子比特 1 为目标）
# 这会将两个量子比特纠缠为贝尔态
qc.cx(0, 1)

# 第三步：测量两个量子比特，结果存入经典比特
qc.measure([0, 1], [0, 1])

# 可视化电路
print("量子电路：")
print(qc.draw(output='text'))

# 保存高清图片
qc.draw(output='mpl', style='iqp')
plt.savefig('bell_circuit.png', dpi=150)

from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram

# 使用 Aer 模拟器
simulator = AerSimulator()

# 编译电路（适配后端指令集）
from qiskit import transpile
compiled_circuit = transpile(qc, simulator)

# 运行 1000 次
job = simulator.run(compiled_circuit, shots=1000)
result = job.result()

# 获取统计结果
counts = result.get_counts()
print("测量结果:", counts)
# 预期输出：{'00': ~500, '11': ~500}

# 可视化
fig = plot_histogram(counts)
fig.savefig('bell_histogram.png')

from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

service = QiskitRuntimeService()

# 选择一个可用的量子后端（根据量子位数量和队列长度选择）
backend = service.least_busy(operational=True, simulator=False)
print(f"使用后端: {backend.name}")

# 编译电路适配真实硬件
compiled = transpile(qc, backend)

# 使用 Sampler primitive 运行
sampler = Sampler(mode=backend)
job = sampler.run([compiled], shots=1024)

print(f"任务 ID: {job.job_id()}")
print("等待结果...")
result = job.result()

# 真实的量子计算有噪声，结果不会 100% 集中在 00/11
counts = result[0].data.c.get_counts()
print("量子机测量结果:", counts)
# 可能输出：{'00': 480, '11': 460, '01': 42, '10': 42}
# 误差来自量子噪声（退相干、门误差）

from qiskit import QuantumCircuit

qc = QuantumCircuit(3)  # 3 个量子比特

# ===== 单量子比特门 =====
qc.x(0)       # Pauli-X（量子非门）
qc.y(0)       # Pauli-Y
qc.z(0)       # Pauli-Z（相位翻转）
qc.h(0)       # Hadamard（创建叠加）
qc.s(0)       # S 门（相位 π/2）
qc.t(0)       # T 门（相位 π/4）

# 通用旋转门（绕布洛赫球三个轴）
qc.rx(np.pi/4, 0)   # 绕 X 轴旋转 π/4
qc.ry(np.pi/3, 0)   # 绕 Y 轴旋转 π/3
qc.rz(np.pi/2, 0)   # 绕 Z 轴旋转 π/2

# U 门（最通用的单量子比特门）
# U(θ, φ, λ) = RZ(φ) * RY(θ) * RZ(λ)
qc.u(np.pi/2, 0, np.pi, 0)

# ===== 双量子比特门 =====
qc.cx(0, 1)   # CNOT（受控非）
qc.cz(0, 1)   # CZ（受控 Z）
qc.swap(0, 1) # SWAP（交换）

# 受控旋转
qc.crx(np.pi/2, 0, 1)  # 控制位为 |1⟩ 时对目标做 RX

# ===== 三量子比特门 =====
qc.ccx(0, 1, 2)  # Toffoli（双控非）
qc.cswap(0, 1, 2)  # Fredkin（受控交换）

print(qc.draw())

from qiskit.circuit import Parameter
import numpy as np

# 定义参数
theta = Parameter('θ')
phi = Parameter('φ')

# 构建参数化电路（常用于变分量子算法 VQE/QAOA）
qc = QuantumCircuit(2)
qc.rx(theta, 0)
qc.ry(phi, 1)
qc.cx(0, 1)

# 绑定参数值
bound_circuit = qc.assign_parameters({theta: np.pi/4, phi: np.pi/3})
print(bound_circuit.draw())

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
import numpy as np

# ===== 构建 Oracle =====
# Oracle 是一个黑盒函数，量子查询通过控制操作实现
# 这里构造一个"平衡函数"的 Oracle

def create_oracle(n, oracle_type='balanced'):
    """
    n: 输入比特数
    oracle_type: 'constant' 或 'balanced'
    """
    oracle = QuantumCircuit(n + 1)
    
    if oracle_type == 'balanced':
        # 平衡函数：一半输入输出 0，一半输出 1
        # 实现：对第一个输入做 CNOT
        oracle.cx(0, n)
    else:
        # 常数函数：所有输入输出相同
        # 常数 0：不做任何操作
        # 常数 1：翻转输出比特
        oracle.x(n)
    
    return oracle

# ===== 完整的 Deutsch-Jozsa 算法电路 =====
n = 3  # 3 个输入比特

dj_circuit = QuantumCircuit(n + 1, n)

# 步骤1：最后一个量子比特设为 |1⟩
dj_circuit.x(n)

# 步骤2：所有量子比特应用 H
dj_circuit.h(range(n + 1))

# 步骤3：插入 Oracle
oracle = create_oracle(n, 'balanced')
dj_circuit = dj_circuit.compose(oracle)

# 步骤4：前 n 个量子比特再应用 H
dj_circuit.h(range(n))

# 步骤5：测量前 n 个量子比特
dj_circuit.measure(range(n), range(n))

print(dj_circuit.draw())

# ===== 在模拟器中运行 =====
simulator = AerSimulator()
compiled = transpile(dj_circuit, simulator)
result = simulator.run(compiled, shots=1024).result()
counts = result.get_counts()

print("测量结果:", counts)
# 如果是平衡函数：结果不会是 |000⟩
# 如果是常数函数：结果一定是 |000⟩

# 判断逻辑
if '0' * n in counts and counts['0' * n] == 1024:
    print("函数是常数函数")
else:
    print("函数是平衡函数")

from qiskit_ibm_runtime import Estimator
from qiskit.primitives import EstimatorPub
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# 生成带错误缓解的 Estimator
estimator = Estimator(mode=backend, options={
    "resilience": {
        "measure_mitigation": True,  # 测量错误缓解
        "zne_mitigation": True,      # 零噪声外推
    }
})