本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。 # 模拟哈密顿模拟 [模拟哈密顿模拟](https://en.wikipedia.org/wiki/Hamiltonian_simulation)（AHS）是量子计算的新兴范式，与传统的量子电路模型有很大的不同。它不是一系列门，即每个电路一次只能作用于几个量子比特。AHS 程序由相关哈密顿量的时变和空间相关参数定义。[系统的哈密顿量](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics))对其能级和外力的影响进行编码，它们共同控制着其状态的时间演变。对于 N 量子比特系统，哈密顿量可以用 2NX2N 个复数方阵表示。 能够执行 AHS 的量子设备旨在通过仔细调整其内部控制参数，近似定制哈密顿量下的量子系统的时间演变。例如，调整相干驱动场的振幅和失谐参数。AHS 范式非常适合模拟具有许多相互作用粒子的量子系统的静态和动态特性，比如在凝聚态物理学或量子化学中。专门设计的量子处理单元 (QPUs)，例如的 [Aquila设备](https://aws.amazon.com/braket/quantum-computers/quera/)QuEra，是为了利用AHS的力量，以创新的方式解决传统数字量子计算方法无法解决的问题。 **Topics** + [Hello AHS：运行您的第一个模拟哈密顿模拟](braket-get-started-hello-ahs.md) + [使用 A QuEra quila 提交模拟节目](braket-quera-submitting-analog-program-aquila.md) # Hello AHS：运行您的第一个模拟哈密顿模拟 本节提供了有关运行第一个模拟哈密顿模拟的信息。 **Topics** + [交互式旋转链](#braket-get-started-interacting-spin-chain) + [排列](#braket-get-started-arrangement) + [相互作用](#braket-get-started-interaction) + [驱动场](#braket-get-started-driving-field) + [AHS 程序](#braket-get-started-ahs-program) + [在本地模拟器上运行](#braket-get-started-running-local-simulator) + [分析模拟器结果](#braket-get-started-analyzing-simulator-results) + [Run QuEra ning on 的 Aquila QPU](#braket-get-started-running-aquila-qpu) + [分析结果](#braket-get-started-analyzing-qpu-results) + [后续步骤](#braket-get-started-ahs-next) ## 交互式旋转链 举一个由许多相互作用粒子组成的系统的典型示例，让我们考虑一个由八个旋转组成的环（每个旋转都可以处于“向上”∣↑⟩ 和“向下”∣↓⟩ 的状态）。尽管规模很小，但该模型系统已经表现出自然存在的磁性材料的一些有趣现象。在此例中，我们将展示如何准备一个所谓的反铁磁阶数，即连续的自旋指向相反的方向。 ![\[连接 8 个包含向上和向下反向箭头的圆形节点的示意图。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/AntiFerromagnetic.png) ## 排列 我们将使用一个中性原子来代表每次自旋，“向上”和“向下”自旋态将分别以激发的里德伯格态和原子的基态编码。首先，创建二维排列。我们可以用以下代码对上面的旋转圈进行编程。 **先决条件**：您需要 pip 安装 [Braket SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk)。（如果您使用的是 Braket 托管的 Notebook 实例，则此 SDK 已预先安装在 Notebook 中。） 要重现绘图，您还需要使用 shell 命令 `pip install matplotlib` 单独安装 matplotlib。 ``` from braket.ahs.atom_arrangement import AtomArrangement import numpy as np import matplotlib.pyplot as plt # Required for plotting a = 5.7e-6 # Nearest-neighbor separation (in meters) register = AtomArrangement() register.add(np.array([0.5, 0.5 + 1/np.sqrt(2)]) * a) register.add(np.array([0.5 + 1/np.sqrt(2), 0.5]) * a) register.add(np.array([0.5 + 1/np.sqrt(2), - 0.5]) * a) register.add(np.array([0.5, - 0.5 - 1/np.sqrt(2)]) * a) register.add(np.array([-0.5, - 0.5 - 1/np.sqrt(2)]) * a) register.add(np.array([-0.5 - 1/np.sqrt(2), - 0.5]) * a) register.add(np.array([-0.5 - 1/np.sqrt(2), 0.5]) * a) register.add(np.array([-0.5, 0.5 + 1/np.sqrt(2)]) * a) ``` 我们还可以绘制散点图， ``` fig, ax = plt.subplots(1, 1, figsize=(7, 7)) xs, ys = [register.coordinate_list(dim) for dim in (0, 1)] ax.plot(xs, ys, 'r.', ms=15) for idx, (x, y) in enumerate(zip(xs, ys)): ax.text(x, y, f" {idx}", fontsize=12) plt.show() # This will show the plot below in an ipython or jupyter session ``` ![\[显示在两个轴上的正值和负值分布的点。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/PlotNeutralAtoms.png) ## 相互作用 为准备反铁磁相，我们需要诱导相邻自旋之间的相互作用。为此，我们使用了 [van der Waals 相互作用](https://en.wikipedia.org/wiki/Van_der_Waals_force)，该相互作用是由中性原子设备（如来自 QuEra 的 Aquila 设备）原生实现的。这种相互作用的哈密顿项使用自旋表示，可以表示为所有自旋对 (j,k) 的总和。 ![\[这种相互作用的哈密顿项使用自旋表示，可以表示为所有自旋对 (j,k) 的总和。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/HInteraction.png) 其中：nj=∣↑j​⟩⟨↑j​∣ 是一个运算符，仅当自旋 j 处于“向上”状态时才取值 1，否则取值 0。强度为 Vj,k​=C6​/(dj,k​)6，其中：C6 是固定系数，dj,k 是自旋 j 和 k 之间的欧几里得距离。这个相互作用项的直接影响是，任何自旋 j 和自旋 k 都是“向上”状态的能量都会升高（按量 Vj,k）。通过精心设计 AHS 程序的其余部分，这种相互作用可防止相邻的旋转都处于“向上”状态，这种效果通常被称为“Rydberg 阻塞”。 ## 驱动场 AHS 程序开始时，所有旋转（默认情况下）都以“向下”状态开始，它们处于所谓的铁磁阶段。着眼于准备反铁磁相位的目标，我们指定了一个时变相干驱动场，该驱动场可以平稳地将自旋从这种状态过渡到多体状态，首选为“向上”状态。相应的哈密顿量可以写成 ![\[描述哈密顿驱动函数计算的数学方程。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/HDrive.png) 其中 Ω(t)、(t)、Δ(t) 是时变全局振幅（又名 [Rabi 频率](https://en.wikipedia.org/wiki/Rabi_frequency)）、相位和失谐均匀地影响所有自旋的驱动场。其中：S−,k​ =∣↓k​⟩⟨↑k​∣and S\$1,k​​=(S−,k​)†=∣↑k​⟩⟨↓k​∣分别是 spin k 的降低和升高运算符，nk​=∣↑k​⟩⟨↑k​∣和以前的运算符相同。驱动场的 Ω 部分同时连贯地耦合所有旋转的“向下”和“向上”状态，而 Δ 部分控制“向上”状态的能量奖励。 为了对从铁磁相向到反铁磁相的平滑过渡进行编程，我们使用以下代码指定驱动场。 ``` from braket.timings.time_series import TimeSeries from braket.ahs.driving_field import DrivingField # Smooth transition from "down" to "up" state time_max = 4e-6 # seconds time_ramp = 1e-7 # seconds omega_max = 6300000.0 # rad / sec delta_start = -5 * omega_max delta_end = 5 * omega_max omega = TimeSeries() omega.put(0.0, 0.0) omega.put(time_ramp, omega_max) omega.put(time_max - time_ramp, omega_max) omega.put(time_max, 0.0) delta = TimeSeries() delta.put(0.0, delta_start) delta.put(time_ramp, delta_start) delta.put(time_max - time_ramp, delta_end) delta.put(time_max, delta_end) phi = TimeSeries().put(0.0, 0.0).put(time_max, 0.0) drive = DrivingField( amplitude=omega, phase=phi, detuning=delta ) ``` 我们可以使用以下脚本可视化驱动场的时间序列。 ``` fig, axes = plt.subplots(3, 1, figsize=(12, 7), sharex=True) ax = axes[0] time_series = drive.amplitude.time_series ax.plot(time_series.times(), time_series.values(), '.-') ax.grid() ax.set_ylabel('Omega [rad/s]') ax = axes[1] time_series = drive.detuning.time_series ax.plot(time_series.times(), time_series.values(), '.-') ax.grid() ax.set_ylabel('Delta [rad/s]') ax = axes[2] time_series = drive.phase.time_series # Note: time series of phase is understood as a piecewise constant function ax.step(time_series.times(), time_series.values(), '.-', where='post') ax.set_ylabel('phi [rad]') ax.grid() ax.set_xlabel('time [s]') plt.show() # This will show the plot below in an ipython or jupyter session ``` ![\[三张图显示了一段时间内的 phi、delta 和 omega。顶部的子图显示增长到略高于 6， rads/s 在此处它保持 4 秒钟，直到回落到 0。中间的图描绘了导数的相关线性增长，底图描绘了一条接近零的平线。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/DrivingTimeSeries.png) ## AHS 程序 寄存器、驱动场（以及隐式的范德华相互作用）构成了模拟哈密顿模拟程序 `ahs_program`。 ``` from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation ahs_program = AnalogHamiltonianSimulation( register=register, hamiltonian=drive ) ``` ## 在本地模拟器上运行 由于此示例很小（少于 15 次旋转），因此在兼容 AHS 的 QPU 上运行之前，我们可以在 Braket SDK 附带的本地 AHS 模拟器上运行它。由于本地模拟器可免费使用 Braket SDK，因而这是确保我们的代码能够正确执行的最佳实践。 在这里，我们可以将拍摄次数设置为较大的值（比如 100 万），因为本地模拟器会跟踪量子态的时间演变并从最终状态中抽取样本；因此，可以增加拍摄次数，而总运行时仅略有增加。 ``` from braket.devices import LocalSimulator device = LocalSimulator("braket_ahs") result_simulator = device.run( ahs_program, shots=1_000_000 ).result() # Takes about 5 seconds ``` ## 分析模拟器结果 我们可以使用以下函数汇总拍摄结果，该函数可以推断每次旋转的状态（可以是“d”代表“向下”，“u”表示“向上”，“e“代表空场地），并计算每种配置在拍摄中发生的次数。 ``` from collections import Counter def get_counts(result): """Aggregate state counts from AHS shot results A count of strings (of length = # of spins) are returned, where each character denotes the state of a spin (site): e: empty site u: up state spin d: down state spin Args: result (braket.tasks.analog_hamiltonian_simulation_quantum_task_result.AnalogHamiltonianSimulationQuantumTaskResult) Returns dict: number of times each state configuration is measured """ state_counts = Counter() states = ['e', 'u', 'd'] for shot in result.measurements: pre = shot.pre_sequence post = shot.post_sequence state_idx = np.array(pre) * (1 + np.array(post)) state = "".join(map(lambda s_idx: states[s_idx], state_idx)) state_counts.update((state,)) return dict(state_counts) counts_simulator = get_counts(result_simulator) # Takes about 5 seconds print(counts_simulator) ``` ``` *[Output]* {'dddddddd': 5, 'dddddddu': 12, 'ddddddud': 15, ...} ``` 在这里，`counts` 是一本字典，它计算了拍摄中观察到的每种状态配置的次数。我们还可以使用以下代码实现它们的可视化。 ``` from collections import Counter def has_neighboring_up_states(state): if 'uu' in state: return True if state[0] == 'u' and state[-1] == 'u': return True return False def number_of_up_states(state): return Counter(state)['u'] def plot_counts(counts): non_blockaded = [] blockaded = [] for state, count in counts.items(): if not has_neighboring_up_states(state): collection = non_blockaded else: collection = blockaded collection.append((state, count, number_of_up_states(state))) blockaded.sort(key=lambda _: _[1], reverse=True) non_blockaded.sort(key=lambda _: _[1], reverse=True) for configurations, name in zip((non_blockaded, blockaded), ('no neighboring "up" states', 'some neighboring "up" states')): plt.figure(figsize=(14, 3)) plt.bar(range(len(configurations)), [item[1] for item in configurations]) plt.xticks(range(len(configurations))) plt.gca().set_xticklabels([item[0] for item in configurations], rotation=90) plt.ylabel('shots') plt.grid(axis='y') plt.title(f'{name} configurations') plt.show() plot_counts(counts_simulator) ``` ![\[条形图显示了大量没有相邻的“向上”状态配置的拍摄。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/AHSCounts1.png) ![\[条形图显示了一些相邻的“向上”状态配置的拍摄，其中 1.0 次拍摄有 4 个状态。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/AHSCounts2.png) 从图中，我们可以读出以下观测结果，以验证我们成功制备了反铁磁相。 1. 通常，非阻塞状态（没有两个相邻的旋转处于“向上”状态）比至少有一对相邻旋转都处于“向上”状态的状态更为常见。 1. 通常，除非配置被阻止，否则会优先选择激励更多“向上”状态。 1. 最常见的状态确实是完美的反铁磁态 `"dudududu"` 和 `"udududud"`。 1. 第二种常见的状态是只有 3 个“向上”激励，连续间隔为 1、2、2 的状态。这表明范德华的相互作用也会对最近的邻居产生影响（尽管该影响要小得多）。 ## Run QuEra ning on 的 Aquila QPU **先决条件**：除了 pip 安装 [Braket SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) 之外，如果您不熟悉 Amazon Braket，请确保您已完成必要的[入门步骤](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html)。 **注意** 如果您使用的是 Braket 托管的 Notebook 实例，则该实例预装了 Braket SDK。 安装所有依赖项后，我们就可以连接到 Aquila QPU 了。 ``` from braket.aws import AwsDevice aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila") ``` 为了使我们的 AHS 程序适合 QuEra 机器，我们需要对所有值进行四舍五入，以符合 Aquila QPU 规定的精度水平。（这些要求受名称中带有“分辨率”的设备参数的约束。我们可以通过在 Notebook 中执行 `aquila_qpu.properties.dict()` 来看到它们。有关 Aquila 功能和要求的更多详细信息，请参阅 [Aquila Notebook 简介](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb)。） 我们可以通过调用 `discretize` 方法来做到这一点。 ``` discretized_ahs_program = ahs_program.discretize(aquila_qpu) ``` 现在，我们可以在 Aquila QPU 上运行该程序（目前只运行 100 次拍摄）。 **注意** 在 Aquila 处理器上运行此程序将产生一定的成本。Amazon Braket SDK 包含一个[成本追踪器](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/)，这样，客户能够设置成本限额并近乎实时地跟踪成本。 ``` task = aquila_qpu.run(discretized_ahs_program, shots=100) metadata = task.metadata() task_arn = metadata['quantumTaskArn'] task_status = metadata['status'] print(f"ARN: {task_arn}") print(f"status: {task_status}") ``` ``` *[Output]* ARN: arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef status: CREATED ``` 由于量子任务的运行时差异很大（取决于可用窗口和 QPU 利用率），因此记下量子任务 ARN 是个好主意，这样我们就可以在后续时间使用以下代码片段检查其状态了。 ``` # Optionally, in a new python session from braket.aws import AwsQuantumTask SAVED_TASK_ARN = "arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef" task = AwsQuantumTask(arn=SAVED_TASK_ARN) metadata = task.metadata() task_arn = metadata['quantumTaskArn'] task_status = metadata['status'] print(f"ARN: {task_arn}") print(f"status: {task_status}") ``` ``` *[Output]* ARN: arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef status: COMPLETED ``` 状态为“已完成”（也可以从 Amazon Braket [控制台](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks)的量子任务页面进行检查）后，我们可以通过以下方式查询结果： ``` result_aquila = task.result() ``` ## 分析结果 我们可以使用与以前相同的 `get_counts` 函数计算计数。 ``` counts_aquila = get_counts(result_aquila) print(counts_aquila) ``` ``` *[Output]* {'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...} ``` 然后，用 `plot_counts` 绘制函数： ``` plot_counts(counts_aquila) ``` ![\[条形图显示了大量没有相邻的“向上”状态配置的拍摄。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/QPUPlotCounts1.png) ![\[条形图显示了一些相邻的“向上”状态配置的拍摄，其中 1.0 次拍摄有 4 个状态。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/QPUPlotCounts2.png) 请注意，一小部分拍摄的场地为空（标为“e”）。这是由于 Aquila QPU 的每个原子制备存在 1%-2% 的缺陷。除此之外，由于拍摄次数少，结果在预期的统计波动范围内与模拟相符。 ## 后续步骤 恭喜！您现在已经使用本地 AHS 模拟器和 Aquila QPU 在 Amazon Braket 上运行了第一个 AHS 工作负载。 要了解有关 Rydberg 物理学、模拟哈密顿模拟和 Aquila 设备的更多信息，请参阅我们的[示例 Notebook。](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation) # 使用 A QuEra quila 提交模拟节目 本页提供了有关来自 QuEra 的 Aquila 机器能力的整个文档。此处涵盖的详细信息如下： 1. 通过以下方法模拟的参数化哈密顿量模型 Aquila 1. AHS 程序参数 1. AHS 结果内容 1. Aquila 能力参数 **Topics** + [哈密顿量](#braket-quera-aquila-device-hamiltonian) + [Braket AHS 程序架构](#braket-quera-ahs-program-schema) + [Braket AHS 任务结果架构](#braket-quera-ahs-task-result-schema) + [QuEra 设备属性架构](#braket-quera-device-properties-schema) ## 哈密顿量 来自 QuEra 的 Aquila 机器以原生方式对以下（时变）哈密顿量程进行模拟。 ![\[数学方程，其中：求和表示系统的哈密顿量，包括驱动、局部失谐和点间耦合项。\]](http://docs.aws.amazon.com/zh_cn/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png) **注意** 访问局部失谐是一项[实验能力](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html)，可通过 Braket Direct 申请获得。 where + Hdrive,k​(t)=( 1/2 ​Ω(t)eiϕ(t)S−,k​ \$1 1/2 ​Ω(t)e−iϕ(t) S\$1,k​) \$1 (−Δglobal​(t)nk​)， + Ω(t) 是时变全局驱动振幅（又名 Rabi 频率），单位为（弧度/秒） + ϕ(t) 是时变全局相位，单位为弧度 + S−,k​ 和 S\$1,k 是原子 k 的自旋降低和升高运算符（在基数中，\$1↓⟩=\$1g⟩,\$1↑⟩=\$1r），它们是 S−​=\$1g⟩⟨r\$1,S\$1​=(S−​)†=\$1r⟩⟨g\$1) + Δglobal​(t) 是时变全局失谐 + nk 是原子 k 的里德伯格状态的投影运算符（也就是说，n=\$1r⟩⟨r\$1） + Hlocal detuning,k(t)=-Δlocal(t)hknk + Δlocal(t) 是局部频移的时变因子，单位为（弧度/秒） + hk 是与位置相关的因子，介于 0.0 到 1.0 之间的无量纲数字 + Vvdw,k,l​=C6​/(dk,l​)6nk​nl​， + C6 是范德华系数，单位为 (rad / s) \$1 (m)^6 + dk,l 是原子 k 和 l 之间的欧几里得距离，单位为米。 用户可以通过 Braket AHS 程序架构控制以下参数。 + 二维原子排列（每个原子 k 的 xk 和 yk 坐标，单位为 um），它控制成对原子距离 dk,l​，其中：k,l=1,2,…N + Ω(t)，时变全局 Rabi 频率，单位为（弧度/秒） + ϕ(t)，时变全局相位，单位为（弧度） + Δglobal​(t)，时变全局失谐，单位为（弧度/秒） + Δlocal(t)，局部失谐振幅的时变（全局）因子，单位为（弧度/秒） + hk，与地点相关的局部失谐振幅的（静态）因子，属于介于 0.0 和 1.0 之间的无量纲数字 **注意** 用户无法控制涉及哪些级别（即 S−、S\$1​、n 运算符是固定的），也无法控制里德伯-里德伯交互系数 (C6) 的强度。 ## Braket AHS 程序架构 **braket.ir.ahs.program\$1v1.Program 对象**（示例） **注意** 如果您的账户未启用[局部失谐](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning)功能，请在以下示例中使用 `localDetuning=[]`。 ``` Program( braketSchemaHeader=BraketSchemaHeader( name='braket.ir.ahs.program', version='1' ), setup=Setup( ahs_register=AtomArrangement( sites=[ [Decimal('0'), Decimal('0')], [Decimal('0'), Decimal('4e-6')], [Decimal('4e-6'), Decimal('0')] ], filling=[1, 1, 1] ) ), hamiltonian=Hamiltonian( drivingFields=[ DrivingField( amplitude=PhysicalField( time_series=TimeSeries( values=[Decimal('0'), Decimal('15700000.0'), Decimal('15700000.0'), Decimal('0')], times=[Decimal('0'), Decimal('0.000001'), Decimal('0.000002'), Decimal('0.000003')] ), pattern='uniform' ), phase=PhysicalField( time_series=TimeSeries( values=[Decimal('0'), Decimal('0')], times=[Decimal('0'), Decimal('0.000003')] ), pattern='uniform' ), detuning=PhysicalField( time_series=TimeSeries( values=[Decimal('-54000000.0'), Decimal('54000000.0')], times=[Decimal('0'), Decimal('0.000003')] ), pattern='uniform' ) ) ], localDetuning=[ LocalDetuning( magnitude=PhysicalField( times_series=TimeSeries( values=[Decimal('0'), Decimal('25000000.0'), Decimal('25000000.0'), Decimal('0')], times=[Decimal('0'), Decimal('0.000001'), Decimal('0.000002'), Decimal('0.000003')] ), pattern=Pattern([Decimal('0.8'), Decimal('1.0'), Decimal('0.9')]) ) ) ] ) ) ``` **JSON**（示例） **注意** 如果您的账户未启用[局部失谐](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning)功能，请在以下示例中使用 `"localDetuning": []`。 ``` { "braketSchemaHeader": { "name": "braket.ir.ahs.program", "version": "1" }, "setup": { "ahs_register": { "sites": [ [0E-7, 0E-7], [0E-7, 4E-6], [4E-6, 0E-7] ], "filling": [1, 1, 1] } }, "hamiltonian": { "drivingFields": [ { "amplitude": { "time_series": { "values": [0.0, 15700000.0, 15700000.0, 0.0], "times": [0E-9, 0.000001000, 0.000002000, 0.000003000] }, "pattern": "uniform" }, "phase": { "time_series": { "values": [0E-7, 0E-7], "times": [0E-9, 0.000003000] }, "pattern": "uniform" }, "detuning": { "time_series": { "values": [-54000000.0, 54000000.0], "times": [0E-9, 0.000003000] }, "pattern": "uniform" } } ], "localDetuning": [ { "magnitude": { "time_series": { "values": [0.0, 25000000.0, 25000000.0, 0.0], "times": [0E-9, 0.000001000, 0.000002000, 0.000003000] }, "pattern": [0.8, 1.0, 0.9] } } ] } } ``` **主要字段** | 程序字段 | 类型 | 描述 | | --- | --- | --- | | setup.ahs\$1register.sites | List[List[Decimal]] | 镊子捕获原子的二维坐标清单 | | setup.ahs\$1register.filling | List[int] | 用 1 标记占据陷阱位点的原子，用 0 标记占据空位点的原子 | | hamiltonian.drivingFields[].amplitude.time\$1series.times | List[Decimal] | 驱动振幅的时间点，Omega(t) | | hamiltonian.drivingFields[].amplitude.time\$1series.values | List[Decimal] | 驱动振幅值，Omega(t) | | hamiltonian.drivingFields[].amplitude.pattern | str | 驱动振幅的空间规律，Omega(t)；必须是“均匀的” | | hamiltonian.drivingFields[].phase.time\$1series.times | List[Decimal] | 驾驶相位的时间点，phi(t) | | hamiltonian.drivingFields[].phase.time\$1series.values | List[Decimal] | 驱动相位的值，phi(t) | | hamiltonian.drivingFields[].phase.pattern | str | 驱动相位的空间规律，phi(t)；必须是“均匀的” | | hamiltonian.drivingFields[].detuning.time\$1series.times | List[Decimal] | 驱动的时间点，delta\$1Global(t) | | hamiltonian.drivingFields[].detuning.time\$1series.values | List[Decimal] | 驱动失谐值，delta\$1Global(t) | | hamiltonian.drivingFields[].detuning.pattern | str | 驾驶失谐的空间规律，delta\$1Global(t)；必须是“均匀的” | | hamiltonian.localDetuning[].magnitude.time\$1series.times | List[Decimal] | 局部失谐振幅的时变因子的时间点，delta\$1Local(t) | | hamiltonian.localDetuning[].magnitude.time\$1series.values | List[Decimal] | 局部失谐振幅的时变因子值，delta\$1Local(t) | | hamiltonian.localDetuning[].magnitude.pattern | List[Decimal] | 局部失谐振幅的站点相关因子 h\$1k（数值对应于 setup.ahs\$1register.sites 中的站点） | **元数据字段** | 程序字段 | 类型 | 描述 | | --- | --- | --- | | braketSchemaHeader.name | str | 架构的名称；必须是“braket.ir.ahs.program” | | braketSchemaHeader. 版本 | str | 架构版本 | ## Braket AHS 任务结果架构 **braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result AnalogHamiltonianSimulationQuantumTaskResult**（示例） ``` AnalogHamiltonianSimulationQuantumTaskResult( task_metadata=TaskMetadata( braketSchemaHeader=BraketSchemaHeader( name='braket.task_result.task_metadata', version='1' ), id='arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef', shots=2, deviceId='arn:aws:braket:us-east-1::device/qpu/quera/Aquila', deviceParameters=None, createdAt='2022-10-25T20:59:10.788Z', endedAt='2022-10-25T21:00:58.218Z', status='COMPLETED', failureReason=None ), measurements=[ ShotResult( status=, pre_sequence=array([1, 1, 1, 1]), post_sequence=array([0, 1, 1, 1]) ), ShotResult( status=, pre_sequence=array([1, 1, 0, 1]), post_sequence=array([1, 0, 0, 0]) ) ] ) ``` **JSON**（示例） ``` { "braketSchemaHeader": { "name": "braket.task_result.analog_hamiltonian_simulation_task_result", "version": "1" }, "taskMetadata": { "braketSchemaHeader": { "name": "braket.task_result.task_metadata", "version": "1" }, "id": "arn:aws:braket:us-east-1:123456789012:quantum-task/12345678-90ab-cdef-1234-567890abcdef", "shots": 2, "deviceId": "arn:aws:braket:us-east-1::device/qpu/quera/Aquila", "createdAt": "2022-10-25T20:59:10.788Z", "endedAt": "2022-10-25T21:00:58.218Z", "status": "COMPLETED" }, "measurements": [ { "shotMetadata": {"shotStatus": "Success"}, "shotResult": { "preSequence": [1, 1, 1, 1], "postSequence": [0, 1, 1, 1] } }, { "shotMetadata": {"shotStatus": "Success"}, "shotResult": { "preSequence": [1, 1, 0, 1], "postSequence": [1, 0, 0, 0] } } ], "additionalMetadata": { "action": {...} "queraMetadata": { "braketSchemaHeader": { "name": "braket.task_result.quera_metadata", "version": "1" }, "numSuccessfulShots": 100 } } } ``` **主要字段** | 任务结果字段 | 类型 | 描述 | | --- | --- | --- | | measurements[].shotResult.preSequence | List[int] | 每次拍摄的预序测量位（每个原子位点一个）：如果位点为空，则为 0，如果位点已填满，则为 1，在运行量子进化的脉冲序列之前测量 | | measurements[].shotResult.postSequence | List[int] | 每次拍摄的序列后测量位：如果原子处于里德伯格状态或位点为空，则为 0；如果原子处于基态，则为 1，在运行量子进化的脉冲序列末尾测量 | **元数据字段** | 任务结果字段 | 类型 | 描述 | | --- | --- | --- | | braketSchemaHeader.name | str | 架构名称；必须是“braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result.result” | | braketSchemaHeader. 版本 | str | 架构版本 | | 任务元数据。 braketSchemaHeader.name | str | 架构名称；必须是“braket.task\$1result.task\$1metadata” | | 任务元数据。 braketSchemaHeader. 版本 | str | 架构版本 | | taskmetadata.id | str | 量子任务 ID。对于 AWS 量子任务，这是量子任务 ARN。 | | taskMetadata.shots | int | 量子任务的拍摄次数 | | taskmetadata.shots.deviceId | str | 运行量子任务的设备的 ID。对于 AWS 设备，这是设备 ARN。 | | taskMetadata.shots.createdAt | str | 创建的时间戳；格式必须采用 ISO-8 RFC3339 601/ 字符串格式：mm: ss.sssz。 YYYY-MM-DDTHH默认值：无。 | | taskMetadata.shots.endedAt | str | 量子任务结束的时间戳；格式必须采用 ISO-8 RFC3339 601/ 字符串格式：mm: ss.sssz。 YYYY-MM-DDTHH默认值：无。 | | taskMetadata.shots.status | str | 量子任务的状态（已创建、已排队、正在运行、已完成、失败）。默认值：无。 | | taskMetadata.shots.failureReason | str | 量子任务失败的原因。默认值：无。 | | additionalMetadata.action | braket.ir.ahs.program\$1v1.Program | （请参阅 [Braket AHS 程序架构](#braket-quera-ahs-program-schema)部分） | | 其他元数据.action。 braketSchemaHeader.querametadata.name | str | 架构名称；必须是“braket.task\$1result.quera\$1metadata” | | 其他元数据.action。 braketSchemaHeader.querametaData.version | str | 架构版本 | | 其他元数据.action。 numSuccessfulShots | int | 完全成功拍摄的次数；必须等于请求的拍摄次数 | | measurements[].shotMetadata.shotStatus | int | 拍摄状态（成功、部分成功、失败）；必须为“成功” | ## QuEra 设备属性架构 **braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1。 QueraDeviceCapabilities**（示例） ``` QueraDeviceCapabilities( service=DeviceServiceProperties( braketSchemaHeader=BraketSchemaHeader( name='braket.device_schema.device_service_properties', version='1' ), executionWindows=[ DeviceExecutionWindow( executionDay=, windowStartHour=datetime.time(1, 0), windowEndHour=datetime.time(23, 59, 59) ), DeviceExecutionWindow( executionDay=, windowStartHour=datetime.time(0, 0), windowEndHour=datetime.time(12, 0) ), DeviceExecutionWindow( executionDay=, windowStartHour=datetime.time(0, 0), windowEndHour=datetime.time(12, 0) ), DeviceExecutionWindow( executionDay=, windowStartHour=datetime.time(0, 0), windowEndHour=datetime.time(23, 59, 59) ), DeviceExecutionWindow( executionDay=, windowStartHour=datetime.time(0, 0), windowEndHour=datetime.time(23, 59, 59) ), DeviceExecutionWindow( executionDay=, windowStartHour=datetime.time(0, 0), windowEndHour=datetime.time(12, 0) ) ], shotsRange=(1, 1000), deviceCost=DeviceCost( price=0.01, unit='shot' ), deviceDocumentation= DeviceDocumentation( imageUrl='https://a.b.cdn.console.awsstatic.com/59534b58c709fc239521ef866db9ea3f1aba73ad3ebcf60c23914ad8c5c5c878/a6cfc6fca26cf1c2e1c6.png', summary='Analog quantum processor based on neutral atom arrays', externalDocumentationUrl='https://www.quera.com/aquila' ), deviceLocation='Boston, USA', updatedAt=datetime.datetime(2024, 1, 22, 12, 0, tzinfo=datetime.timezone.utc), getTaskPollIntervalMillis=None ), action={ : DeviceActionProperties( version=['1'], actionType= ) }, deviceParameters={}, braketSchemaHeader=BraketSchemaHeader( name='braket.device_schema.quera.quera_device_capabilities', version='1' ), paradigm=QueraAhsParadigmProperties( ... # See https://github.com/amazon-braket/amazon-braket-schemas-python/blob/main/src/braket/device_schema/quera/quera_ahs_paradigm_properties_v1.py ... ) ) ``` **JSON**（示例） ``` { "service": { "braketSchemaHeader": { "name": "braket.device_schema.device_service_properties", "version": "1" }, "executionWindows": [ { "executionDay": "Monday", "windowStartHour": "01:00:00", "windowEndHour": "23:59:59" }, { "executionDay": "Tuesday", "windowStartHour": "00:00:00", "windowEndHour": "12:00:00" }, { "executionDay": "Wednesday", "windowStartHour": "00:00:00", "windowEndHour": "12:00:00" }, { "executionDay": "Friday", "windowStartHour": "00:00:00", "windowEndHour": "23:59:59" }, { "executionDay": "Saturday", "windowStartHour": "00:00:00", "windowEndHour": "23:59:59" }, { "executionDay": "Sunday", "windowStartHour": "00:00:00", "windowEndHour": "12:00:00" } ], "shotsRange": [ 1, 1000 ], "deviceCost": { "price": 0.01, "unit": "shot" }, "deviceDocumentation": { "imageUrl": "https://a.b.cdn.console.awsstatic.com/59534b58c709fc239521ef866db9ea3f1aba73ad3ebcf60c23914ad8c5c5c878/a6cfc6fca26cf1c2e1c6.png", "summary": "Analog quantum processor based on neutral atom arrays", "externalDocumentationUrl": "https://www.quera.com/aquila" }, "deviceLocation": "Boston, USA", "updatedAt": "2024-01-22T12:00:00+00:00" }, "action": { "braket.ir.ahs.program": { "version": [ "1" ], "actionType": "braket.ir.ahs.program" } }, "deviceParameters": {}, "braketSchemaHeader": { "name": "braket.device_schema.quera.quera_device_capabilities", "version": "1" }, "paradigm": { ... # See Aquila device page > "Calibration" tab > "JSON" page ... } } ``` **服务属性字段** | 服务属性字段 | 类型 | 描述 | | --- | --- | --- | | service.executionWindows[].executionDay | ExecutionDay | 执行窗口的天数；必须是 “每天”、“工作日”、“周末”、“星期一”、“星期二”、“星期三”、“星期四”、“星期五”、“星期六”或“星期日” | | Service.executionWindows []。 windowStartHour | datetime.time | 执行窗口开始时间的 UTC 24 小时格式 | | Service.executionWindows []。 windowEndHour | datetime.time | 执行窗口结束时间的 UTC 24 小时格式 | | service.qpu\$1Capabilities.service.shotsRange | Tuple[int, int] | 设备的最小和最大拍摄次数 | | service.qpu\$1capabilities.service.deviceCost.price | 浮点数 | 设备价格（以美元计） | | service.qpu\$1capabilities.service.deviceCost.unit | str | 计费单位，例如：“分钟”、“小时”、“拍摄”、“任务” | **元数据字段** | 元数据字段 | 类型 | 描述 | | --- | --- | --- | | action[].version | str | AHS 程序架构的版本 | | action[].actionType | ActionType | AHS 程序架构名称；必须是“braket.ir.ahs.program” | | 服务。 braketSchemaHeader.name | str | 架构的名称；必须是“braket.device\$1schema.device\$1service\$1properties” | | 服务。 braketSchemaHeader. 版本 | str | 架构版本 | | service.deviceDocumentation.imageUrl | str | 设备图片的 URL | | service.deviceDocumentation.summary | str | 设备的简要描述 | | 服务设备文档。 externalDocumentationUrl | str | 外部文档 URL | | service.deviceLocation | str | 设备的地理位置 | | service.updatedAt | datetime | 上次更新设备属性的时间 |