Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Analoge Hamiltonsche Simulation
Die [analoge Hamiltonsche Simulation](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) ist ein neues Paradigma im Quantencomputing, das sich erheblich vom traditionellen Quantenschaltkreismodell unterscheidet. Anstatt einer Abfolge von Gates, bei der jeder Schaltkreis nur auf ein paar Qubits gleichzeitig wirkt. Ein AHS-Programm wird durch die zeit- und raumabhängigen Parameter des betreffenden Hamiltonschen Parameters definiert. Der [Hamilton-Wert eines Systems](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) kodiert seine Energieniveaus und die Auswirkungen äußerer Kräfte, die zusammen die zeitliche Entwicklung seiner Zustände bestimmen. Bei einem N-Qubit-System kann der Hamiltonsche Wert durch eine quadratische Matrix komplexer Zahlen mit 2 N x 2 N dargestellt werden.
Quantengeräte, die AHS ausführen können, sind so konzipiert, dass sie der zeitlichen Entwicklung eines Quantensystems unter einem benutzerdefinierten Hamiltonschen Wert sehr nahe kommen, indem ihre internen Steuerparameter sorgfältig abgestimmt werden. Zum Beispiel die Anpassung der Amplitude und die Verstimmung der Parameter eines kohärenten Antriebsfeldes. Das AHS-Paradigma eignet sich gut für die Simulation der statischen und dynamischen Eigenschaften von Quantensystemen mit vielen wechselwirkenden Teilchen, beispielsweise in der Physik der kondensierten Materie oder der Quantenchemie. Speziell angefertigte Quantenverarbeitungseinheiten (QPUs), wie das [Aquila-Gerät](https://aws.amazon.com/braket/quantum-computers/quera/) vonQuEra, wurden entwickelt, um die Leistungsfähigkeit von AHS zu nutzen und Probleme, die mit herkömmlichen digitalen Quantencomputern nicht möglich sind, auf innovative Weise anzugehen.
**Topics**
+ [Hallo AHS: Führe deine erste analoge Hamilton-Simulation aus](braket-get-started-hello-ahs.md)
+ [Reichen Sie ein analoges Programm mit Aquila ein QuEra](braket-quera-submitting-analog-program-aquila.md)
# Hallo AHS: Führe deine erste analoge Hamilton-Simulation aus
Dieser Abschnitt enthält Informationen zur Ausführung Ihrer ersten analogen Hamiltonschen Simulation.
**Topics**
+ [Interagierende Spin-Kette](#braket-get-started-interacting-spin-chain)
+ [Anordnung](#braket-get-started-arrangement)
+ [Interaktionen](#braket-get-started-interaction)
+ [Fahrfeld](#braket-get-started-driving-field)
+ [AHS-Programm](#braket-get-started-ahs-program)
+ [Läuft auf einem lokalen Simulator](#braket-get-started-running-local-simulator)
+ [Analysieren der Simulatorergebnisse](#braket-get-started-analyzing-simulator-results)
+ [Läuft auf der Aquila QuEra QPU](#braket-get-started-running-aquila-qpu)
+ [QPU-Ergebnisse analysieren](#braket-get-started-analyzing-qpu-results)
+ [Nächste Schritte](#braket-get-started-ahs-next)
## Interagierende Spin-Kette
Als kanonisches Beispiel für ein System aus vielen wechselwirkenden Teilchen betrachten wir einen Ring mit acht Spins (von denen sich jeder in den Zuständen „oben“ ↑ und „unten“ ↓⟩ befinden kann). Dieses Modellsystem ist zwar klein, weist aber bereits eine Handvoll interessanter Phänomene natürlich vorkommender magnetischer Materialien auf. In diesem Beispiel werden wir zeigen, wie man eine sogenannte antiferromagnetische Ordnung erzeugt, bei der aufeinanderfolgende Spins in entgegengesetzte Richtungen zeigen.
![\[Diagramm, das 8 Kreisknoten verbindet, die invertierte Aufwärts- und Abwärtspfeile enthalten.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/AntiFerromagnetic.png)
## Anordnung
Wir verwenden ein neutrales Atom, das für jeden Spin steht, und die Spinzustände „hoch“ und „runter“ werden jeweils im angeregten Rydberg-Zustand und im Grundzustand der Atome kodiert. Zuerst erstellen wir die 2-D-Anordnung. Wir können den obigen Ring von Spins mit dem folgenden Code programmieren.
**Voraussetzungen**: Sie müssen das [Braket](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) SDK per Pip installieren. (Wenn Sie eine von Braket gehostete Notebook-Instanz verwenden, ist dieses SDK zusammen mit den Notebooks vorinstalliert.) Um die Plots zu reproduzieren, müssen Sie matplotlib auch separat mit dem Shell-Befehl installieren. `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)
```
womit wir auch plotten können
```
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
```
![\[Streudiagramm, das Punkte zeigt, die über positive und negative Werte auf beiden Achsen verteilt sind.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/PlotNeutralAtoms.png)
## Interaktionen
Um die antiferromagnetische Phase vorzubereiten, müssen wir Wechselwirkungen zwischen benachbarten Spins induzieren. Wir nutzen dafür die [Van-der-Waals-Wechselwirkung](https://en.wikipedia.org/wiki/Van_der_Waals_force), die nativ von neutralen Atomgeräten (wie dem Gerät von) implementiert wird. Aquila QuEra Mit Hilfe der Spin-Repräsentation kann der Hamiltonsche Term für diese Wechselwirkung als Summe über alle Spinpaare (j, k) ausgedrückt werden.
![\[Die Hamiltonsche Wechselwirkungsgleichung zeigt, dass diese Wechselwirkung als Summe aller Spinpaare (j, k) ausgedrückt wird.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/HInteraction.png)
In diesem Fall ist nj=↑ bung↑ j ein j Operator, der den Wert 1 nur annimmt, wenn sich Spin j im Zustand „up“ befindet, andernfalls 0. Die Stärke ist V j,k =C6/(dj,k) 6, wobei C 6 der feste Koeffizient und d der euklidische Abstand zwischen den Spins j und k j,k ist. Der unmittelbare Effekt dieses Wechselwirkungsterms besteht darin, dass jeder Zustand, in dem sowohl Spin j als auch Spin k „oben“ sind, eine erhöhte Energie (um den Betrag V) aufweist. j,k Durch die sorgfältige Gestaltung des restlichen AHS-Programms wird durch diese Wechselwirkung verhindert, dass sich benachbarte Spins beide im „Up-Zustand“ befinden — ein Effekt, der allgemein als „Rydberg-Blockade“ bekannt ist.
## Fahrfeld
Zu Beginn des AHS-Programms beginnen alle Spins (standardmäßig) in ihrem „down“ -Zustand, sie befinden sich in einer sogenannten ferromagnetischen Phase. Mit Blick auf unser Ziel, die antiferromagnetische Phase vorzubereiten, spezifizieren wir ein zeitabhängiges kohärentes Antriebsfeld, das die Spins sanft von diesem Zustand in einen Vielteilchenzustand überführt, in dem der Zustand „oben“ bevorzugt wird. Der entsprechende Hamilton-Operator kann geschrieben werden als
![\[Mathematische Gleichung, die die Berechnung einer Hamiltonschen Antriebsfunktion darstellt.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/HDrive.png)
wobei Ω (t), φ (t), δ (t) die zeitabhängige globale Amplitude (auch bekannt als [Rabi-Frequenz](https://en.wikipedia.org/wiki/Rabi_frequency)), Phase und Verstimmung des treibenden Feldes sind, die alle Spins gleichmäßig beeinflussen. Hier sind S −,k =↓ k bung↑ k und S \$1,k =( S−,k) † =↑ k Chesinik↓ k die senkenden und anhebenden Operatoren von Spin k, und n k =↑ k ↑ ←↑ k ist derselbe Operator wie zuvor. Der Ω Teil des Antriebsfeldes verbindet kohärent die Zustände „nach unten“ und „nach oben“ aller Spins gleichzeitig, während der Δ-Teil die Energiebelohnung für den Zustand „hoch“ steuert.
Um einen reibungslosen Übergang von der ferromagnetischen Phase zur antiferromagnetischen Phase zu programmieren, spezifizieren wir das treibende Feld mit dem folgenden Code.
```
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
)
```
Wir können die Zeitreihen des Fahrfeldes mit dem folgenden Skript visualisieren.
```
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
```
![\[Drei Grafiken, die Phi, Delta und Omega im Zeitverlauf zeigen. Das obere Teildiagramm zeigt das Wachstum auf knapp über 6, rads/s wo es 4 Sekunden lang anhält, bis es wieder auf 0 fällt. Das mittlere Teildiagramm zeigt das damit verbundene lineare Wachstum der Ableitung, und das untere Teildiagramm zeigt eine flache Linie nahe Null.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/DrivingTimeSeries.png)
## AHS-Programm
Das Register, das treibende Feld (und die impliziten Van-der-Waals-Interaktionen) bilden das Programm Analoge Hamiltonsche Simulation. `ahs_program`
```
from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation
ahs_program = AnalogHamiltonianSimulation(
register=register,
hamiltonian=drive
)
```
## Läuft auf einem lokalen Simulator
Da dieses Beispiel klein ist (weniger als 15 Spins), können wir es vor der Ausführung auf einer AHS-kompatiblen QPU auf dem lokalen AHS-Simulator ausführen, der mit dem Braket-SDK geliefert wird. Da der lokale Simulator kostenlos mit dem Braket-SDK verfügbar ist, ist dies eine bewährte Methode, um sicherzustellen, dass unser Code korrekt ausgeführt werden kann.
Hier können wir die Anzahl der Aufnahmen auf einen hohen Wert setzen (z. B. 1 Million), weil der lokale Simulator die zeitliche Entwicklung des Quantenzustands verfolgt und Proben aus dem Endzustand zieht. Dadurch wird die Anzahl der Aufnahmen erhöht, während die Gesamtlaufzeit nur geringfügig erhöht wird.
```
from braket.devices import LocalSimulator
device = LocalSimulator("braket_ahs")
result_simulator = device.run(
ahs_program,
shots=1_000_000
).result() # Takes about 5 seconds
```
## Analysieren der Simulatorergebnisse
Wir können die Schussergebnisse mit der folgenden Funktion aggregieren, die den Status jedes Spins ableitet (der „d“ für „runter“, „u“ für „oben“ oder „e“ für leere Stelle sein kann) und zählt, wie oft jede Konfiguration in den Schüssen aufgetreten ist.
```
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, ...}
```
Hier `counts` ist ein Wörterbuch, das zählt, wie oft jede Zustandskonfiguration in den einzelnen Schüssen beobachtet wurde. Wir können sie auch mit dem folgenden Code visualisieren.
```
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)
```
![\[Balkendiagramm, das eine große Anzahl von Aufnahmen ohne benachbarte „Up-Status“ -Konfigurationen zeigt.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/AHSCounts1.png)
![\[Balkendiagramm mit Aufnahmen einiger benachbarter Konfigurationen mit „Up-Status“, mit 4 Zuständen bei 1,0 Aufnahmen.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/AHSCounts2.png)
Aus den Diagrammen können wir die folgenden Beobachtungen ablesen, die belegen, dass wir die antiferromagnetische Phase erfolgreich vorbereitet haben.
1. Im Allgemeinen sind nicht blockierte Zustände (in denen sich keine zwei benachbarten Spins im „Up“ -Zustand befinden) häufiger als Zustände, in denen sich mindestens ein Paar benachbarter Spins beide im „Up“ -Zustand befinden.
1. Im Allgemeinen werden Zustände mit mehr Erregungen nach oben bevorzugt, es sei denn, die Konfiguration ist blockiert.
1. Die häufigsten Zustände sind in der Tat die perfekten antiferromagnetischen Zustände und. `"dudududu"` `"udududud"`
1. Die zweithäufigsten Zustände sind diejenigen, bei denen es nur 3 „nach oben“ gerichtete Erregungen mit aufeinanderfolgenden Abständen von 1, 2, 2 gibt. Dies zeigt, dass sich die Van-der-Waals-Wechselwirkung auch auf die nächstgelegenen Nachbarn auswirkt (wenn auch viel geringer).
## Läuft auf der Aquila QuEra QPU
**Voraussetzungen**[: Wenn Sie neu bei Amazon Braket sind, stellen Sie neben der Pip-Installation des [Braket-SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) sicher, dass Sie die erforderlichen Schritte für den Einstieg abgeschlossen haben.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html)
**Anmerkung**
Wenn Sie eine von Braket gehostete Notebook-Instance verwenden, ist das Braket-SDK zusammen mit der Instance vorinstalliert.
Wenn alle Abhängigkeiten installiert sind, können wir eine Verbindung zur QPU herstellen. Aquila
```
from braket.aws import AwsDevice
aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
```
Damit unser AHS-Programm für die QuEra Maschine geeignet ist, müssen wir alle Werte runden, um die von der Aquila QPU zulässige Genauigkeit einzuhalten. (Diese Anforderungen werden durch die Geräteparameter bestimmt, deren Name „Auflösung“ enthält. Wir können sie sehen, indem wir sie `aquila_qpu.properties.dict()` in einem Notizbuch ausführen. Weitere Informationen zu den Funktionen und Anforderungen von Aquila finden Sie in der [Einführung in das Aquila-Notizbuch](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb).) Wir können das tun, indem wir die `discretize` Methode aufrufen.
```
discretized_ahs_program = ahs_program.discretize(aquila_qpu)
```
Jetzt können wir das Programm (vorerst nur 100 Aufnahmen) auf der Aquila QPU ausführen.
**Anmerkung**
Das Ausführen dieses Programms auf dem Aquila Prozessor ist mit Kosten verbunden. Das Amazon Braket SDK enthält einen [Cost Tracker](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/), mit dem Kunden Kostenlimits festlegen und ihre Kosten nahezu in Echtzeit verfolgen können.
```
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
```
Aufgrund der großen Varianz, wie lange die Ausführung einer Quantenaufgabe dauern kann (abhängig von Verfügbarkeitsfenstern und QPU-Auslastung), ist es eine gute Idee, den ARN der Quantenaufgabe zu notieren, damit wir ihren Status zu einem späteren Zeitpunkt mit dem folgenden Codeausschnitt überprüfen können.
```
# 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
```
Sobald der Status ABGESCHLOSSEN ist (was auch auf der Quantenaufgaben-Seite der Amazon [Braket-Konsole](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks) überprüft werden kann), können wir die Ergebnisse abfragen mit:
```
result_aquila = task.result()
```
## QPU-Ergebnisse analysieren
Mit den gleichen `get_counts` Funktionen wie zuvor können wir die Zählungen berechnen:
```
counts_aquila = get_counts(result_aquila)
print(counts_aquila)
```
```
*[Output]*
{'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...}
```
und plotten Sie sie mit`plot_counts`:
```
plot_counts(counts_aquila)
```
![\[Balkendiagramm, das eine große Anzahl von Aufnahmen ohne benachbarte „Up-Status“ -Konfigurationen zeigt.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/QPUPlotCounts1.png)
![\[Balkendiagramm mit Aufnahmen einiger benachbarter Konfigurationen mit „Up-Status“, mit 4 Zuständen bei 1,0 Aufnahmen.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/QPUPlotCounts2.png)
Beachten Sie, dass ein kleiner Teil der Aufnahmen leere Bereiche hat (mit „e“ gekennzeichnet). Dies ist auf eine Unvollkommenheit der QPU bei der Präparation pro Atom von 1— 2% zurückzuführen. Aquila Abgesehen davon stimmen die Ergebnisse innerhalb der erwarteten statistischen Fluktuation aufgrund der geringen Anzahl von Schüssen mit der Simulation überein.
## Nächste Schritte
Herzlichen Glückwunsch, Sie haben jetzt Ihren ersten AHS-Workload auf Amazon Braket mit dem lokalen AHS-Simulator und der Aquila QPU ausgeführt.
[Weitere Informationen zur Rydberg-Physik, zur analogen Hamiltonschen Simulation und zum Aquila Gerät finden Sie in unseren Beispiel-Notebooks.](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation)
# Reichen Sie ein analoges Programm mit Aquila ein QuEra
Diese Seite enthält eine umfassende Dokumentation über die Funktionen der Aquila Maschine vonQuEra. Hier werden die folgenden Details behandelt:
1. Der parametrisierte Hamilton-Operator, simuliert von Aquila
1. AHS-Programmparameter
1. Inhalt der AHS-Ergebnisse
1. AquilaParameter „Fähigkeiten“
**Topics**
+ [Hamiltonisch](#braket-quera-aquila-device-hamiltonian)
+ [AHS-Programmschema in Braket](#braket-quera-ahs-program-schema)
+ [Ergebnisschema der AHS-Aufgabe in Braket](#braket-quera-ahs-task-result-schema)
+ [QuEra Schema der Geräteeigenschaften](#braket-quera-device-properties-schema)
## Hamiltonisch
Die Aquila Maschine von QuEra simuliert nativ den folgenden (zeitabhängigen) Hamilton-Operator:
![\[Mathematische Gleichung mit Summationen, die den Hamiltonschen Operator eines Systems darstellen und dabei Begriffe aus Antrieb, lokaler Verstimmung und Interpunktkopplung beinhalten.\]](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png)
**Anmerkung**
Der Zugriff auf lokale Verstimmung ist eine [experimentelle Funktion](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html), die auf Anfrage über Braket Direct verfügbar ist.
where
+ H drive,k (t) =( 1/2Ω (t) e i( t) S −,k \$1 1/2Ω (t) e −iφ (t) S) \$1 (−δ (t\$1,k) n), global k
+ Ω (t) ist die zeitabhängige globale Antriebsamplitude (auch bekannt als Rabi-Frequenz) in Einheiten von (rad/s)
+ φ (t) ist die zeitabhängige, globale Phase, gemessen im Bogenmaß
+ S −,k und S \$1,k sind die Operatoren zum Herabsetzen und Erhöhen des Spins des Atoms k (in der Basis \$1↓⟩ =\$1g⟩, \$1↓ = \$1r⟩, sie lauten S =\$1g¤ ¤ r\$1, S =( S) † =\$1r-und r790g\$1) − \$1 −
+ δ (tglobal) ist die zeitabhängige, globale Verstimmung
+ n k ist der Projektionsoperator für den Rydberg-Zustand des Atoms k (das heißt, n=\$1r¤ ¤ r\$1)
+ H (t) =-Δ (t) h n local detuning,k local k k
+ Δ local (t) ist der zeitabhängige Faktor der lokalen Frequenzverschiebung in Einheiten von (rad/s)
+ h k ist der ortsabhängige Faktor, eine dimensionslose Zahl zwischen 0,0 und 1,0
+ V vdw,k,l =C6/(dk,l) 6 n n, k l
+ C 6 ist der Van-der-Waals-Koeffizient in Einheiten von (rad/s) \$1 (m) ^6
+ d k,l ist der euklidische Abstand zwischen Atom k und l, gemessen in Metern.
Benutzer haben über das Braket AHS-Programmschema die Kontrolle über die folgenden Parameter.
+ 2D-Atomanordnung (X k - und k Y-Koordinaten jedes Atoms k, in Einheiten von um), die die paarweisen Atomabstände d k,l mit k steuert, l=1,2,... N
+ Ω (t), die zeitabhängige, globale Rabi-Frequenz, in Einheiten von (rad/s)
+ φ (t), die zeitabhängige, globale Phase, in Einheiten von (rad)
+ Δ global (t), die zeitabhängige, globale Verstimmung, in Einheiten von (rad/s)
+ Δ local (t), der zeitabhängige (globale) Faktor für die Größe der lokalen Verstimmung, in Einheiten von (rad/s)
+ hk, der (statische) ortsabhängige Faktor für das Ausmaß der lokalen Verstimmung, eine dimensionslose Zahl zwischen 0,0 und 1,0
**Anmerkung**
Der Benutzer kann weder kontrollieren, um welche Stufen es sich handelt (d. h. die Operatoren S, S −\$1, n sind fest) noch die Stärke des Rydberg-Rydberg-Wechselwirkungskoeffizienten (C). 6
## AHS-Programmschema in Braket
**Braket.IR.AHS.Program\$1V1.Program-Objekt** (Beispiel)
**Anmerkung**
Wenn die Funktion zur [lokalen Feinabstimmung](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) für Ihr Konto nicht aktiviert ist, verwenden Sie das folgende Beispiel. `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** (Beispiel)
**Anmerkung**
Wenn die Funktion zur [lokalen Feinabstimmung](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) für Ihr Konto nicht aktiviert ist, verwenden Sie sie `"localDetuning": []` im folgenden Beispiel.
```
{
"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]
}
}
]
}
}
```
**Wichtigste Felder**
| Feld Programm | type | description |
| --- | --- | --- |
| setup.ahs\$1register.sites | Liste [Liste [Dezimal]] | Liste der 2D-Koordinaten, an denen die Pinzette Atome einfängt |
| setup.ahs\$1register.filling | Liste [int] | Markiert Atome, die die Fallenstellen besetzen, mit 1 und leere Stellen mit 0 |
| Hamiltonian.DrivingFields [] .amplitude.time\$1series.times | Liste [Dezimal] | Zeitpunkte der Antriebsamplitude, Omega (t) |
| Hamiltonian.DrivingFields [] .amplitude.time\$1series.values | Liste [Dezimal] | Werte der Antriebsamplitude, Omega (t) |
| Hamiltonian.DrivingFields [] .amplitude.pattern | str | das räumliche Muster der Antriebsamplitude, Omega (t); muss „einheitlich“ sein |
| Hamiltonian.DrivingFields [] .phase.time\$1series.times | Liste [Dezimal] | Zeitpunkte der Fahrphase, phi (t) |
| Hamiltonian.DrivingFields [] .phase.time\$1series.values | Liste [Dezimal] | Werte der Antriebsphase, Phi (t) |
| Hamiltonian.DrivingFields [] .phase.pattern | str | räumliches Muster der Fahrphase, phi (t); muss „einheitlich“ sein |
| Hamiltonian.DrivingFields [] .detuning.time\$1series.times | Liste [Dezimal] | Zeitpunkte der Fahrverstimmung, Delta\$1Global (t) |
| Hamiltonian.DrivingFields [] .detuning.time\$1series.values | Liste [Dezimal] | Werte der Fahrverstimmung, Delta\$1Global (t) |
| Hamiltonian.DrivingFields [] .detuning.pattern | str | das räumliche Muster der Fahrverstimmung, delta\$1Global (t); muss „einheitlich“ sein |
| Hamiltonian.LocalDeTuning [] .magnitude.time\$1series.times | Liste [Dezimal] | Zeitpunkte des zeitabhängigen Faktors der lokalen Verstimmungsgröße, delta\$1LOCAL (t) |
| Hamiltonian.LocalDeTuning [] .magnitude.time\$1series.values | Liste [Dezimal] | Werte des zeitabhängigen Faktors der lokalen Verstimmungsgröße, Delta\$1LOCAL (t) |
| Hamiltonian.LocalDeTuning [] .magnitude.pattern | Liste [Dezimal] | ortsabhängiger Faktor der lokalen Verstimmungsgröße, h\$1k (Werte entsprechen Standorten in setup.ahs\$1register.sites) |
**Metadaten-Felder**
| Feld Programm | type | description |
| --- | --- | --- |
| braketSchemaHeader.name | str | Name des Schemas; muss 'braket.ir.ahs.program' sein |
| braketSchemaHeader.version | str | Version des Schemas |
## Ergebnisschema der AHS-Aufgabe in Braket
**braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result. AnalogHamiltonianSimulationQuantumTaskResult**(Beispiel)
```
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** (Beispiel)
```
{
"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
}
}
}
```
**Hauptfelder**
| Ergebnisfeld der Aufgabe | type | description |
| --- | --- | --- |
| Messungen [] .shotResult.Presequence | Liste [int] | Vorsequenz-Messbits (eins für jede atomare Stelle) für jeden Schuss: 0, wenn die Stelle leer ist, 1, wenn die Stelle gefüllt ist, gemessen vor den Impulssequenzen, die die Quantenentwicklung bestimmen |
| Messungen [] .shotResult.postSequence | Liste [int] | Bits für die Messung nach der Sequenz für jeden Schuss: 0, wenn sich das Atom im Rydberg-Zustand befindet oder die Stelle leer ist, 1, wenn sich das Atom im Grundzustand befindet, gemessen am Ende der Impulssequenzen, die die Quantenentwicklung bestimmen |
**Metadaten-Felder**
| Feld für das Ergebnis der Aufgabe | type | description |
| --- | --- | --- |
| braketSchemaHeader.name | str | Name des Schemas; muss 'braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result' sein |
| braketSchemaHeader.version | str | Version des Schemas |
| Metadaten der Aufgabe. braketSchemaHeader.name | str | Name des Schemas; muss 'braket.task\$1result.task\$1metadata' sein |
| Aufgaben-Metadaten. braketSchemaHeader. Version | str | Version des Schemas |
| TaskMetadata.id | str | Die ID der Quantenaufgabe. Für AWS Quantenaufgaben ist dies die Quantenaufgabe ARN. |
| TaskMetadata.shots | int | Die Anzahl der Schüsse für die Quantenaufgabe |
| taskMetadata.Shots.DeviceID | str | Die ID des Geräts, auf dem die Quantenaufgabe ausgeführt wurde. Für AWS Geräte ist dies der Geräte-ARN. |
| TaskMetadata.Shots.CreatedAt | str | Der Zeitstempel der Erstellung; das Format muss ISO-8601/string format:mm:ss.sssz sein. RFC3339 YYYY-MM-DDTHH Die Standardeinstellung ist None. |
| taskMetadata.shots.endedat | str | Der Zeitstempel, zu dem die Quantenaufgabe beendet wurde. Das Format muss ISO-8601/string format:mm:ss.sssz sein. RFC3339 YYYY-MM-DDTHH Die Standardeinstellung ist None. |
| taskMetadata.shots.Status | str | Der Status der Quantenaufgabe (CREATED, QUEUED, RUNNING, COMPLETED, FAILED). Die Standardeinstellung ist Keine. |
| TaskMetadata.Shots.FailureReason | str | Der Fehlergrund der Quantenaufgabe. Die Standardeinstellung ist Keine. |
| Zusätzliche Metadaten.Action | Braket.IR.AHS.Program\$1V1.Program | [(Siehe den Abschnitt zum Braket AHS-Programmschema)](#braket-quera-ahs-program-schema) |
| Zusätzliche Metadaten.Aktion. braketSchemaHeader.Metadaten.Name abfragen | str | Name des Schemas; muss 'braket.task\$1result.quera\$1metadata' sein |
| Zusätzliche Metadaten.Action. braketSchemaHeader.querametadata.version | str | Version des Schemas |
| Zusätzliche Metadaten.Aktion. numSuccessfulShots | int | Anzahl der vollständig erfolgreichen Schüsse; muss der angeforderten Anzahl von Schüssen entsprechen |
| Messungen [] .shotMetadata.shotStatus | int | Der Status des Schusses (Erfolg, Teilerfolg, Fehlschlag) muss „Success“ lauten |
## QuEra Schema der Geräteeigenschaften
**braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1. QueraDeviceCapabilities**(Beispiel)
```
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** (Beispiel)
```
{
"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
...
}
}
```
**Felder für Diensteigenschaften**
| Feld „Serviceeigenschaften“ | type | description |
| --- | --- | --- |
| service.executionWindows [] .executionDay | ExecutionDay | Tage des Ausführungsfensters; muss 'Jeden Tag', 'Wochentage', 'Wochenende', 'Montag', 'Dienstag', 'Mittwoch', Donnerstag ',' Freitag ',' Samstag 'oder' Sonntag 'sein |
| Dienst.AusführungWindows []. windowStartHour | Datetime.time | UTC-24-Stunden-Format der Uhrzeit, zu der das Ausführungsfenster gestartet wird |
| Service.ExecutionWindows []. windowEndHour | Datetime.time | UTC-24-Stunden-Format der Uhrzeit, zu der das Ausführungsfenster endet |
| service.qpu\$1capabilities.service.shotsRange | Tupel [int, int] | Minimale und maximale Anzahl von Aufnahmen für das Gerät |
| service.qpu\$1capabilities.service.devicecost.price | float | Preis des Geräts in US-Dollar |
| service.qpu\$1capabilities.service.devicecost.unit | str | Einheit zur Berechnung des Preises, z. B.: 'Minute', 'Stunde', 'Schuss', 'Aufgabe' |
**Metadaten-Felder**
| Metadaten-Feld | type | description |
| --- | --- | --- |
| Aktion [] .version | str | Version des AHS-Programmschemas |
| Aktion [] .actionType | ActionType | Name des AHS-Programmschemas; muss 'braket.ir.ahs.program' sein |
| Dienst. braketSchemaHeader.name | str | Name des Schemas; muss 'braket.device\$1schema.device\$1service\$1properties' sein |
| Dienst. braketSchemaHeader. Ausführung | str | Version des Schemas |
| service.deviceDocumentation.imageUrl | str | URL für das Bild des Geräts |
| Service.DeviceDocumentation.Summary | str | kurze Beschreibung auf dem Gerät |
| Service. Gerätedokumentation. externalDocumentationUrl | str | URL der externen Dokumentation |
| service.deviceLocation | str | geografischer Standort des Geräts |
| Service.AktualisiertAt | datetime | Zeitpunkt der letzten Aktualisierung der Geräteeigenschaften |