本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 類比漢密爾頓模擬
[類比漢密爾頓模擬](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) 是量子運算的新興範例，與傳統的量子電路模型有很大的差異。而不是一連串的閘道，其中每個電路一次只能作用於幾個 qubit。AHS 程式是由有問題的漢密爾頓時間相依和空間相依參數所定義。[系統的 Hamiltonian](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) 會編碼其能源水準和外部力的影響，這些作用力共同管理其狀態的時間演變。對於 N-qubit 系統，Hamiltonian 可由複雜數字的 2NX2N 平方矩陣表示。
能夠執行 AHS 的 Quantum 裝置旨在透過仔細調校其內部控制參數，在自訂 Hamiltonian 下接近量子系統的時間演變。例如，調整一致駕駛欄位的振幅和調整參數。AHS 範例非常適合使用許多互動粒子來模擬量子系統的靜態和動態屬性，例如在壓縮物質物理或量子化學中。專門建置的量子處理單元 (QPUs)，例如來自 的 [Aquila 裝置](https://aws.amazon.com/braket/quantum-computers/quera/)QuEra，已開發為使用 AHS 的強大功能，並以創新方式解決傳統數位量子運算方法無法解決的問題。
**Topics**
+ [AHS 您好：執行您的第一個類比 Hamiltonian 模擬](braket-get-started-hello-ahs.md)
+ [使用 QuEra Aquila 提交類比程式](braket-quera-submitting-analog-program-aquila.md)
# AHS 您好：執行您的第一個類比 Hamiltonian 模擬
本節提供執行第一個類比 Hamiltonian 模擬的相關資訊。
**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)
+ [在 QuEra 的 Aquila QPU 上執行](#braket-get-started-running-aquila-qpu)
+ [分析 QPU 結果](#braket-get-started-analyzing-qpu-results)
+ [後續步驟](#braket-get-started-ahs-next)
## 互動旋轉鏈
對於許多互動粒子系統的正式範例，讓我們考慮一個八次旋轉的環 （每個旋轉環可以是「向上」∣↑⟩ 和「向下」∣↓⟩ 狀態）。雖然很小，但此模型系統已展現一些自然產生的磁性材料的有趣現象。在此範例中，我們將示範如何準備所謂的抗鐵磁順序，其中連續旋轉指向相反方向。
![\[連接 8 個包含上下箭頭的圓形節點的圖表。\]](http://docs.aws.amazon.com/zh_tw/braket/latest/developerguide/images/AntiFerromagnetic.png)
## 安排
我們將使用一個中性原子來代表每次旋轉，而「向上」和「向下」旋轉狀態將分別以激磁的 Rydberg 狀態和原子的接地狀態進行編碼。首先，我們建立 2 天排列。我們可以使用下列程式碼來編寫上述旋轉環。
**先決條件**：您需要 pip 安裝 [Braket SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk)。（如果您使用的是 Braket 託管筆記本執行個體，此 SDK 會預先安裝筆記本。) 若要重現圖，您也需要使用 shell 命令 單獨安裝 matplotlib`pip install 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_tw/braket/latest/developerguide/images/PlotNeutralAtoms.png)
## 互動
為了準備抗鐵磁階段，我們需要在鄰近旋轉之間觸發互動。我們對此使用 [van der Waals 互動](https://en.wikipedia.org/wiki/Van_der_Waals_force)，這是由中性原子裝置 （例如來自 Aquila的裝置QuEra) 原生實作。使用旋轉代表法，此互動的 Hamiltonian 詞彙可以用總和來表示所有旋轉對 (j，k)。
![\[漢密爾頓互動方程式顯示此互動，以所有旋轉對 (j，k) 的總和表示。\]](http://docs.aws.amazon.com/zh_tw/braket/latest/developerguide/images/HInteraction.png)
在這裡，nj =jj∣↑⟩⟨↑∣ 是運算子，只有在旋轉 j 處於「上升」狀態時，才會採用 1 的值，否則為 0。強度為 Vj,k=C6/(dj,k)6，其中 6Cis 是固定係數，而 dis j,k是旋轉 j 和 k 之間的歐幾里得距離。此互動術語的立即效果是，旋轉 j 和旋轉 k 都是「向上」的任何狀態都具有更高的能量 （按 V 量）j,k。透過仔細設計 AHS 計畫的其餘部分，此互動將防止相鄰旋轉同時處於「上」狀態，這是一種通常稱為「Rydberg 封鎖」的效果。
## 駕駛欄位
在 AHS 程式開始時，所有旋轉 （預設） 都會以「向下」狀態開始，處於所謂的鐵磁階段。密切關注我們準備抗鐵磁階段的目標，我們指定了時間相依的一致駕駛欄位，可將旋轉從此狀態順暢地轉換為「上升」狀態的許多身體狀態。對應的 Hamiltonian 可以寫入為
![\[描述漢密爾頓磁碟機函數計算的數學方程式。\]](http://docs.aws.amazon.com/zh_tw/braket/latest/developerguide/images/HDrive.png)
其中 DLR(t)、φ(t)、Δ(t) 是時間相依的全域振幅 （也稱為 [Rabi 頻率](https://en.wikipedia.org/wiki/Rabi_frequency))、階段，以及影響所有旋轉的駕駛欄位的調整。此處的 S−,k=kk∣↓⟩⟨↑∣and S\$1,k=(S−,k)†=kk∣↑⟩⟨↓∣ 分別是旋轉 k 的降低和提高運算子，而 nk=kk∣↑��⟩⟨↑∣ 是與之前相同的運算子。駕駛欄位的 DLR 部分會一致地聯結所有旋轉的「向下」和「向上」狀態，而 Δ 部分則會控制「向上」狀態的能源獎勵。
若要程式設計從鐵磁階段順利轉換為抗鐵磁階段，請使用下列程式碼指定駕駛欄位。
```
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_tw/braket/latest/developerguide/images/DrivingTimeSeries.png)
## AHS 程式
註冊、駕駛欄位 （以及隱含 van der Waals 互動） 組成了類比 Hamiltonian 模擬程式 `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」表示「down」、「u」表示「up」或「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_tw/braket/latest/developerguide/images/AHSCounts1.png)
![\[長條圖顯示一些相鄰「向上」狀態組態的鏡頭，其中 4 個狀態為 1.0 個鏡頭。\]](http://docs.aws.amazon.com/zh_tw/braket/latest/developerguide/images/AHSCounts2.png)
從圖中，我們可以讀取下列觀察，確認已成功準備抗鐵磁階段。
1. 一般而言，非封鎖狀態 （其中沒有兩個相鄰旋轉處於「上」狀態） 比至少有一個相鄰旋轉處於「上」狀態的狀態更常見。
1. 一般而言，除非組態遭到封鎖，否則具有更多 "up" 激發的狀態是有利的。
1. 最常見的狀態確實是完美的抗鐵磁狀態 `"dudududu"`和 `"udududud"`。
1. 第二個最常見的狀態是其中只有 3 個「向上」激發，連續分隔為 1、2、2。這顯示 van der Waals 互動也會影響 （雖然更小） 下一個最近鄰。
## 在 QuEra 的 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 託管筆記本執行個體，則 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 允許的精確度。（這些要求由名稱中具有「解析度」的裝置參數管理。 我們可以透過在筆記本`aquila_qpu.properties.dict()`中執行來查看它們。 如需 Aquila 功能和需求的詳細資訊，請參閱 [Aquila 筆記本簡介](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
```
一旦狀態為 COMPLETED （也可以從 Amazon Braket [主控台](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks)的量子任務頁面進行檢查），我們可以使用下列方式查詢結果：
```
result_aquila = task.result()
```
## 分析 QPU 結果
使用與之前相同的`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_tw/braket/latest/developerguide/images/QPUPlotCounts1.png)
![\[長條圖顯示一些相鄰「向上」狀態組態的鏡頭，其中 4 個狀態為 1.0 個鏡頭。\]](http://docs.aws.amazon.com/zh_tw/braket/latest/developerguide/images/QPUPlotCounts2.png)
請注意，一小部分的鏡頭具有空的網站 （以 “e” 標記）。這是因為 Aquila QPU 的每個原子準備瑕疵為 1-2%。除此之外，由於鏡頭數量較少，結果與模擬在預期的統計波動內相符。
## 後續步驟
恭喜您，您現在已使用本機 AHS 模擬器和 Aquila QPU 在 Amazon Braket 上執行第一個 AHS 工作負載。
若要進一步了解 Rydberg 物理、類比 Hamiltonian 模擬和Aquila裝置，請參閱我們的[筆記本範例](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation)。
# 使用 QuEra Aquila 提交類比程式
此頁面提供 Aquila機器功能的完整文件QuEra。此處涵蓋的詳細資訊如下：
1. 模擬的參數化 Hamiltonian 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)
## 漢密爾頓文
來自 的Aquila機器原生QuEra模擬下列 （時間相依） 漢密爾頓文：
![\[具有代表系統 Hamiltonian 的加總的數學方程式，涉及驅動、局部位移和點間耦合詞彙。\]](http://docs.aws.amazon.com/zh_tw/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 JPEG(t)eiφ(t)S−,k\$1 1/2 JPEG(t)e−iφ(t) S\$1,k) \$1 (−globalΔ(t)nk)，
+ DLR(t) 是時間相依的全域駕駛振幅 （也稱為 Rabi 頻率），單位為 (rad / s)
+ φ(t) 是時間相依的全域階段，以弧度為單位
+ S−,k 和 \$1,kSare 是 atom k 的旋轉降低和提升運算子 （以 \$1↓⟩=\$1g⟩、 \$1↑⟩=\$1r⟩ 為基礎，它們是 S−=\$1g⟩⟨r\$1、S\$1=(S−)†=\$1r⟩⟨g\$1)
+ globalΔ(t) 是時間相依的全域調整
+ nk 是 atom k 之 Rydberg 狀態的投影運算子 （即 n=\$1r⟩⟨r\$1)
+ Hlocal detuning,k(t)=-localΔ(t)h knk
+ localΔ(t) 是本機頻率轉移的時間相依因素，單位為 (rad/s)
+ hk 是網站相依因素，介於 0.0 和 1.0 之間的無維度數字
+ Vvdw,k,l=C6/(dk,l)6nknl，
+ 6Cis van der Waals 係數，單位為 (rad / s) \$1 (m)^6
+ dk,l 是 atom k 和 l 之間的歐幾里得距離，以公尺為單位。
使用者可以透過 Braket AHS 程式結構描述控制下列參數。
+ 2-d 原子排列 （每個 k 的 x k和k座標，以 um 為單位），以 k，l=1，2，...N 控制成對原子距離 dk,l
+ 以 (rad / s) 為單位的時間相依性、全域 Rabi 頻率
+ φ(t)，時間相依的全域階段，單位為 (rad)
+ globalΔ(t)，時間相依性、全域調整，單位為 (rad/s)
+ localΔ(t)，局部偏轉幅度的時間相依性 （全域） 因素，單位為 (rad / s)
+ hk，局部調整幅度的 （靜態） 網站相依因素，介於 0.0 和 1.0 之間的無維度數字
**注意**
使用者無法控制涉及的關卡 （即 S−、S\$1、n 運算子是固定的） 或 Rydberg-Rydberg 互動係數 (C) 的強度6。
## 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]
}
}
]
}
}
```
**主要欄位**
| 程式欄位 | type | description |
| --- | --- | --- |
| setup.ahs\$1register.sites | List【List【Decimal】】 | 鑷子捕捉原子的 2-d 座標清單 |
| 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)；必須是 'uniform' |
| 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)；必須是 'uniform' |
| 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)；必須是 'uniform' |
| 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 中的網站） |
**中繼資料欄位**
| 程式欄位 | type | description |
| --- | --- | --- |
| braketSchemaHeader.name | str | 結構描述的名稱；必須是 'braket.ir.ahs.program' |
| braketSchemaHeader.version | 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
}
}
}
```
**主要欄位**
| 任務結果欄位 | type | description |
| --- | --- | --- |
| measurements【】.shotResult.preSequence | List【int】 | 每個鏡頭的序列前測量位元 （每個原子站點一個）：如果站點為空，則 0；如果站點已填滿，則 1；在執行量子演進的脈衝序列之前測量 |
| measurements【】.shotResult.postSequence | List【int】 | 每個鏡頭的序列後測量位元：如果原子處於 Rydberg 狀態或位置為空，則為 0；如果原子處於接地狀態，則為 1，在執行量子演進的脈衝序列結束時測量 |
**中繼資料欄位**
| 任務結果欄位 | type | description |
| --- | --- | --- |
| braketSchemaHeader.name | str | 結構描述的名稱；必須是 'braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result' |
| braketSchemaHeader.version | str | 結構描述的版本 |
| taskMetadata.braketSchemaHeader.name | str | 結構描述的名稱；必須是 ‘braket.task\$1result.task\$1metadata' |
| taskMetadata.braketSchemaHeader.version | str | 結構描述的版本 |
| taskMetadata.id | str | 量子任務的 ID。對於 AWS 量子任務，這是量子任務 ARN。 |
| taskMetadata.shots | int | 量子任務的鏡頭數量 |
| taskMetadata.shots.deviceId | str | 量子任務執行所在的裝置 ID。對於 AWS 裝置，這是裝置 ARN。 |
| taskMetadata.shots.createdAt | str | 建立的時間戳記；格式必須是 ISO-8601/RFC3339 字串格式 YYYY-MM-DDTHH：mm：ss.sssZ。預設為無。 |
| taskMetadata.shots.endedAt | str | 量子任務結束時的時間戳記；格式必須是 ISO-8601/RFC3339 字串格式 YYYY-MM-DDTHH：mm：ss.sssZ。預設為無。 |
| taskMetadata.shots.status | str | 量子任務的狀態 (CREATED、QUEUED、RUNNING、COMPLETED、FAILED)。預設為無。 |
| taskMetadata.shots.failureReason | str | 量子任務的失敗原因。預設為無。 |
| additionalMetadata.action | braket.ir.ahs.program\$1v1.Program | （請參閱 [Braket AHS 程式結構描述](#braket-quera-ahs-program-schema)一節） |
| additionalMetadata.action.braketSchemaHeader.queraMetadata.name | str | 結構描述的名稱；必須是 'braket.task\$1result.quera\$1metadata' |
| additionalMetadata.action.braketSchemaHeader.queraMetadata.version | str | 結構描述的版本 |
| additionalMetadata.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
...
}
}
```
**服務屬性欄位**
| 服務屬性欄位 | type | description |
| --- | --- | --- |
| 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 | float | 以美元為單位的裝置價格 |
| service.qpu\$1capabilities.service.deviceCost.unit | str | 收取價格的單位，例如：'minute'、'hour'、'shot'、'task' |
**中繼資料欄位**
| 中繼資料欄位 | type | description |
| --- | --- | --- |
| action【】.version | str | AHS 程式結構描述的版本 |
| action【】.actionType | ActionType | AHS 程式結構描述名稱；必須是 'braket.ir.ahs.program' |
| service.braketSchemaHeader.name | str | 結構描述的名稱；必須是 'braket.device\$1schema.device\$1service\$1properties' |
| service.braketSchemaHeader.version | str | 結構描述的版本 |
| service.deviceDocumentation.imageUrl | str | 裝置映像的 URL |
| service.deviceDocumentation.summary | str | 裝置上的簡短描述 |
| service.deviceDocumentation.externalDocumentationUrl | str | 外部文件 URL |
| service.deviceLocation | str | 裝置所在的地理位置 |
| service.updatedAt | datetime | 上次更新裝置屬性的時間 |