翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# アナログハミルトニアンシミュレーション
[アナログハミルトニアンシミュレーション](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) は、量子コンピューティングにおける新たなパラダイムであり、従来の量子回路モデルとは大きく異なります。各回路は一度に、一連のゲートでなく、数量子ビットにのみ作用します。AHS プログラムは、問題のハミルトニアンの時間依存パラメータとスペース依存パラメータによって定義されます。[系のハミルトニアン](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics))は、系のエネルギー準位と外力の作用をエンコードします。これらが連携して系の状態の時間進化を管理します。N 量子ビットの系の場合、ハミルトニアンは複素数で構成される 2NX2N の正方マトリックスで表すことができます。
AHS を実行できる量子デバイスは、内部制御パラメータを慎重に調整することで、カスタムハミルトニアンにおける量子系の時間進化をほぼ近似できるように設計されています。調整できるパラメータの例は、コヒーレント駆動場の振幅やパラメータなどです。AHS パラダイムは、凝縮系物理学や量子化学など、相互作用パーティクルが多い量子系の静的および動的特性をシミュレートするのに適しています。AHS のパワーを利用し、従来のデジタル量子コンピューティングアプローチでは手の届かなかった問題に革新的な方法で対処するため、QuEra の [Aquila デバイス](https://aws.amazon.com/braket/quantum-computers/quera/)など、専用の量子処理装置 (QPU) が開発されました。
**Topics**
+ [Hello AHS: 初めてのアナログハミルトニアンシミュレーションを実行する](braket-get-started-hello-ahs.md)
+ [QuEra Aquila を使用してアナログプログラムを送信する](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)
+ [QuEra Aquila QPU での実行](#braket-get-started-running-aquila-qpu)
+ [QPU の結果を分析する](#braket-get-started-analyzing-qpu-results)
+ [次の手順](#braket-get-started-ahs-next)
## スピン鎖の操作
多くの相互作用パーティクルで構成される系の正規例については、8 つのスピンのリング (それぞれが「上向き」∣↑⟩ 状態と「下向き」∣↓⟩ 状態になる場合があります) を考えてみましょう。次のモデル系は小さいながらも、自然に発生する磁性物質によるいくつかの興味深い現象を最初から示しています。この例では、連続するスピンが反対方向に向く、いわゆる反強磁性秩序を作成する方法を示します。
![\[上下反転矢印を含む 8 つの円ノードを接続している図。\]](http://docs.aws.amazon.com/ja_jp/braket/latest/developerguide/images/AntiFerromagnetic.png)
## 配置
スピンごとに 1 つの中性原子を使用し、「上向き」スピン状態と「下向き」スピン状態をそれぞれ、原子の励起リュードベリ状態と基底状態でエンコードします。まず、2-d 配置を作成します。上記のスピンリングは、下記のコードでプログラミングできます。
**前提条件**: [Braket SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) を pip install コマンドでインストールする必要があります。(Braket がホストするノートブックインスタンスを使用する場合には、そのノートブックはこの SDK にプリインストールされています)。プロットを再現する場合は、シェルコマンド `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/ja_jp/braket/latest/developerguide/images/PlotNeutralAtoms.png)
## 相互作用
反強磁性相を作成するには、隣接するスピン間の相互作用を誘発する必要があります。これには [ファンデルワールス相互作用](https://en.wikipedia.org/wiki/Van_der_Waals_force)を使用します。これは、中性原子デバイス (QuEra の Aquila デバイスなど) でネイティブに実装されています。この相互作用のハミルトニアン項は、スピン表現を使用することで、すべてのスピンペア (j,k) の和として表現できます。
![\[この相互作用をすべてのスピンペア (j,k) の和として表現したハミルトニアン相互作用式。\]](http://docs.aws.amazon.com/ja_jp/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 プログラムの残りの部分を綿密に設計することで、隣接するスピンが両方とも「上向き」状態になるのを防ぐことができます。これは、一般的に「リュードベリ遮断」と呼ばれる効果です。
## 駆動場
AHS プログラムの開始時、すべてのスピン (デフォルト) は「下向き」状態で始まり、いわゆる強磁性相にあります。強磁性相を作成するという目的に留意し、スピンをこの状態から、「上向き」状態が望ましい多体状態にスムーズに遷移させる、時間依存のコヒーレント駆動場を指定します。対応するハミルトニアンは次のように記述できます。
![\[ハミルトニアン駆動関数の計算を表す数式。\]](http://docs.aws.amazon.com/ja_jp/braket/latest/developerguide/images/HDrive.png)
ここで、Ω(t)、ϕ(t)、Δ(t) はそれぞれ、すべてのスピンに均一に作用する駆動場に対する、時間依存、グローバル振幅 (別名: [Rabi 周波数](https://en.wikipedia.org/wiki/Rabi_frequency))、位相、およびデチューニングです。ここで、S−,k=∣↓k⟩⟨↑k∣ および S\$1,k=(S−,k)†=∣↑k⟩⟨↓k∣ はそれぞれ、スピン 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 を時系列で示した 3 つのグラフ。上のグラフには 6 rad/s のすぐ上までの増加が示され、0 に戻るまで 4 秒間留まっています。中央のグラフには関連する導関数の線形成長が示され、下部のグラフにはゼロに近い平坦な線が示されています。\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/braket/latest/developerguide/images/AHSCounts1.png)
![\[隣接するいくつかの「上向き」状態設定のショットを示す棒グラフ (4 つの状態が 1.0 ショット)。\]](http://docs.aws.amazon.com/ja_jp/braket/latest/developerguide/images/AHSCounts2.png)
プロットから、以下の観測値を読み取ることで、反強磁性相が作成されたことを確認できます。
1. 通常、非遮断状態 (いかなる 2 つの隣接するスピンも「上向き」状態ではない状態) は、少なくとも 1 つの隣接スピンペアが両方とも「上向き」状態である状態よりも一般的です。
1. 一般に、設定が遮断状態でない限り、より多くの「上向き」の励起がある状態が優先されます。
1. 実際には、最も一般的な状態は、完全な反強磁性状態 `"dudududu"` と `"udududud"` です。
1. 2 番目に一般的な状態は、連続する間隔が 1、2、2 である 3 つの「上向き」励起のみを持つ状態です。これは、ファンデルワールス相互作用が、次の最近傍にも作用する (ただし、はるかに小さなものです) ことを示しています。
## QuEra Aquila QPU での実行
**前提条件**: Amazon Braket を初めて使用する場合 (Braket [SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) を pip install コマンドでインストールすることは除く) は、必要な[開始手順](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 で許容される精度レベルに準拠するようにすべての値を丸める必要があります。(丸める必要があるかどうかは、名前に「Resolution」が含まれるデバイスパラメータで管理されています。そのようなデバイスパラメータを確認するには、ノートブックで `aquila_qpu.properties.dict()` を実行します。Aquila の機能と要件の詳細については、「[Introduction to 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 の状態を確認できるように、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()
```
## 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/ja_jp/braket/latest/developerguide/images/QPUPlotCounts1.png)
![\[隣接するいくつかの「上向き」状態設定のショットを示す棒グラフ (4 つの状態が 1.0 ショット)。\]](http://docs.aws.amazon.com/ja_jp/braket/latest/developerguide/images/QPUPlotCounts2.png)
ショットのごく一部に空のサイトがあることに注意してください (「e」でマークされています)。これは、Aquila QPU の原子ごとの準備の不完全性が 1～2% であるためです。これを例外とすれば、結果は、シミュレーションと、ショット数が少ないことによる予想される統計的変動の範囲内で一致しています。
## 次の手順
これで、ローカル AHS シミュレーターと Aquila QPU を使用して Amazon Braket で初めての AHS ワークロードを実行できました。
リュードベリ物理学、アナログハミルトニアンシミュレーション、Aquila デバイスの詳細については、[example](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation) ノートブックを参照してください。
# QuEra Aquila を使用してアナログプログラムを送信する
このページでは、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/ja_jp/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png)
**注記**
ローカルデチューニングへのアクセスは[実験機能](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html)であり、Braket Direct を通じたリクエストによって利用可能になります。
各一般項の意味は次のとおりです。
+ 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 周波数) を rad/s 数として表したものです
+ ϕ(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) は、ローカル周波数シフトの時間依存係数であり、単位は rad/s です。
+ hk はサイト依存因子であり、0.0 から 1.0 の間の無次元数です。
+ Vvdw,k,l=C6/(dk,l)6nknl
+ 6 はファンデルワールス係数であり、単位は「rad/s \$1 m^6」です。
+ dk,l は、原子 k と l の間のユークリッド距離であり、メートル数として測定されます。
ユーザーは Braket AHS プログラムスキーマを使用して以下のパラメータを制御できます。
+ 2次元での原子配置 (各原子 k の xk および yk 座標、μm 数): k,l=1、2、...N までの原子間の距離 dk,l を制御する
+ Ω(t): 時間依存、グローバル Rabi 周波数、単位 rad/s
+ ϕ(t): 時間依存、グローバル位相、単位 rad
+ Δglobal(time): 時間依存、グローバル調整、単位 rad/s
+ Δlocal(t): ローカルデチューニングの大きさの時間依存 (グローバル) 因子、単位 rad/s
+ 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]] | 光ピンセットが原子を捕捉する 2 次元座標のリスト |
| 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)。「均一」である必要があります |
| 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 の sites に対応) |
**メタデータフィールド**
| プログラムフィールド | 型 | 説明 |
| --- | --- | --- |
| 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
}
}
}
```
**主なフィールド**
| タスク結果フィールド | 型 | 説明 |
| --- | --- | --- |
| measurements[].shotResult.preSequence | List[int] | 各ショットのシーケンス前測定ビット (原子サイトごとに 1 つ): サイトが空の場合は 0、サイトが占有されている場合は 1。測定は、量子進化を実行するパルスのシーケンスの前に行います |
| measurements[].shotResult.postSequence | List[int] | 各ショットのシーケンス後測定ビット: 原子がリュードベリ状態か空の場合は 0、原子が基底状態の場合は 1。測定は、量子進化を実行するパルスシーケンスの終了後に行います |
**メタデータフィールド**
| タスク結果フィールド | 型 | 説明 |
| --- | --- | --- |
| 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 にする必要があります。デフォルトは「None」です。 |
| taskMetadata.shots.endedAt | str | 量子タスクが終了した日時のタイムスタンプ。形式は ISO-8601/RFC3339 文字列形式 YYYY-MM-DDTHH:mm:ss.sssZ にする必要があります。デフォルトは「None」です。 |
| taskMetadata.shots.status | str | 量子タスクのステータス (CREATED、QUEUED、RUNNING、COMPLETED、FAILED)。デフォルトは「None」です。 |
| taskMetadata.shots.failureReason | str | 量子タスクの失敗の理由。デフォルトは「None」です。 |
| 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
...
}
}
```
**サービスプロパティのフィールド**
| サービスプロパティのフィールド | 型 | 説明 |
| --- | --- | --- |
| service.executionWindows[].executionDay | ExecutionDay | 実行ウィンドウの曜日。「Everyday」、「Weekdays」、「Weekend」、「Monday」、「Tuesday」、「Wednesday」、「Thursday」、「Friday」、「Saturday」、または「Sunday」を指定する必要があります |
| 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 | デバイスの価格 (単位: USD) |
| service.qpu\$1capabilities.service.deviceCost.unit | str | 料金の請求単位。例：「minute」(分)、「hour」(時間)、「shot」(ショット)、「task」(タスク) |
**メタデータフィールド**
| メタデータフィールド | 型 | 説明 |
| --- | --- | --- |
| 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 | デバイスプロパティが最後に更新された日時 |