Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Simulation hamiltonienne analogique
La [simulation hamiltonienne analogique](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) est un nouveau paradigme de l'informatique quantique qui diffère considérablement du modèle de circuit quantique traditionnel. Au lieu d'une séquence de portes, où chaque circuit n'agit que sur quelques qubits à la fois. Un programme AHS est défini par les paramètres dépendants du temps et de l'espace de l'hamiltonien en question. L'[hamiltonien d'un système](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) code ses niveaux d'énergie et les effets des forces extérieures, qui, ensemble, régissent l'évolution temporelle de ses états. Pour un système à N qubits, l'hamiltonien peut être représenté par une matrice carrée de 2 N X2 N de nombres complexes.
Les dispositifs quantiques capables d'exécuter l'AHS sont conçus pour se rapprocher étroitement de l'évolution temporelle d'un système quantique selon un hamiltonien personnalisé en ajustant soigneusement leurs paramètres de contrôle interne. Par exemple, le réglage de l'amplitude et les paramètres de désaccordage d'un champ de conduite cohérent. Le paradigme AHS est bien adapté pour simuler les propriétés statiques et dynamiques de systèmes quantiques comportant de nombreuses particules en interaction, comme dans le cas de la physique de la matière condensée ou de la chimie quantique. Les unités de traitement quantique spécialement conçues (QPUs), comme le [dispositif Aquila](https://aws.amazon.com/braket/quantum-computers/quera/) deQuEra, ont été développées pour utiliser la puissance de l'AHS et résoudre des problèmes hors de portée des approches informatiques quantiques numériques conventionnelles de manière innovante.
**Topics**
+ [Bonjour AHS : Exécutez votre première simulation hamiltonienne analogique](braket-get-started-hello-ahs.md)
+ [Soumettre un programme analogique à l'aide d' QuEra Aquila](braket-quera-submitting-analog-program-aquila.md)
# Bonjour AHS : Exécutez votre première simulation hamiltonienne analogique
Cette section fournit des informations sur l'exécution de votre première simulation hamiltonienne analogique.
**Topics**
+ [Chaîne de spin en interaction](#braket-get-started-interacting-spin-chain)
+ [Arrangement](#braket-get-started-arrangement)
+ [Interaction](#braket-get-started-interaction)
+ [Champ de conduite](#braket-get-started-driving-field)
+ [Programme AHS](#braket-get-started-ahs-program)
+ [Exécution sur un simulateur local](#braket-get-started-running-local-simulator)
+ [Analyse des résultats du simulateur](#braket-get-started-analyzing-simulator-results)
+ [Running QuEra On's Aquila QPU](#braket-get-started-running-aquila-qpu)
+ [Analyse des résultats du QPU](#braket-get-started-analyzing-qpu-results)
+ [Étapes suivantes](#braket-get-started-ahs-next)
## Chaîne de spin en interaction
Pour un exemple canonique d'un système de nombreuses particules en interaction, considérons un anneau de huit spins (dont chacun peut être dans les états « haut » ↑ ⟩ et « bas »). Bien que petit, ce système modèle présente déjà une poignée de phénomènes intéressants liés aux matériaux magnétiques naturels. Dans cet exemple, nous allons montrer comment préparer un ordre dit antiferromagnétique, dans lequel des spins consécutifs pointent dans des directions opposées.
![\[Schéma reliant 8 nœuds circulaires contenant des flèches inversées vers le haut et vers le bas.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/AntiFerromagnetic.png)
## Arrangement
Nous utiliserons un atome neutre pour représenter chaque spin, et les états de spin « haut » et « bas » seront codés dans l'état de Rydberg excité et dans l'état fondamental des atomes, respectivement. Tout d'abord, nous créons l'arrangement 2D. Nous pouvons programmer l'anneau de tours ci-dessus avec le code suivant.
**Prérequis** : Vous devez installer le SDK [Braket](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) en un clin d'œil. (Si vous utilisez une instance de bloc-notes hébergée par Braket, ce SDK est préinstallé avec les blocs-notes.) Pour reproduire les tracés, vous devez également installer matplotlib séparément à l'aide de la commande shell. `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)
```
avec lequel nous pouvons également comploter
```
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
```
![\[Diagramme de dispersion montrant les points répartis entre des valeurs positives et négatives sur les deux axes.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/PlotNeutralAtoms.png)
## Interaction
Pour préparer la phase antiferromagnétique, nous devons induire des interactions entre des spins voisins. Pour cela, nous utilisons l'[interaction de van der Waals](https://en.wikipedia.org/wiki/Van_der_Waals_force), qui est implémentée nativement par des appareils à atomes neutres (tels que le Aquila périphérique deQuEra). En utilisant la représentation du spin, le terme hamiltonien pour cette interaction peut être exprimé sous la forme d'une somme de toutes les paires de spins (j, k).
![\[Équation d'interaction hamiltonienne montrant cette interaction exprimée sous la forme d'une somme de toutes les paires de spins (j, k).\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/HInteraction.png)
Ici, nj=↑ j ⟨↑ est j un opérateur qui prend la valeur 1 uniquement si le spin j est à l'état « up », et 0 dans le cas contraire. La force est V j,k =C6/(dj,k) 6, où C 6 est le coefficient fixe, et d j,k est la distance euclidienne entre les spins j et k. L'effet immédiat de ce terme d'interaction est que tout état dans lequel le spin j et le spin k sont à la fois « en hausse » produit une énergie élevée (de la quantité Vj,k). En concevant soigneusement le reste du programme AHS, cette interaction empêchera les spins voisins d'être tous deux à l'état « actif », un effet communément appelé « blocus de Rydberg ».
## Champ de conduite
Au début du programme AHS, tous les spins (par défaut) démarrent dans leur état « down », ils sont dans une phase dite ferromagnétique. En gardant un œil sur notre objectif de préparer la phase antiferromagnétique, nous avons spécifié un champ de commande cohérent dépendant du temps qui fait passer en douceur les spins de cet état à un état à plusieurs corps où les états « haut » sont préférés. L'hamiltonien correspondant peut être écrit comme
![\[Équation mathématique illustrant le calcul d'une fonction d'entraînement hamiltonienne.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/HDrive.png)
où Ω (t), φ (t), Δ (t) sont l'amplitude globale (ou [fréquence de Rabi](https://en.wikipedia.org/wiki/Rabi_frequency)), la phase et le désaccord du champ moteur en fonction du temps, affectant tous les spins de manière uniforme. Ici, S −,k =↓ k ⟨↑ k et S \$1,k =( S−,k) † =↑ ± k ↓ ↓ k sont respectivement les opérateurs d'abaissement et d'augmentation du spin k, et n k =↑ k k La partie Ω du champ moteur couple de manière cohérente les états « bas » et « haut » de tous les spins simultanément, tandis que la partie Δ contrôle la récompense énergétique pour les états « haut ».
Pour programmer une transition en douceur de la phase ferromagnétique à la phase antiferromagnétique, nous indiquons le champ de commande avec le code suivant.
```
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
)
```
Nous pouvons visualiser les séries chronologiques du champ de conduite avec le script suivant.
```
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
```
![\[Trois graphiques montrant les valeurs phi, delta et oméga au fil du temps. Le sous-graphique supérieur montre la croissance juste au-dessus de 6, rads/s où elle reste pendant 4 secondes jusqu'à ce qu'elle retombe à 0. Le sous-diagramme du milieu représente la croissance linéaire associée de la dérivée, tandis que le sous-diagramme du bas illustre une ligne plate proche de zéro.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/DrivingTimeSeries.png)
## Programme AHS
Le registre, le champ de conduite (et les interactions implicites de van der Waals) constituent le programme de simulation hamiltonienne analogique. `ahs_program`
```
from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation
ahs_program = AnalogHamiltonianSimulation(
register=register,
hamiltonian=drive
)
```
## Exécution sur un simulateur local
Comme cet exemple est petit (moins de 15 tours), avant de l'exécuter sur un QPU compatible AHS, nous pouvons l'exécuter sur le simulateur AHS local fourni avec le SDK Braket. Le simulateur local étant disponible gratuitement avec le SDK Braket, il s'agit d'une bonne pratique pour garantir que notre code puisse s'exécuter correctement.
Ici, nous pouvons régler le nombre de prises à une valeur élevée (disons, 1 million) car le simulateur local suit l'évolution temporelle de l'état quantique et prélève des échantillons à partir de l'état final, augmentant ainsi le nombre de prises de vue, tout en n'augmentant que légèrement le temps d'exécution total.
```
from braket.devices import LocalSimulator
device = LocalSimulator("braket_ahs")
result_simulator = device.run(
ahs_program,
shots=1_000_000
).result() # Takes about 5 seconds
```
## Analyse des résultats du simulateur
Nous pouvons agréger les résultats des tirs à l'aide de la fonction suivante qui déduit l'état de chaque rotation (qui peut être « d » pour « vers le bas », « u » pour « haut » ou « e » pour un site vide) et compte le nombre de fois où chaque configuration s'est produite sur les plans.
```
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`Voici un dictionnaire qui compte le nombre de fois que chaque configuration d'état est observée sur les plans. Nous pouvons également les visualiser avec le code suivant.
```
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)
```
![\[Diagramme à barres montrant un grand nombre de prises de vue sans configurations d'états « up » voisines.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/AHSCounts1.png)
![\[Diagramme à barres montrant des plans de certaines configurations d'états « en haut » voisines, avec 4 états à 1,0 plan.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/AHSCounts2.png)
À partir des graphiques, nous pouvons lire les observations suivantes pour vérifier que nous avons bien préparé la phase antiferromagnétique.
1. En général, les états non bloqués (où aucun spin voisin n'est dans l'état « haut ») sont plus courants que les états où au moins une paire de spins voisins sont tous deux dans l'état « haut ».
1. En général, les états avec plus d'excitations « ascendantes » sont privilégiés, sauf si la configuration est bloquée.
1. Les états les plus courants sont en effet les états `"dudududu"` antiferromagnétiques parfaits et. `"udududud"`
1. Les deuxièmes états les plus courants sont ceux où il n'y a que 3 excitations « ascendantes » avec des séparations consécutives de 1, 2, 2. Cela montre que l'interaction de van der Waals a également un effet (bien que beaucoup plus faible) sur les voisins les plus proches.
## Running QuEra On's Aquila QPU
**Conditions préalables** [: Outre l'installation du [SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) Braket par pip, si vous utilisez Amazon Braket pour la première fois, assurez-vous d'avoir suivi les étapes de démarrage nécessaires.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html)
**Note**
Si vous utilisez une instance de bloc-notes hébergée par Braket, le SDK Braket est préinstallé avec l'instance.
Une fois toutes les dépendances installées, nous pouvons nous connecter au Aquila QPU.
```
from braket.aws import AwsDevice
aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
```
Pour que notre programme AHS soit adapté à la QuEra machine, nous devons arrondir toutes les valeurs afin de respecter les niveaux de précision autorisés par le Aquila QPU. (Ces exigences sont régies par les paramètres de l'appareil dont le nom contient « Résolution ». Nous pouvons les voir en les exécutant `aquila_qpu.properties.dict()` dans un carnet. Pour plus de détails sur les fonctionnalités et les exigences d'Aquila, consultez le bloc-notes [Introduction à Aquila](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb).) Nous pouvons le faire en appelant la `discretize` méthode.
```
discretized_ahs_program = ahs_program.discretize(aquila_qpu)
```
Nous pouvons maintenant exécuter le programme (seulement 100 prises de vue pour le moment) sur le Aquila QPU.
**Note**
L'exécution de ce programme sur le Aquila processeur entraînera un coût. Le SDK Amazon Braket inclut un outil de [suivi des coûts](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/) qui permet aux clients de définir des limites de coûts et de suivre leurs coûts en temps quasi réel.
```
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
```
En raison de la grande variation de la durée d'exécution d'une tâche quantique (en fonction des fenêtres de disponibilité et de l'utilisation du QPU), il est conseillé de noter l'ARN de la tâche quantique, afin que nous puissions vérifier son statut ultérieurement à l'aide de l'extrait de code suivant.
```
# 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
```
Une fois le statut TERMINÉ (qui peut également être vérifié depuis la page des tâches quantiques de la [console](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks) Amazon Braket), nous pouvons interroger les résultats avec :
```
result_aquila = task.result()
```
## Analyse des résultats du QPU
En utilisant les mêmes `get_counts` fonctions que précédemment, nous pouvons calculer les nombres :
```
counts_aquila = get_counts(result_aquila)
print(counts_aquila)
```
```
*[Output]*
{'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...}
```
et tracez-les avec `plot_counts` :
```
plot_counts(counts_aquila)
```
![\[Diagramme à barres montrant un grand nombre de prises de vue sans configurations d'états « up » voisines.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/QPUPlotCounts1.png)
![\[Diagramme à barres montrant des plans de certaines configurations d'états « en haut » voisines, avec 4 états à 1,0 plan.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/QPUPlotCounts2.png)
Notez qu'une petite partie des prises de vue comportent des sites vides (marqués d'un « e »). Cela est dû à une imperfection de préparation de 1 à 2 % par atome du Aquila QPU. En outre, les résultats correspondent à la simulation dans les limites des fluctuations statistiques attendues en raison du faible nombre de prises de vue.
## Étapes suivantes
Félicitations, vous venez d'exécuter votre première charge de travail AHS sur Amazon Braket à l'aide du simulateur AHS local et du Aquila QPU.
[Pour en savoir plus sur la physique de Rydberg, la simulation hamiltonienne analogique et le Aquila dispositif, consultez nos exemples de carnets de notes.](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation)
# Soumettre un programme analogique à l'aide d' QuEra Aquila
Cette page fournit une documentation complète sur les fonctionnalités de la Aquila machine à partir deQuEra. Les détails abordés ici sont les suivants :
1. L'hamiltonien paramétré simulé par Aquila
1. Paramètres du programme AHS
1. Contenu du résultat AHS
1. Aquilaparamètre de capacités
**Topics**
+ [hamiltonien](#braket-quera-aquila-device-hamiltonian)
+ [Schéma du programme Braket AHS](#braket-quera-ahs-program-schema)
+ [Schéma des résultats des tâches Braket AHS](#braket-quera-ahs-task-result-schema)
+ [QuEra schéma des propriétés de l'appareil](#braket-quera-device-properties-schema)
## hamiltonien
La Aquila machine de QuEra simule nativement l'hamiltonien suivant (en fonction du temps) :
![\[Équation mathématique avec des sommations représentant l'hamiltonien d'un système, impliquant des termes d'entraînement, de désaccordage local et de couplage interpoints.\]](http://docs.aws.amazon.com/fr_fr/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png)
**Note**
L'accès au désaccordage local est une [fonctionnalité expérimentale](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html) et est disponible sur demande via Braket Direct.
où
+ H drive,k (t) = (1/2Ω (t) e iφ (t) S −,k \$1 1/2Ω (t) e −iφ (t) S) \$1 (−Δ global (t\$1,k) n), k
+ Ω (t) est l'amplitude de conduite globale en fonction du temps (également appelée fréquence de Rabi), en unités de (rad/s)
+ φ (t) est la phase globale dépendante du temps, mesurée en radians
+ S −,k et S \$1,k sont les opérateurs d'abaissement et d'augmentation du spin de l'atome k (dans la base \$1↓⟩ =\$1g⟩, \$1↑=\$1r⟩, ils sont S − =\$1g \$1 −
+ Δ global (t) est le déréglage global dépendant du temps
+ n k est l'opérateur de projection sur l'état de Rydberg de l'atome k (c'est-à-dire, n=\$1r
+ H local detuning,k (t) =-Δ local (t) h n k k
+ Δ local (t) est le facteur dépendant du temps du décalage de fréquence local, en unités de (rad/s)
+ h k est le facteur dépendant du site, un nombre sans dimension compris entre 0,0 et 1,0
+ V vdw,k,l = C6/(dk,l) 6 n k n, l
+ C 6 est le coefficient de van der Waals, en unités de (rad/s) \$1 (m) ^6
+ d k,l est la distance euclidienne entre l'atome k et l, mesurée en mètres.
Les utilisateurs peuvent contrôler les paramètres suivants via le schéma du programme Braket AHS.
+ Arrangement bidimensionnel des atomes (kcoordonnées x k et y de chaque atome k, en unités de µm), qui contrôle les distances atomiques par paires d k,l avec k, l=1,2,... N
+ Ω (t), fréquence globale de Rabi dépendante du temps, en unités de (rad/s)
+ φ (t), phase globale dépendante du temps, en unités de (rad)
+ Δ global (t), le désaccordage global dépendant du temps, en unités de (rad/s)
+ Δ local (t), le facteur (global) dépendant du temps de l'ampleur du déréglage local, en unités de (rad/s)
+ hk, le facteur (statique) dépendant du site de l'ampleur du déréglage local, un nombre adimensionnel compris entre 0,0 et 1,0
**Note**
L'utilisateur ne peut pas contrôler les niveaux concernés (c'est-à-dire que les opérateurs S−, S\$1, n sont fixes) ni la force du coefficient d'interaction Rydberg-Rydberg (C). 6
## Schéma du programme Braket AHS
**Objet Braket.IR.AHS.Program\$1V1.program** (exemple)
**Note**
Si la fonctionnalité de [désaccordage local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) n'est pas activée pour votre compte, utilisez-la `localDetuning=[]` dans l'exemple suivant.
```
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** (exemple)
**Note**
Si la fonctionnalité de [désaccordage local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) n'est pas activée pour votre compte, utilisez-la `"localDetuning": []` dans l'exemple suivant.
```
{
"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]
}
}
]
}
}
```
**Principaux domaines**
| Champ du programme | type | description |
| --- | --- | --- |
| setup.ahs\$1register.sites | Liste [Liste [Décimal]] | Liste des coordonnées bidimensionnelles où la pince à épiler piège les atomes |
| setup.ahs\$1register.filling | Liste [int] | Marque les atomes qui occupent les sites piégés avec 1 et les sites vides avec 0 |
| Hamiltonian.DrivingFields [] .amplitude.time\$1series.times | Liste [décimale] | points temporels de l'amplitude de conduite, Omega (t) |
| Hamiltonian.DrivingFields [] .amplitude.time\$1series.values | Liste [décimale] | valeurs de l'amplitude de conduite, Omega (t) |
| Hamiltonian.DrivingFields [] .amplitude.pattern | str | schéma spatial de l'amplitude de conduite, Omega (t) ; doit être « uniforme » |
| Hamiltonian.DrivingFields [] .phase.time\$1series.times | Liste [décimale] | points temporels de la phase de conduite, phi (t) |
| Hamiltonian.DrivingFields [] .phase.time\$1series.values | Liste [décimale] | valeurs de la phase de conduite, phi (t) |
| Hamiltonian.DrivingFields [] .phase.pattern | str | schéma spatial de la phase de conduite, phi (t) ; doit être « uniforme » |
| Hamiltonian.DrivingFields [] .detuning.time\$1series.times | Liste [décimale] | points temporels du désaccordage de conduite, Delta\$1global (t) |
| Hamiltonian.DrivingFields [] .detuning.time\$1series.values | Liste [décimale] | valeurs du désaccordage de conduite, Delta\$1global (t) |
| Hamiltonian.DrivingFields [] .detuning.pattern | str | schéma spatial de désaccordage de conduite, Delta\$1global (t) ; doit être « uniforme » |
| Hamiltonian.LocalDeTuning [] .magnitude.time\$1series.times | Liste [décimale] | points temporels du facteur dépendant du temps de l'amplitude de désaccordage locale, Delta\$1local (t) |
| Hamiltonian.LocalDeTuning [] .magnitude.time\$1series.values | Liste [décimale] | valeurs du facteur dépendant du temps de l'amplitude de déréglage locale, Delta\$1local (t) |
| Hamiltonian.LocalDeTuning [] .magnitude.pattern | Liste [décimale] | facteur dépendant du site de l'amplitude du déréglage local, h\$1k (les valeurs correspondent aux sites dans setup.ahs\$1register.sites) |
**Champs de métadonnées**
| Champ du programme | type | description |
| --- | --- | --- |
| braketSchemaHeader.nom | str | nom du schéma ; doit être « braket.ir.ahs.program » |
| braketSchemaHeader.version | str | version du schéma |
## Schéma des résultats des tâches Braket AHS
**braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result. AnalogHamiltonianSimulationQuantumTaskResult**(exemple)
```
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** (exemple)
```
{
"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
}
}
}
```
**Principaux domaines**
| Champ de résultat de la tâche | type | description |
| --- | --- | --- |
| mesures [] .ShotResult.PreSequence | Liste [int] | Bits de mesure de pré-séquence (un pour chaque site atomique) pour chaque tir : 0 si le site est vide, 1 si le site est plein, mesurés avant les séquences d'impulsions qui exécutent l'évolution quantique |
| mesures [] .ShotResult.PostSequence | Liste [int] | Bits de mesure post-séquence pour chaque tir : 0 si l'atome est dans l'état de Rydberg ou si le site est vide, 1 si l'atome est dans l'état fondamental, mesurés à la fin des séquences d'impulsions qui exécutent l'évolution quantique |
**Champs de métadonnées**
| Champ de résultat de la tâche | type | description |
| --- | --- | --- |
| braketSchemaHeader.nom | str | nom du schéma ; doit être « braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result » |
| braketSchemaHeader.version | str | version du schéma |
| Métadonnées des tâches. braketSchemaHeader.nom | str | nom du schéma ; doit être « braket.task\$1result.task\$1metadata » |
| Métadonnées des tâches. braketSchemaHeader.version | str | version du schéma |
| TaskMetadata.id | str | L'identifiant de la tâche quantique. Pour les tâches AWS quantiques, il s'agit de l'ARN des tâches quantiques. |
| TaskMetadata.Shots | int | Le nombre de tirs pour la tâche quantique |
| TaskMetadata.Shots.DeviceID | str | L'identifiant de l'appareil sur lequel la tâche quantique s'est exécutée. Pour les AWS appareils, il s'agit de l'ARN de l'appareil. |
| TaskMetadata.Shots.Créé à | str | Horodatage de la création ; le format doit être au format RFC3339 ISO-8601/ string format:MM:SS.SSSZ. YYYY-MM-DDTHH La valeur par défaut est None. |
| TaskMetadata.shots.Endedat | str | Horodatage de la fin de la tâche quantique ; le format doit être au format RFC3339 ISO-8601/ string format:MM:SS.SSSZ. YYYY-MM-DDTHH La valeur par défaut est None. |
| TaskMetadata.Shots.Status | str | État de la tâche quantique (CREATED, QUEUED, RUNNING, COMPLETED, FAILED). La valeur par défaut est None. |
| TaskMetadata.Shots.Raison de l'échec | str | La raison de l'échec de la tâche quantique. La valeur par défaut est None. |
| Métadonnées.Action supplémentaires | Braket.IR.AHS.Program\$1V1.program | (Voir la section sur le [schéma du programme Braket AHS](#braket-quera-ahs-program-schema)) |
| Métadonnées supplémentaires. Action. braketSchemaHeader.querametadata.name | str | nom du schéma ; doit être « braket.task\$1result.quera\$1metadata » |
| Métadonnées supplémentaires. Action. braketSchemaHeader.Quera Metadata.Version | str | version du schéma |
| Métadonnées supplémentaires. Action. numSuccessfulShots | int | nombre de prises complètement réussies ; doit être égal au nombre de prises demandé |
| mesures [] .shotMetadata.shotStatus | int | Le statut du tir (succès, succès partiel, échec) doit être « Succès » |
## QuEra schéma des propriétés de l'appareil
**braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1. QueraDeviceCapabilities**(exemple)
```
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** (exemple)
```
{
"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
...
}
}
```
**Champs des propriétés du service**
| Champ des propriétés du service | type | description |
| --- | --- | --- |
| Service.ExecutionWindows [] .ExecutionDay | ExecutionDay | Jours de la fenêtre d'exécution ; doivent être « Tous les jours », « Jours de semaine », « Week-end », « lundi », « mardi », « mercredi », « jeudi », « vendredi », « samedi » ou « dimanche » |
| Service.ExecutionWindows []. windowStartHour | datetime.heure | Format UTC 24 heures de l'heure de début de la fenêtre d'exécution |
| Service.ExecutionWindows []. windowEndHour | datetime.heure | Format UTC de 24 heures indiquant l'heure de fin de la fenêtre d'exécution |
| service.qpu\$1capabilities.service.shotsRange | Tuple [int, int] | Nombre minimum et maximum de prises de vue pour l'appareil |
| service.qpu\$1capabilities.service.DeviceCost.Price | float | Prix de l'appareil en dollars américains |
| service.qpu\$1capabilities.service.DeviceCost.unit | str | unité pour facturer le prix, par exemple : « minute », « heure », « shot », « task » |
**Champs de métadonnées**
| Champ de métadonnées | type | description |
| --- | --- | --- |
| action [] .version | str | version du schéma du programme AHS |
| action [] .ActionType | ActionType | Nom du schéma du programme AHS ; doit être « braket.ir.ahs.program » |
| service. braketSchemaHeader.nom | str | nom du schéma ; doit être « braket.device\$1schema.device\$1service\$1properties » |
| service. braketSchemaHeader.version | str | version du schéma |
| Service.DeviceDocumentation.URL de l'image | str | URL de l'image de l'appareil |
| Service.DeviceDocumentation.Résumé | str | brève description de l'appareil |
| Service.DeviceDocumentation. externalDocumentationUrl | str | URL de documentation externe |
| Service.Emplacement de l'appareil | str | emplacement géographique de l'appareil |
| Service. Mis à jour à | datetime | heure à laquelle les propriétés de l'appareil ont été mises à jour pour la dernière fois |