Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Simulación hamiltoniana analógica La [simulación hamiltoniana analógica](https://en.wikipedia.org/wiki/Hamiltonian_simulation) (AHS) es un paradigma emergente en la computación cuántica que difiere significativamente del modelo de circuito cuántico tradicional. En lugar de una secuencia de puertas, en la que cada circuito actúa solo sobre un par de qubits a la vez. Un programa de AHS se define por los parámetros dependientes del tiempo y del espacio del hamiltoniano en cuestión. El [hamiltoniano de un sistema](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) codifica sus niveles de energía y los efectos de las fuerzas externas, que juntos gobiernan la evolución temporal de sus estados. Para un sistema de N qubits, el hamiltoniano puede representarse mediante una matriz cuadrada 2NX2N de números complejos. Los dispositivos cuánticos capaces de realizar AHS están diseñados para aproximarse con gran precisión a la evolución temporal de un sistema cuántico bajo un hamiltoniano personalizado, ajustando cuidadosamente sus parámetros de control internos. Por ejemplo, ajustando los parámetros de amplitud y desintonización de un campo de excitación coherente. El paradigma AHS es muy adecuado para simular las propiedades estáticas y dinámicas de los sistemas cuánticos con muchas partículas en interacción, como en la física de la materia condensada o la química cuántica. Las unidades de procesamiento cuántico diseñadas específicamente (QPUs), como el [dispositivo Aquila](https://aws.amazon.com/braket/quantum-computers/quera/) deQuEra, se han desarrollado para utilizar el poder del AHS y abordar problemas que están fuera del alcance de los enfoques convencionales de computación cuántica digital de manera innovadora. **Topics** + [Hola AHS: ejecución de la primera simulación hamiltoniana analógica](braket-get-started-hello-ahs.md) + [Envíe un programa analógico con Aquila QuEra](braket-quera-submitting-analog-program-aquila.md) # Hola AHS: ejecución de la primera simulación hamiltoniana analógica En esta sección se proporciona información sobre cómo ejecutar su primera simulación hamiltoniana analógica. **Topics** + [Cadena de espín interactiva](#braket-get-started-interacting-spin-chain) + [Disposición](#braket-get-started-arrangement) + [Interacción](#braket-get-started-interaction) + [Campo de accionamiento](#braket-get-started-driving-field) + [Programa de AHS](#braket-get-started-ahs-program) + [Ejecución en un simulador local](#braket-get-started-running-local-simulator) + [Análisis de resultados de simuladores](#braket-get-started-analyzing-simulator-results) + [Se ejecuta en la QuEra QPU Aquila](#braket-get-started-running-aquila-qpu) + [Análisis de los resultados de la QPU](#braket-get-started-analyzing-qpu-results) + [Siguientes pasos](#braket-get-started-ahs-next) ## Cadena de espín interactiva Como ejemplo canónico de un sistema de muchas partículas que interactúan, consideremos un anillo de ocho espines (cada uno de los cuales puede estar en estados «arriba» y «abajo»). Aunque pequeño, este sistema modelo ya muestra una serie de fenómenos interesantes propios de los materiales magnéticos naturales. En este ejemplo, mostraremos cómo preparar un orden denominado antiferromagnético, en el que los espines consecutivos apuntan en direcciones opuestas. ![\[Diagrama que conecta 8 nodos circulares que contienen flechas inversas hacia arriba y hacia abajo.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/AntiFerromagnetic.png) ## Disposición Utilizaremos un átomo neutro para representar cada espín, y los estados de espín «arriba» y «abajo» se codificarán en el estado excitado de Rydberg y el estado fundamental de los átomos, respectivamente. En primer lugar, crearemos la disposición 2-D. Podemos programar el anillo de espines anterior con el siguiente código. **Requisitos previos**: es necesario instalar el [SDK de Braket](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk). (Si utiliza una instancia de cuaderno alojada en Braket, este SDK viene preinstalado con los cuadernos). Para reproducir los gráficos, también debe instalar matplotlib por separado con el intérprete de comandos `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) ``` que también podemos representar gráficamente con: ``` 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 ``` ![\[Gráfico de dispersión que muestra puntos distribuidos entre valores positivos y negativos en ambos ejes.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/PlotNeutralAtoms.png) ## Interacción Para preparar la fase antiferromagnética, necesitamos inducir interacciones entre espines vecinos. Para ello utilizamos la [interacción de van der Waals](https://en.wikipedia.org/wiki/Van_der_Waals_force), que se implementa de forma nativa mediante dispositivos de átomos neutros (como el dispositivo Aquila de QuEra). Utilizando la representación de espines, el término hamiltoniano para esta interacción puede expresarse como una suma de todos los pares de espines (j, k). ![\[Ecuación de interacción hamiltoniana que muestra esta interacción expresada como una suma de todos los pares de espines (j, k).\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/HInteraction.png) Aquí, nj​=∣↑j​⟩⟨↑j​∣es un operador que toma el valor 1 solo si el espín j está en el estado «arriba», y 0 en caso contrario. La fuerza es Vj,k​=C6​/(dj,k​)6, donde C6​ es el coeficiente fijo y dj,k​ es la distancia euclidiana entre los espines j y k. El efecto inmediato de este término de interacción es que cualquier estado en el que tanto el espín j como el espín k estén «arriba» tienen una energía elevada (con la cantidad Vj,k​). Al diseñar cuidadosamente el resto del programa de AHS, esta interacción evitará que los espines vecinos se encuentren ambos en el estado «arriba», un efecto conocido comúnmente como «bloqueo de Rydberg». ## Campo de accionamiento Al inicio del programa de AHS, todos los espines (por defecto) comienzan en su estado «abajo», es decir, se encuentran en la denominada fase ferromagnética. Con la mirada puesta en nuestro objetivo de preparar la fase antiferromagnética, especificamos un campo de excitación coherente dependiente del tiempo que hace que los espines pasen suavemente de este estado a un estado de muchos cuerpos en el que se prefieren los estados «arriba». El hamiltoniano correspondiente se puede escribir como: ![\[Ecuación matemática que representa el cálculo de una función de accionamiento hamiltoniano.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/HDrive.png) donde Ω(t),ϕ(t),Δ(t) son la amplitud global dependiente del tiempo (también conocida como [frecuencia de Rabi](https://en.wikipedia.org/wiki/Rabi_frequency)), la fase y la desintonización del campo de accionamiento que afecta a todos los espines de manera uniforme. Aquí, S−,k​=∣↓k​⟩⟨↑k​∣and S\$1,k​​=(S−,k​)†=∣↑k​⟩⟨↓k​∣son los operadores de bajada y subida del espín k, respectivamente, y nk​=∣↑k​⟩⟨↑k​∣es el mismo operador que antes. La parte Ω del campo de accionamiento acopla de forma coherente los estados «abajo» y «arriba» de todos los espines simultáneamente, mientras que la parte Δ controla la recompensa energética para los estados «arriba». Para programar una transición suave de la fase ferromagnética a la fase antiferromagnética, especificamos el campo de excitación con el siguiente código. ``` 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 ) ``` Podemos visualizar la serie temporal del campo de accionamiento con el siguiente 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 ``` ![\[Tres gráficos que muestran phi, delta y omega a lo largo del tiempo. La subgráfica superior muestra el crecimiento justo por encima de 6, rads/s donde permanece durante 4 segundos hasta que vuelve a caer a 0. El subgráfico del medio muestra el crecimiento lineal asociado de la derivada, y el subgráfico inferior ilustra una línea plana cercana a cero.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/DrivingTimeSeries.png) ## Programa de AHS El registro, el campo de accionamiento (y las interacciones implícitas de van der Waals) conforman el programa de simulación hamiltoniana analógica `ahs_program`. ``` from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation ahs_program = AnalogHamiltonianSimulation( register=register, hamiltonian=drive ) ``` ## Ejecución en un simulador local Dado que este ejemplo es pequeño (menos de 15 espines), antes de ejecutarlo en una QPU compatible con AHS, podemos ejecutarlo en el simulador AHS local que viene con el SDK de Braket. Puesto que el simulador local está disponible de forma gratuita con el SDK de Braket, esta es la mejor práctica para garantizar que nuestro código se ejecute correctamente. Aquí, podemos establecer el número de shots en un valor alto (por ejemplo, 1 millón) porque el simulador local realiza un rastreo de la evolución temporal del estado cuántico y extrae muestras del estado final; por lo tanto, al aumentar el número de shots, el tiempo total de ejecución solo aumenta ligeramente. ``` from braket.devices import LocalSimulator device = LocalSimulator("braket_ahs") result_simulator = device.run( ahs_program, shots=1_000_000 ).result() # Takes about 5 seconds ``` ## Análisis de resultados de simuladores Podemos agregar los resultados de los lanzamientos con la siguiente función que infiere el estado de cada espín (que puede ser «d» para «abajo», «u» para «arriba» o «e» para sitio vacío) y cuenta cuántas veces se produjo cada configuración en los shots. ``` 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, ...} ``` Este `counts` es un diccionario que cuenta el número de veces que se observa cada configuración de estado en los shots. También podemos visualizarlos con el siguiente código. ``` 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) ``` ![\[Gráfico de barras que muestra un gran número de shots sin configuraciones de estados «arriba» adyacentes.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/AHSCounts1.png) ![\[Gráfico de barras que muestra los shots de algunas configuraciones de estados «arriba» vecinos, con 4 estados a 1,0 shots.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/AHSCounts2.png) A partir de los gráficos, podemos extraer las siguientes observaciones que confirman que hemos preparado correctamente la fase antiferromagnética. 1. Por lo general, los estados no bloqueados (en los que no hay dos espines vecinos en estado «arriba») son más comunes que los estados en los que al menos un par de espines vecinos se encuentran ambos en estado «arriba». 1. Normalmente, se prefieren los estados con más excitaciones «arriba», a menos que la configuración esté bloqueada. 1. Los estados más comunes son, de hecho, los estados antiferromagnéticos perfectos `"dudududu"` y `"udududud"`. 1. Los segundos estados más comunes son aquellos en los que solo hay tres excitaciones «arriba» con separaciones consecutivas de 1, 2, 2. Esto demuestra que la interacción de van der Waals también afecta (aunque en menor medida) a los vecinos más cercanos. ## Se ejecuta en la QuEra QPU Aquila **Requisitos previos**: además de instalar el [SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) de Braket con pip, si es nuevo en Amazon Braket, asegúrese de haber completado los [pasos de introducción](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html). **nota** Si utiliza una instancia de cuaderno alojada en Braket, el SDK de Braket viene preinstalado con la instancia. Con todas las dependencias instaladas, podemos conectarnos a la QPU de Aquila. ``` from braket.aws import AwsDevice aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila") ``` Para que nuestro programa de AHS sea adecuado para la máquina de QuEra, necesitamos redondear todos los valores para que cumplan con los niveles de precisión permitidos por la QPU de Aquila. (Estos requisitos se rigen por los parámetros del dispositivo con «Resolución» en su nombre. Podemos verlos al ejecutar `aquila_qpu.properties.dict()` en un cuaderno. Para obtener más detalles sobre las capacidades y requisitos de Aquila, consulte el cuaderno [Introducción a Aquila](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb)). Podemos hacerlo llamando al método `discretize`. ``` discretized_ahs_program = ahs_program.discretize(aquila_qpu) ``` Ahora podemos ejecutar el programa (ejecutando solo 100 shots de momento) en la QPU de Aquila. **nota** La ejecución de este programa en el procesador Aquila tendrá un costo. El SDK de Amazon Braket incluye un [Rastreador de costos](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/) que permite a los clientes establecer límites de costos y realizar el seguimiento de sus costos casi en tiempo real. ``` 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 ``` Debido a la gran variación en el tiempo que puede tardar en ejecutarse una tarea cuántica (dependiendo de los periodos de disponibilidad y la utilización de la QPU), es recomendable anotar el ARN de la tarea cuántica, para poder comprobar su estado más adelante con el siguiente fragmento de código. ``` # 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 vez que el estado sea COMPLETADO (lo cual también se puede comprobar desde la página de tareas cuánticas de la [consola](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks) de Amazon Braket), podemos consultar los resultados con: ``` result_aquila = task.result() ``` ## Análisis de los resultados de la QPU Usando las mismas funciones `get_counts` que antes, podemos computar los recuentos: ``` counts_aquila = get_counts(result_aquila) print(counts_aquila) ``` ``` *[Output]* {'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...} ``` y representarlos gráficamente con `plot_counts`: ``` plot_counts(counts_aquila) ``` ![\[Gráfico de barras que muestra un gran número de shots sin configuraciones de estados «arriba» adyacentes.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/QPUPlotCounts1.png) ![\[Gráfico de barras que muestra los shots de algunas configuraciones de estados «arriba» vecinos, con 4 estados a 1,0 shots.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/QPUPlotCounts2.png) Tenga en cuenta que una pequeña fracción de los shots tiene sitios vacíos (marcados con una «e»). Esto se debe a que la QPU de Aquila presenta imperfecciones en la preparación de un 1-2 % por átomo. Además, los resultados coinciden con los de la simulación dentro de la fluctuación estadística esperada debido al reducido número de shots. ## Siguientes pasos Enhorabuena, ya ha ejecutado su primera carga de trabajo de AHS en Amazon Braket con el simulador AHS local y la QPU de Aquila. Para obtener más información sobre la física de Rydberg, la simulación hamiltoniana analógica y el dispositivo Aquila, consulte nuestros [cuadernos de ejemplos](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation). # Envíe un programa analógico con Aquila QuEra Esta página incluye documentación completa sobre las capacidades de la máquina Aquila de QuEra. Los detalles que se tratan aquí son los siguientes: 1. El hamiltoniano parametrizado simulado por Aquila 1. Parámetros del programa de AHS 1. Contenido de resultados de AHS 1. Parámetro de capacidades de Aquila **Topics** + [Hamiltoniano](#braket-quera-aquila-device-hamiltonian) + [Esquema del programa de AHS de Braket](#braket-quera-ahs-program-schema) + [Esquema de resultados de tareas de AHS de Braket](#braket-quera-ahs-task-result-schema) + [QuEra esquema de propiedades del dispositivo](#braket-quera-device-properties-schema) ## Hamiltoniano La máquina Aquila de QuEra simula el siguiente hamiltoniano (dependiente del tiempo) de forma nativa: ![\[Ecuación matemática con sumas que representan el hamiltoniano de un sistema e incluye términos de accionamiento, desintonización local y acoplamiento entre puntos.\]](http://docs.aws.amazon.com/es_es/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png) **nota** El acceso a la desintonización local es una [capacidad experimental](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html) y está disponible previa solicitud a través de Braket Direct. donde + Hdrive,k​(t)=( 1/2 ​Ω(t)eiϕ(t)S−,k​ \$1 1/2 ​Ω(t)e−iϕ(t) S\$1,k​) \$1 (−Δglobal​(t)nk​), + Ω(t) es la amplitud de excitación global dependiente del tiempo (también conocida como frecuencia de Rabi), en unidades de (rad / s) + φ (t) es la fase global dependiente del tiempo, medida en radianes + S−,k​ y S\$1,k​ son los operadores de reducción y aumento del espín del átomo k (en la base \$1↓⟩=\$1g⟩, \$1↑⟩=\$1r⟩, son S−​=\$1g⟩⟨r\$1, S\$1​=(S−​)†=\$1r⟩⟨g\$1) + Δglobal​(t) es la desintonización global dependiente del tiempo + nk es el operador de proyección sobre el estado de Rydberg del átomo k (es decir, n=\$1r⟩⟨r\$1) + Hlocal detuning,k(t)=-Δlocal(t)hknk + Δlocal(t) es el factor dependiente del tiempo del desplazamiento de frecuencia local, en unidades de (rad / s) + hk es el factor dependiente del emplazamiento, un número adimensional entre 0,0 y 1,0 + Vvdw,k,l​=C6​/(dk,l​)6nk​nl​, + C6​ es el coeficiente de van der Waals en unidades de (rad / s) \$1 (m)^6 + dk,l es la distancia euclidiana entre los átomos k y l, medida en metros. Los usuarios tienen control sobre los siguientes parámetros a través del esquema del programa de AHS de Braket. + Disposición de átomos en 2-d (coordenadas xk e yk de cada átomo k, en unidades de um), que controla las distancias atómicas por pares dk,l​ con k,l=1,2,…N + Ω(t), la frecuencia Rabi global dependiente del tiempo en unidades de (rad / s) + ϕ(t), la fase global dependiente del tiempo en unidades de (rad) + Δglobal​(t), la desintonización global dependiente del tiempo en unidades de (rad / s) + Δlocal(t), el factor (global) dependiente del tiempo de la magnitud de la desintonización local en unidades de (rad / s) + hk, el factor (estático) dependiente del emplazamiento de la magnitud de la desintonización local, un número adimensional entre 0,0 y 1,0 **nota** El usuario no puede controlar qué niveles intervienen (es decir, los operadores S−, S\$1​ y n son fijos) ni la intensidad del coeficiente de interacción Rydberg-Rydberg (C6). ## Esquema del programa de AHS de Braket **Objeto braket.ir.ahs.program\$1v1.Program** (ejemplo) **nota** Si la característica [desintonización local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) no está habilitada para su cuenta, use `localDetuning=[]` en el siguiente ejemplo. ``` 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** (ejemplo) **nota** Si la característica [desintonización local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) no está habilitada para su cuenta, use `"localDetuning": []` en el siguiente ejemplo. ``` { "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] } } ] } } ``` **Campos principales** | Campo de programa | type | description | | --- | --- | --- | | setup.ahs\$1register.sites | List[List[Decimal]] | Lista de coordenadas 2-d donde las pinzas atrapan átomos | | setup.ahs\$1register.filling | List[int] | Marca los átomos que ocupan los emplazamientos de la trampa con 1 y los emplazamientos vacíos con 0 | | hamiltonian.drivingFields[].amplitude.time\$1series.times | List[Decimal] | puntos temporales de la amplitud de accionamiento, Omega(t) | | hamiltonian.drivingFields[].amplitude.time\$1series.values | List[Decimal] | valores de la amplitud de accionamiento, Omega(t) | | hamiltonian.drivingFields[].amplitude.pattern | str | patrón espacial de la amplitud de conducción, Omega(t); debe ser «uniform» | | hamiltonian.drivingFields[].phase.time\$1series.times | List[Decimal] | puntos temporales de la fase de accionamiento, phi(t) | | hamiltonian.drivingFields[].phase.time\$1series.values | List[Decimal] | valores de la fase de accionamiento, phi(t) | | hamiltonian.drivingFields[].phase.pattern | str | patrón espacial de la fase de accionamiento, phi(t); debe ser «uniform» | | hamiltonian.drivingFields[].detuning.time\$1series.times | List[Decimal] | puntos temporales de desintonización de accionamiento, Delta\$1global(t) | | hamiltonian.drivingFields[].detuning.time\$1series.values | List[Decimal] | valores de desintonización de accionamiento, Delta\$1global(t) | | hamiltonian.drivingFields[].detuning.pattern | str | patrón espacial de desintonización de conducción, Delta\$1global(t); debe ser «uniforme» | | hamiltonian.localDetuning[].magnitude.time\$1series.times | List[Decimal] | puntos temporales del factor dependiente del tiempo de la magnitud de desintonización local, Delta\$1local(t) | | hamiltonian.localDetuning[].magnitude.time\$1series.values | List[Decimal] | valores del factor dependiente del tiempo de la magnitud de desintonización local, Delta\$1local(t) | | hamiltonian.localDetuning[].magnitude.pattern | List[Decimal] | factor dependiente del emplazamiento de la magnitud de desintonización local, h\$1k (los valores corresponden a los emplazamientos en setup.ahs\$1register.sites) | **Campos de metadatos** | Campo de programa | type | description | | --- | --- | --- | | braketSchemaHeader.name | str | nombre del esquema; debe ser «braket.ir.ahs.program» | | braketSchemaHeader.versión | str | versión del esquema | ## Esquema de resultados de tareas de AHS de Braket **braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result. AnalogHamiltonianSimulationQuantumTaskResult**(ejemplo) ``` 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** (ejemplo) ``` { "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 } } } ``` **Campos principales** | Campo de resultados de la tarea | type | description | | --- | --- | --- | | measurements[].shotResult.preSequence | List[int] | Bits de medición previos a la secuencia (uno por cada emplazamiento atómico) para cada shot: 0 si el emplazamiento está vacío, 1 si el emplazamiento está lleno, medidos antes de las secuencias de pulsos que ejecutan la evolución cuántica | | measurements[].shotResult.postSequence | List[int] | Bits de medición posteriores a la secuencia para cada shot: 0 si el átomo se encuentra en estado de Rydberg o el emplazamiento está vacío, 1 si el átomo se encuentra en estado fundamental, medido al final de las secuencias de pulsos que ejecutan la evolución cuántica | **Campos de metadatos** | Campo de resultados de la tarea | type | description | | --- | --- | --- | | braketSchemaHeader.name | str | nombre del esquema; debe ser «braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result» | | braketSchemaHeader.versión | str | versión del esquema | | Metadatos de tareas. braketSchemaHeader.nombre | str | nombre del esquema; debe ser «braket.task\$1result.task\$1metadata» | | Metadatos de la tarea. braketSchemaHeader.versión | str | versión del esquema | | taskMetadata.id | str | El ID de la tarea cuántica. Para las tareas AWS cuánticas, esta es la tarea cuántica ARN. | | taskMetadata.shots | int | El número de shots de la tarea cuántica | | taskMetadata.shots.deviceId | str | El ID del dispositivo en el que se ejecutó la tarea cuántica. Para AWS los dispositivos, este es el ARN del dispositivo. | | taskMetadata.shots.createdAt | str | La marca de tiempo de la creación; el formato debe estar en el formato RFC3339 ISO-8601/ de cadena: MM:SS.SSSZ. YYYY-MM-DDTHH El valor predeterminado es Ninguno. | | taskMetadata.shots.endedAt | str | La marca de tiempo en la que finalizó la tarea cuántica; el formato debe estar en el formato ISO-8601/ de cadena: MM:SS.SSSZ. RFC3339 YYYY-MM-DDTHH El valor predeterminado es Ninguno. | | taskMetadata.shots.status | str | El estado de la tarea cuántica (CREADA, EN COLA, EN EJECUCIÓN, COMPLETADA, FALLIDA). El valor predeterminado es Ninguno. | | taskMetadata.shots.failureReason | str | El motivo del error de la tarea cuántica. El valor predeterminado es Ninguno. | | additionalMetadata.action | braket.ir.ahs.program\$1v1.Program | (Consulte la sección [Esquema del programa de AHS de Braket](#braket-quera-ahs-program-schema)) | | Metadatos adicionales. Acción. braketSchemaHeaderMetadatos.Nombre de quera.Metadatos | str | nombre del esquema; debe ser «braket.task\$1result.quera\$1metadata» | | Metadatos adicionales. Acción. braketSchemaHeader.Quera Metadata.Versión | str | versión del esquema | | Metadatos adicionales. Acción. numSuccessfulShots | int | número de shots totalmente de éxito; debe ser igual al número de shots solicitado | | measurements[].shotMetadata.shotStatus | int | El estado del shot (éxito, éxito parcial, fracaso) debe ser «Éxito». | ## QuEra esquema de propiedades del dispositivo **braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1. QueraDeviceCapabilities**(ejemplo) ``` 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** (ejemplo) ``` { "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 ... } } ``` **Campos de propiedades de servicio** | Campos de propiedades de servicio | type | description | | --- | --- | --- | | service.executionWindows[].executionDay | ExecutionDay | Días del periodo de ejecución; debe ser «Todos los días», «Días laborables», «Fin de semana», «Lunes», «Martes», «Miércoles», «Jueves», «Viernes», «Sábado» o «Domingo» | | Service.ExecutionWindows []. windowStartHour | datetime.time | Formato UTC de 24 horas de la hora en que comienza el periodo de ejecución | | Service.ExecutionWindows []. windowEndHour | datetime.time | Formato UTC de 24 horas de la hora en que finaliza el periodo de ejecución | | service.qpu\$1capabilities.service.shotsRange | Tuple[int, int] | Número mínimo y máximo de shots del dispositivo | | service.qpu\$1capabilities.service.deviceCost.price | float | Precio del dispositivo en dólares estadounidenses | | service.qpu\$1capabilities.service.deviceCost.unit | str | unidad para cobrar el precio, por ejemplo: «minuto», «hora», «disparo», «tarea» | **Campos de metadatos** | Campo de metadatos | type | description | | --- | --- | --- | | action[].version | str | versión del esquema del programa de AHS | | action[].actionType | ActionType | nombre del esquema del programa de AHS; debe ser «braket.ir.ahs.program» | | servicio. braketSchemaHeader.nombre | str | nombre del esquema; debe ser «braket.device\$1schema.device\$1service\$1properties» | | servicio. braketSchemaHeader.versión | str | versión del esquema | | service.deviceDocumentation.imageUrl | str | URL de la imagen del dispositivo | | service.deviceDocumentation.summary | str | breve descripción del dispositivo | | Servicio. Documentación del dispositivo. externalDocumentationUrl | str | URL de documentación externa | | service.deviceLocation | str | ubicación geográfica del dispositivo | | service.updatedAt | datetime | hora en que se actualizaron las propiedades del dispositivo por última vez |