Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Simulazione hamiltoniana analogica
La [simulazione hamiltoniana analogica](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) è un paradigma emergente nell'informatica quantistica che si differenzia significativamente dal modello di circuito quantistico tradizionale. Invece di una sequenza di porte, in cui ogni circuito agisce solo su un paio di qubit alla volta. Un programma AHS è definito dai parametri dipendenti dal tempo e dallo spazio dell'hamiltoniano in questione. L'[hamiltoniano di un sistema codifica i suoi livelli di](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) energia e gli effetti delle forze esterne, che insieme governano l'evoluzione temporale dei suoi stati. Per un sistema a N-qubit, l'hamiltoniano può essere rappresentato da una matrice quadrata di numeri complessi di 2 N X2 N.
I dispositivi quantistici in grado di eseguire AHS sono progettati per approssimare da vicino l'evoluzione temporale di un sistema quantistico in un sistema hamiltoniano personalizzato regolando attentamente i parametri di controllo interno. Ad esempio, la regolazione dell'ampiezza e la desintonizzazione dei parametri di un campo di guida coerente. Il paradigma AHS è adatto per simulare le proprietà statiche e dinamiche dei sistemi quantistici con molte particelle interagenti, come nella fisica della materia condensata o nella chimica quantistica. Le unità di elaborazione quantistica costruite appositamente (QPUs), come il [dispositivo Aquila](https://aws.amazon.com/braket/quantum-computers/quera/), sono state sviluppate per sfruttare la potenza dell'AHS e affrontare problemi che esulano dalla QuEra portata degli approcci convenzionali di calcolo quantistico digitale in modi innovativi.
**Topics**
+ [Hello AHS: esegui la tua prima simulazione hamiltoniana analogica](braket-get-started-hello-ahs.md)
+ [Invia un QuEra programma analogico usando Aquila](braket-quera-submitting-analog-program-aquila.md)
# Hello AHS: esegui la tua prima simulazione hamiltoniana analogica
Questa sezione fornisce informazioni sull'esecuzione della prima simulazione hamiltoniana analogica.
**Topics**
+ [Catena di rotazione interagente](#braket-get-started-interacting-spin-chain)
+ [Disposizione](#braket-get-started-arrangement)
+ [Interazione](#braket-get-started-interaction)
+ [Campo di guida](#braket-get-started-driving-field)
+ [Programma AHS](#braket-get-started-ahs-program)
+ [In esecuzione su un simulatore locale](#braket-get-started-running-local-simulator)
+ [Analisi dei risultati del simulatore](#braket-get-started-analyzing-simulator-results)
+ [È in esecuzione la QPU Aquila QuEra](#braket-get-started-running-aquila-qpu)
+ [Analisi dei risultati della QPU](#braket-get-started-analyzing-qpu-results)
+ [Fasi successive](#braket-get-started-ahs-next)
## Catena di rotazione interagente
Per un esempio canonico di un sistema di molte particelle interagenti, consideriamo un anello di otto spin (ognuno dei quali può trovarsi negli stati «su» ↑⟩ e «giù» ↓ ⟩). Sebbene piccolo, questo sistema modello mostra già una manciata di interessanti fenomeni legati ai materiali magnetici presenti in natura. In questo esempio, mostreremo come preparare un cosiddetto ordine antiferromagnetico, in cui gli spin consecutivi puntano in direzioni opposte.
![\[Diagramma che collega 8 nodi circolari che contengono frecce invertite su e giù.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/AntiFerromagnetic.png)
## Disposizione
Useremo un atomo neutro per rappresentare ogni spin, e gli stati di spin «su» e «giù» saranno codificati rispettivamente nello stato eccitato di Rydberg e nello stato fondamentale degli atomi. Per prima cosa, creiamo la disposizione bidimensionale. Possiamo programmare il suddetto anello di giri con il seguente codice.
**Prerequisiti**: è necessario installare pip l'SDK [Braket](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk). (Se si utilizza un'istanza di notebook ospitata da Braket, questo SDK viene preinstallato con i notebook.) Per riprodurre i grafici, è inoltre necessario installare separatamente matplotlib con il comando 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)
```
con cui possiamo anche tracciare
```
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
```
![\[Grafico a dispersione che mostra i punti distribuiti tra valori positivi e negativi su entrambi gli assi.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/PlotNeutralAtoms.png)
## Interazione
Per preparare la fase antiferromagnetica, dobbiamo indurre interazioni tra spin adiacenti. A tale scopo utilizziamo l'[interazione di van der Waals](https://en.wikipedia.org/wiki/Van_der_Waals_force), che viene implementata nativamente da dispositivi ad atomi neutri (come il dispositivo from). Aquila QuEra Utilizzando la rappresentazione dello spin, il termine hamiltoniano per questa interazione può essere espresso come somma di tutte le coppie di spin (j, k).
![\[Equazione di interazione hamiltoniana che mostra questa interazione espressa come somma di tutte le coppie di spin (j, k).\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/HInteraction.png)
In questo caso, nj=^ ↑ è un operatore che assume j il valore di 1 solo se lo spin j è nello stato j «alto», e 0 in caso contrario. La forza è V j,k =C6/(dj,k) 6, dove C 6 è il coefficiente fisso e d è la distanza euclidea tra gli spin j e j,k k. L'effetto immediato di questo termine di interazione è che ogni stato in cui sia lo spin j che lo spin k sono «verso l'alto» ha un'energia elevata (della quantità V). j,k Progettando attentamente il resto del programma AHS, questa interazione eviterà che entrambi gli spin adiacenti si trovino nello stato «attivo», un effetto comunemente noto come «blocco di Rydberg».
## Campo di guida
All'inizio del programma AHS, tutti gli spin (per impostazione predefinita) iniziano nel loro stato «inattivo», si trovano in una cosiddetta fase ferromagnetica. Tenendo d'occhio il nostro obiettivo di preparare la fase antiferromagnetica, specifichiamo un campo guida coerente dipendente dal tempo che trasferisce agevolmente gli spin da questo stato a uno stato a molti corpi in cui sono preferiti gli stati «alti». L'hamiltoniano corrispondente può essere scritto come
![\[Equazione matematica che descrive il calcolo di una funzione di azionamento hamiltoniana.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/HDrive.png)
dove Ω (t), 4444t (t), Δ (t) sono l'ampiezza globale (nota anche come [frequenza Rabi](https://en.wikipedia.org/wiki/Rabi_frequency)), la fase e la desintonizzazione del campo di pilotaggio dipendenti dal tempo che influiscono uniformemente su tutti gli spin. Qui S −,k =↓ k †↑ k e S \$1,k =( S−,k) † =↑ ↑ k ↓ k sono rispettivamente gli operatori di abbassamento e innalzamento dello spin k, e k n k =↑ ↑ ≤ k è lo stesso operatore di prima. La parte Ω del campo di pilotaggio accoppia in modo coerente gli stati «giù» e «su» di tutti gli spin contemporaneamente, mentre la parte Δ controlla la ricompensa energetica per gli stati «su».
Per programmare una transizione graduale dalla fase ferromagnetica alla fase antiferromagnetica, specifichiamo il campo di pilotaggio con il seguente codice.
```
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
)
```
Possiamo visualizzare le serie temporali del campo di guida con il seguente script.
```
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
```
![\[Tre grafici che mostrano phi, delta e omega nel tempo. La sottotrama in alto mostra la crescita fino a poco sopra 6, rads/s dove rimane per 4 secondi fino a quando non torna a 0. La sottotrama centrale mostra la crescita lineare associata della derivata e la sottotrama inferiore illustra una linea piatta vicina allo zero.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/DrivingTimeSeries.png)
## Programma AHS
Il registro, il campo di guida (e le interazioni implicite di van der Waals) costituiscono il programma Analog Hamiltonian Simulation. `ahs_program`
```
from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation
ahs_program = AnalogHamiltonianSimulation(
register=register,
hamiltonian=drive
)
```
## In esecuzione su un simulatore locale
Poiché questo esempio è piccolo (meno di 15 giri), prima di eseguirlo su una QPU compatibile con AHS, possiamo eseguirlo sul simulatore AHS locale fornito con l'SDK Braket. Poiché il simulatore locale è disponibile gratuitamente con Braket SDK, questa è la migliore pratica per garantire che il nostro codice possa essere eseguito correttamente.
Qui, possiamo impostare il numero di scatti su un valore elevato (ad esempio, 1 milione) perché il simulatore locale traccia l'evoluzione temporale dello stato quantistico e preleva campioni dallo stato finale, aumentando quindi il numero di scatti e aumentando la durata totale solo marginalmente.
```
from braket.devices import LocalSimulator
device = LocalSimulator("braket_ahs")
result_simulator = device.run(
ahs_program,
shots=1_000_000
).result() # Takes about 5 seconds
```
## Analisi dei risultati del simulatore
Possiamo aggregare i risultati dei colpi con la seguente funzione che deduce lo stato di ogni rotazione (che può essere «d» per «giù», «u» per «su» o «e» per il sito vuoto) e conta quante volte ogni configurazione si è verificata tra i colpi.
```
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`Ecco un dizionario che conta il numero di volte in cui ogni configurazione di stato viene osservata tra le riprese. Possiamo anche visualizzarli con il codice seguente.
```
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)
```
![\[Grafico a barre che mostra un gran numero di scatti senza configurazioni di stati «superiori» adiacenti.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/AHSCounts1.png)
![\[Grafico a barre che mostra immagini di alcune configurazioni di stati «superiori» adiacenti, con 4 stati a 1,0 scatti.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/AHSCounts2.png)
Dai grafici, possiamo leggere le seguenti osservazioni per verificare di aver preparato con successo la fase antiferromagnetica.
1. In genere, gli stati non bloccati (in cui non ci sono due spin adiacenti nello stato «attivo») sono più comuni degli stati in cui almeno una coppia di spin adiacenti si trova entrambi nello stato «positivo».
1. In genere, sono preferiti gli stati con più eccitazioni «in alto», a meno che la configurazione non sia bloccata.
1. Gli stati più comuni sono infatti gli stati antiferromagnetici perfetti e. `"dudududu"` `"udududud"`
1. I secondi stati più comuni sono quelli in cui ci sono solo 3 eccitazioni «verso l'alto» con separazioni consecutive di 1, 2, 2. Ciò dimostra che l'interazione di van der Waals ha un effetto (anche se molto minore) anche sui vicini più prossimi.
## È in esecuzione la QPU Aquila QuEra
**Prerequisiti**[: oltre all'installazione pip dell'[SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) Braket, se non utilizzi Amazon Braket, assicurati di aver completato i passaggi introduttivi necessari.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html)
**Nota**
Se utilizzi un'istanza di notebook ospitata da Braket, l'SDK Braket viene preinstallato con l'istanza.
Con tutte le dipendenze installate, possiamo connetterci alla QPU. Aquila
```
from braket.aws import AwsDevice
aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
```
Per rendere il nostro programma AHS adatto alla QuEra macchina, dobbiamo arrotondare tutti i valori per rispettare i livelli di precisione consentiti dalla Aquila QPU. (Questi requisiti sono regolati dai parametri del dispositivo con «Risoluzione» nel nome. Possiamo vederli `aquila_qpu.properties.dict()` eseguendoli su un notebook. Per ulteriori dettagli sulle funzionalità e sui requisiti di Aquila, vedere il notebook [Introduzione ad Aquila](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb).) Possiamo farlo chiamando il `discretize` metodo.
```
discretized_ahs_program = ahs_program.discretize(aquila_qpu)
```
Ora possiamo eseguire il programma (per ora eseguendo solo 100 scatti) sulla Aquila QPU.
**Nota**
L'esecuzione di questo programma sul Aquila processore comporterà un costo. L'SDK Amazon Braket include un [Cost Tracker](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/) che consente ai clienti di impostare limiti di costo e di tenere traccia dei costi quasi in tempo reale.
```
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
```
A causa della grande differenza tra il tempo di esecuzione di un'attività quantistica (a seconda delle finestre di disponibilità e dell'utilizzo della QPU), è una buona idea annotare l'ARN dell'attività quantistica, in modo da poterne controllare lo stato in un secondo momento con il seguente frammento di codice.
```
# 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
```
Una volta che lo stato è COMPLETATO (che può essere verificato anche dalla pagina delle attività quantistiche della console Amazon [Braket](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks)), possiamo interrogare i risultati con:
```
result_aquila = task.result()
```
## Analisi dei risultati della QPU
Usando le stesse `get_counts` funzioni di prima, possiamo calcolare i conteggi:
```
counts_aquila = get_counts(result_aquila)
print(counts_aquila)
```
```
*[Output]*
{'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...}
```
e tracciali con`plot_counts`:
```
plot_counts(counts_aquila)
```
![\[Grafico a barre che mostra un gran numero di scatti senza configurazioni di stati «superiori» adiacenti.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/QPUPlotCounts1.png)
![\[Grafico a barre che mostra immagini di alcune configurazioni di stati «superiori» adiacenti, con 4 stati a 1,0 scatti.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/QPUPlotCounts2.png)
Si noti che una piccola parte delle riprese presenta aree vuote (contrassegnate con «e»). Ciò è dovuto a imperfezioni della QPU nella preparazione dell'1-2% per atomo. Aquila Inoltre, i risultati corrispondono alla simulazione nell'ambito della fluttuazione statistica prevista a causa del numero ridotto di scatti.
## Fasi successive
Congratulazioni, ora hai eseguito il tuo primo carico di lavoro AHS su Amazon Braket utilizzando il simulatore AHS locale e la QPU. Aquila
[Per ulteriori informazioni sulla fisica di Rydberg, sulla simulazione hamiltoniana analogica e sul dispositivo, consulta i nostri taccuini di esempio. Aquila](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation)
# Invia un QuEra programma analogico usando Aquila
Questa pagina fornisce una documentazione completa sulle funzionalità della Aquila macchina diQuEra. I dettagli trattati qui sono i seguenti:
1. L'hamiltoniano parametrizzato simulato da Aquila
1. Parametri del programma AHS
1. Contenuto dei risultati AHS
1. Aquilaparametro delle capacità
**Topics**
+ [hamiltoniano](#braket-quera-aquila-device-hamiltonian)
+ [Schema del programma Braket AHS](#braket-quera-ahs-program-schema)
+ [schema dei risultati dell'attività Braket AHS](#braket-quera-ahs-task-result-schema)
+ [QuEra schema delle proprietà del dispositivo](#braket-quera-device-properties-schema)
## hamiltoniano
La Aquila macchina di QuEra simula nativamente il seguente hamiltoniano (dipendente dal tempo):
![\[Equazione matematica con sommatorie che rappresentano l'hamiltoniana di un sistema, che include i termini drive, detoning locale e accoppiamento interdot.\]](http://docs.aws.amazon.com/it_it/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png)
**Nota**
[L'accesso alla detuning locale è una funzionalità sperimentale ed è disponibile su richiesta tramite Braket Direct.](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html)
dove
+ H drive,k (t) =( 1/2Ω (t) e i (t) S −,k \$1 1/2Ω (t) s) \$1 (−Δ (t\$1,k) n), global k
+ Ω (t) è l'ampiezza di guida globale, dipendente dal tempo (nota anche come frequenza Rabi), espressa in unità di (rad/s)
+ □ (t) è la fase globale, dipendente dal tempo, misurata in radianti
+ S −,k e S \$1,k sono gli operatori che abbassano e innalzano lo spin dell'atomo k (in base \$1↓⟩ =\$1g⟩, \$1↑=\$1r⟩, sono S =\$1g86.r\$1, S =( S) † =\$1rovolg\$1) − \$1 −
+ Δ (t) è la desintonizzazione globale dipendente dal tempo global
+ n k è l'operatore di proiezione sullo stato di Rydberg dell'atomo k (ovvero, n=\$1r86.r\$1)
+ H (t) =-Δ (t) h n local detuning,k local k k
+ Δ local (t) è il fattore dipendente dal tempo dello spostamento di frequenza locale, espresso in unità di (rad/s)
+ h k è il fattore dipendente dal sito, un numero adimensionale compreso tra 0,0 e 1,0
+ V vdw,k,l = C6/(dk,l) 6 n n, k l
+ C 6 è il coefficiente di van der Waals, espresso in unità di (rad/ s) \$1 (m) ^6
+ d k,l è la distanza euclidea tra l'atomo k e l, misurata in metri.
Gli utenti hanno il controllo sui seguenti parametri tramite lo schema del programma Braket AHS.
+ Disposizione bidimensionale degli atomi (kcoordinate x k e y di ciascun atomo k, in unità di um), che controlla le distanze atomiche a coppie d k,l con k, l=1,2,... N
+ Ω (t), la frequenza Rabi globale dipendente dal tempo, in unità di (rad/ s)
+ □ (t), la fase globale, dipendente dal tempo, in unità di (rad)
+ Δ global (t), la detonizzazione globale dipendente dal tempo, in unità di (rad/s)
+ Δ local (t), il fattore (globale) dipendente dal tempo dell'entità della detonizzazione locale, in unità di (rad/ s)
+ hk, il fattore (statico) dipendente dal sito dell'entità della detonizzazione locale, un numero adimensionale compreso tra 0,0 e 1,0
**Nota**
L'utente non può controllare quali livelli sono coinvolti (ovvero, gli operatori S, S −\$1, n sono fissi) né l'intensità del coefficiente di interazione Rydberg-Rydberg (C). 6
## Schema del programma Braket AHS
**Oggetto Braket.ir.ahs.program\$1v1.program (esempio**)
**Nota**
Se la funzione di [desintonizzazione locale non](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) è abilitata per il tuo account, usala nell'esempio seguente. `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** (esempio)
**Nota**
Se la funzione di [desintonizzazione locale](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) non è abilitata per il tuo account, usala `"localDetuning": []` nell'esempio seguente.
```
{
"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]
}
}
]
}
}
```
**Campi principali**
| Campo del programma | tipo | description |
| --- | --- | --- |
| setup.ahs\$1register.sites | Elenco [Elenco [Decimale]] | Elenco delle coordinate bidimensionali in cui le pinzette intrappolano gli atomi |
| setup.ahs\$1register.filling | Elenco [int] | Contrassegna gli atomi che occupano i siti trap con 1 e i siti vuoti con 0 |
| hamiltonian.drivingFields [] .amplitude.time\$1series.times | Elenco [Decimale] | punti temporali dell'ampiezza di guida, Omega (t) |
| hamiltonian.drivingFields [] .amplitude.time\$1series.values | Elenco [Decimale] | valori dell'ampiezza di guida, Omega (t) |
| hamiltonian.drivingFields [] .amplitude.pattern | str | modello spaziale di ampiezza di guida, Omega (t); deve essere «uniforme» |
| hamiltonian.drivingFields [] .phase.time\$1series.times | Elenco [Decimale] | punti temporali della fase di guida, phi (t) |
| hamiltonian.drivingFields [] .phase.time\$1series.values | Elenco [Decimale] | valori della fase di guida, phi (t) |
| hamiltonian.drivingFields [] .phase.pattern | str | modello spaziale della fase di guida, phi (t); deve essere «uniforme» |
| hamiltonian.drivingFields [] .detuning.time\$1series.times | Elenco [Decimale] | punti temporali di desintonizzazione della guida, delta\$1Global (t) |
| hamiltonian.drivingFields [] .detuning.time\$1series.values | Elenco [Decimale] | valori della detonizzazione della guida, delta\$1Global (t) |
| hamiltonian.drivingFields [] .detuning.pattern | str | modello spaziale di detuning di guida, delta\$1global (t); deve essere «uniforme» |
| hamiltonian.localDeTuning [] .magnitude.time\$1series.times | Elenco [Decimale] | punti temporali del fattore dipendente dal tempo della magnitudine locale di detonizzazione, delta\$1local (t) |
| hamiltonian.localDeTuning [] .magnitude.time\$1series.values | Elenco [Decimale] | valori del fattore dipendente dal tempo della magnitudine locale di detonizzazione, delta\$1local (t) |
| hamiltonian.localDeTuning [] .magnitude.pattern | Elenco [Decimale] | fattore dipendente dal sito della magnitudine di detonizzazione locale, h\$1k (i valori corrispondono ai siti in setup.ahs\$1register.sites) |
**Campi di metadati**
| Campo del programma | tipo | description |
| --- | --- | --- |
| braketSchemaHeader.name | str | nome dello schema; deve essere 'braket.ir.ahs.program' |
| braketSchemaHeader.versione | str | versione dello schema |
## schema dei risultati dell'attività Braket AHS
**braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result. AnalogHamiltonianSimulationQuantumTaskResult**(esempio)
```
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** (esempio)
```
{
"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
}
}
}
```
**Campi principali**
| Campo dei risultati dell'attività | tipo | description |
| --- | --- | --- |
| misure [] .shotResult.presequence | Elenco [int] | Bit di misurazione pre-sequenza (uno per ogni sito atomico) per ogni ripresa: 0 se il sito è vuoto, 1 se il sito è pieno, misurati prima delle sequenze di impulsi che eseguono l'evoluzione quantistica |
| misure [] .shotResult.postSequence | Elenco [int] | Bit di misurazione post-sequenza per ogni ripresa: 0 se l'atomo è nello stato di Rydberg o il sito è vuoto, 1 se l'atomo è allo stato fondamentale, misurati alla fine delle sequenze di impulsi che eseguono l'evoluzione quantistica |
**Campi di metadati**
| Campo dei risultati dell'attività | tipo | description |
| --- | --- | --- |
| braketSchemaHeader.name | str | nome dello schema; deve essere 'braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result' |
| braketSchemaHeader.versione | str | versione dello schema |
| Metadati delle attività. braketSchemaHeader.nome | str | nome dello schema; deve essere 'braket.task\$1result.task\$1metadata' |
| Metadati dell'attività. braketSchemaHeader.versione | str | versione dello schema |
| taskmetadata.id | str | L'ID dell'attività quantistica. Per le attività AWS quantistiche, questo è il compito quantistico ARN. |
| TaskMetadata.shots | int | Il numero di scatti per l'operazione quantistica |
| taskmetadata.shots.deviceID | str | L'ID del dispositivo su cui è stata eseguita l'operazione quantistica. Per AWS i dispositivi, questo è l'ARN del dispositivo. |
| taskmetadata.shots.createdat at | str | Il timestamp della creazione; il formato deve essere in ISO-8601/ string format:mm:SS.SSSZ. RFC3339 YYYY-MM-DDTHH L'impostazione predefinita è Nessuno. |
| taskmetadata.shots.EndedAt | str | Il timestamp di quando è terminato il task quantistico; il formato deve essere in ISO-8601/ string format:mm:SS.SSSZ. RFC3339 YYYY-MM-DDTHH L'impostazione predefinita è Nessuno. |
| taskMetadata.shots.status | str | Lo stato dell'attività quantistica (CREATED, QUEUED, RUNNING, COMPLETED, FAILED). L'impostazione predefinita è Nessuno. |
| taskmetadata.shots.failureReason | str | Il motivo del fallimento del compito quantistico. L'impostazione predefinita è Nessuno. |
| Metadati aggiuntivi. Action | Braket.ir.ahs.program\$1v1.program | [(Vedi la sezione sullo schema del programma Braket AHS)](#braket-quera-ahs-program-schema) |
| Metadati aggiuntivi. Azione. braketSchemaHeader.querametadata.name | str | nome dello schema; deve essere 'braket.task\$1result.quera\$1metadata' |
| Metadati aggiuntivi. Action. braketSchemaHeader.querametadata.version | str | versione dello schema |
| Metadati aggiuntivi. Action. numSuccessfulShots | int | numero di tiri completamente riusciti; deve essere uguale al numero di tiri richiesto |
| misure [] .shotMetadata.shotStatus | int | Lo stato dello scatto, (Successo, Riuscito parziale, Fallimento); deve essere «Riuscito» |
## QuEra schema delle proprietà del dispositivo
**braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1. QueraDeviceCapabilities**(esempio)
```
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** (esempio)
```
{
"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
...
}
}
```
**Campi delle proprietà del servizio**
| Campo delle proprietà del servizio | tipo | description |
| --- | --- | --- |
| service.executionWindows [] .executionDay | ExecutionDay | Giorni della finestra di esecuzione; deve essere «Tutti i giorni», «Giorni feriali», «Fine settimana», «lunedì», «martedì», «mercoledì», giovedì», «venerdì», «sabato» o «domenica» |
| Service.executionWindows []. windowStartHour | datetime.ora | Formato UTC a 24 ore dell'ora di inizio della finestra di esecuzione |
| Service.ExecutionWindows []. windowEndHour | datetime.ora | Formato UTC a 24 ore dell'ora in cui termina la finestra di esecuzione |
| service.qpu\$1capabilities.service.shotsRange | Tupla [int, int] | Numero minimo e massimo di scatti per il dispositivo |
| service.qpu\$1capabilities.service.deviceCost.price | virgola mobile | Prezzo del dispositivo in dollari USA |
| service.qpu\$1capabilities.service.deviceCost.unit | str | unità per l'addebito del prezzo, ad esempio: 'minute', 'hour', 'shot', 'task' |
**Campi di metadati**
| Campo di metadati | tipo | description |
| --- | --- | --- |
| action [] .version | str | versione dello schema del programma AHS |
| azione [] .actionType | ActionType | nome dello schema del programma AHS; deve essere 'braket.ir.ahs.program' |
| servizio. braketSchemaHeader.nome | str | nome dello schema; deve essere 'braket.device\$1schema.device\$1service\$1properties' |
| servizio. braketSchemaHeader.versione | str | versione dello schema |
| service.deviceDocumentation.imageURL | str | URL per l'immagine del dispositivo |
| Service.DeviceDocumentation.Summary | str | breve descrizione sul dispositivo |
| Documentazione Service.Device. externalDocumentationUrl | str | URL della documentazione esterna |
| service.deviceLocation | str | posizione geografica del dispositivo |
| Service.UpdateDat | datetime | ora in cui le proprietà del dispositivo sono state aggiornate l'ultima volta |