As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Simulação hamiltoniana analógica A [Simulação Hamiltoniana Analógica (AHS)](https://en.wikipedia.org/wiki/Hamiltonian_simulation) é um paradigma emergente na computação quântica que difere significativamente do modelo tradicional de circuito quântico. Em vez de uma sequência de portas, em que cada circuito atua apenas em alguns qubits por vez. Um programa AHS é definido pelos parâmetros dependentes do tempo e do espaço do hamiltoniano em questão. O [hamiltoniano de um sistema](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics)) codifica seus níveis de energia e os efeitos das forças externas, que juntas governam a evolução temporal de seus estados. Para um sistema de N qubits, o hamiltoniano pode ser representado por uma matriz quadrada de 2NX2N de números complexos. Os dispositivos quânticos capazes de realizar AHS são projetados para aproximar de perto a evolução temporal de um sistema quântico sob um hamiltoniano personalizado, ajustando cuidadosamente seus parâmetros de controle interno. Por exemplo, ajustar a amplitude e os parâmetros de desajuste de um campo de condução coerente. O paradigma AHS é adequado para simular as propriedades estáticas e dinâmicas de sistemas quânticos com muitas partículas em interação, como na física da matéria condensada ou na química quântica. Unidades de processamento quântico (QPUs) criadas especificamente, como o [dispositivo Aquila](https://aws.amazon.com/braket/quantum-computers/quera/) daQuEra, foram desenvolvidas para usar o poder do AHS e resolver problemas além do alcance das abordagens convencionais de computação quântica digital de maneiras inovadoras. **Topics** + [Olá AHS: Execute sua primeira simulação hamiltoniana analógica](braket-get-started-hello-ahs.md) + [Envie um programa analógico usando Aquila QuEra](braket-quera-submitting-analog-program-aquila.md) # Olá AHS: Execute sua primeira simulação hamiltoniana analógica Esta seção fornece informações sobre como executar sua primeira simulação hamiltoniana analógica. **Topics** + [Cadeia de rotação interativa](#braket-get-started-interacting-spin-chain) + [Arranjo](#braket-get-started-arrangement) + [Interação](#braket-get-started-interaction) + [Campo de condução](#braket-get-started-driving-field) + [Programa AHS](#braket-get-started-ahs-program) + [Executando no simulador local](#braket-get-started-running-local-simulator) + [Analisar resultados de simulação](#braket-get-started-analyzing-simulator-results) + [Executando no QuEra Aquila QPU](#braket-get-started-running-aquila-qpu) + [Analisando os resultados da QPU](#braket-get-started-analyzing-qpu-results) + [Próximas etapas](#braket-get-started-ahs-next) ## Cadeia de rotação interativa Para um exemplo canônico de um sistema de muitas partículas interagindo, vamos considerar um anel de oito giros (cada um dos quais pode estar nos estados “para cima” ⟩ e “para baixo” ↓⟩). Embora pequeno, esse sistema modelo já exibe um punhado de fenômenos interessantes de materiais magnéticos que ocorrem naturalmente. Neste exemplo, mostraremos como preparar a chamada ordem antiferromagnética, em que giros consecutivos apontam em direções opostas. ![\[Diagrama conectando 8 nós circulares que contêm setas invertidas para cima e para baixo.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/AntiFerromagnetic.png) ## Arranjo Usaremos um átomo neutro para representar cada spin, e os estados de spin “para cima” e “para baixo” serão codificados no estado excitado de Rydberg e no estado fundamental dos átomos, respectivamente. Primeiro, criaremos o arranjo 2-d. Podemos programar o anel de giros acima com o código a seguir. **Pré-requisitos**: Você precisa instalar pip o [SDK do Braket.](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) (Se você estiver usando uma instância de caderno hospedada no Braket, esse SDK vem pré-instalado com os cadernos.) Para reproduzir os gráficos, você também precisa instalar separadamente o matplotlib com o 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) ``` com o qual também podemos traçar ``` 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 dispersão mostrando pontos distribuídos entre valores positivos e negativos em ambos os eixos.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/PlotNeutralAtoms.png) ## Interação Para preparar a fase antiferromagnética, precisamos induzir interações entre spins vizinhos. Usamos a [interação van der Waals](https://en.wikipedia.org/wiki/Van_der_Waals_force) para isso, que é implementada nativamente por dispositivos de átomos neutros (como o dispositivo Aquila de QuEra). Usando a representação de spin, o termo hamiltoniano para essa interação pode ser expresso como uma soma de todos os pares de spin (j, k). ![\[Equação de interação hamiltoniana mostrando essa interação expressa como uma soma de todos os pares de spin (j, k).\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/HInteraction.png) Aqui, nj=↑ j ⟨↑ j é um operador que assume o valor de 1 somente se o spin j estiver no estado “ativo” e 0 caso contrário. A força é V j,k =C6/(dj,k​) 6, onde C 6 é o coeficiente fixo e d j,k é a distância euclidiana entre os spins j e k. O efeito imediato desse termo de interação é que qualquer estado em que o spin j e o spin k estejam “para cima” tem energia elevada (na quantidade Vj,k). Ao projetar cuidadosamente o resto do programa AHS, essa interação evitará que ambas as rodadas vizinhas fiquem no estado “ativo”, um efeito comumente conhecido como “bloqueio de Rydberg”. ## Campo de condução No início do programa AHS, todos os giros (por padrão) começam em seu estado “inativo”, eles estão na chamada fase ferromagnética. De olho em nosso objetivo de preparar a fase antiferromagnética, especificamos um campo de condução coerente dependente do tempo que faz a transição suave dos giros desse estado para um estado de muitos corpos, onde os estados “ascendentes” são preferidos. O hamiltoniano correspondente pode ser escrito como ![\[Equação matemática que descreve o cálculo de uma função de acionamento hamiltoniana.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/HDrive.png) onde Ω (t), θ (t), Δ (t) são a amplitude global dependente do tempo (também conhecida como [frequência Rabi](https://en.wikipedia.org/wiki/Rabi_frequency)), a fase e o desajuste do campo de direção, afetando todos os giros de maneira uniforme. Aqui, S−,k​=∣↓k​⟩⟨↑k​∣e S\$1,k​​=(S−,k​)†=∣↑k​⟩⟨↓k​∣ são os operadores de abaixamento e elevação do spin k, respectivamente, e nk​=∣↑k​⟩⟨↑k​∣é o mesmo operador de antes. A parte Ω do campo de condução acopla coerentemente os estados “para baixo” e “para cima” de todos os giros simultaneamente, enquanto a parte Δ controla a recompensa de energia para os estados “para cima”. Para programar uma transição suave da fase ferromagnética para a fase antiferromagnética, especificamos o campo de condução com o código a seguir. ``` 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 a série temporal do campo de condução com o seguinte 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 ``` ![\[Três gráficos mostrando phi, delta e ômega ao longo do tempo. O subgráfico superior mostra o crescimento até um pouco acima de 6, rads/s onde permanece por 4 segundos até cair de volta para 0. O subgráfico central mostra o crescimento linear associado da derivada, e o subgráfico inferior ilustra uma linha plana próxima de zero.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/DrivingTimeSeries.png) ## Programa AHS O registro, o campo motriz (e as interações implícitas de van der Waals) compõem o programa de simulação hamiltoniana analógica `ahs_program`. ``` from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation ahs_program = AnalogHamiltonianSimulation( register=register, hamiltonian=drive ) ``` ## Executando no simulador local Como esse exemplo é pequeno (menos de 15 rodadas), antes de executá-lo em uma QPU compatível com AHS, podemos executá-lo no simulador AHS local que vem com o SDK Braket. Como o simulador local está disponível gratuitamente com o SDK do Braket, essa é a melhor prática para garantir que nosso código possa ser executado corretamente. Aqui, podemos definir o número de fotos para um valor alto (digamos, 1 milhão) porque o simulador local rastreia a evolução temporal do estado quântico e extrai amostras do estado final; portanto, aumenta o número de fotos e aumenta o runtime total apenas 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 ``` ## Analisar resultados de simulação Podemos agregar os resultados da captura com a seguinte função que infere o estado de cada rotação (que pode ser “d” para “para baixo”, “u” para “para cima” ou “e” para local vazio) e conta quantas vezes cada configuração ocorreu nas fotos. ``` 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, ...} ``` Aqui `counts` está um dicionário que conta o número de vezes que cada configuração de estado é observada nas fotos. Também podemos visualizá-los com o código a seguir. ``` 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 mostrando um grande número de fotos sem configurações vizinhas de estados “ativos”.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/AHSCounts1.png) ![\[Gráfico de barras mostrando fotos de algumas configurações de estados “ativos” vizinhos, com 4 estados em 1,0 fotos.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/AHSCounts2.png) A partir dos gráficos, podemos ler as seguintes observações para verificar se preparamos com sucesso a fase antiferromagnética. 1. Geralmente, estados sem bloqueio (onde não há dois giros vizinhos no estado “ativo”) são mais comuns do que estados em que pelo menos um par de giros vizinhos está no estado “ativo”. 1. Geralmente, estados com mais excitações “ascendentes” são favorecidos, a menos que a configuração esteja bloqueada. 1. Os estados mais comuns são, de fato, os estados antiferromagnéticos perfeitos `"dudududu"` e `"udududud"`. 1. Os segundos estados mais comuns são aqueles em que há apenas 3 excitações “ascendentes” com separações consecutivas de 1, 2, 2. Isso mostra que a interação de van der Waals também afeta (embora muito menor) os vizinhos mais próximos. ## Executando no QuEra Aquila QPU **Pré-requisitos**: Além da instalação rápida do [SDK](https://github.com/aws/amazon-braket-sdk-python#installing-the-amazon-braket-python-sdk) do Braket, se você for novo no Amazon Braket, certifique-se de ter concluído as etapas necessárias do [Passos para começar](https://docs.aws.amazon.com/braket/latest/developerguide/braket-get-started.html). **nota** Se você estiver usando uma instância de caderno hospedada no Braket, o SDK do Braket vem pré-instalado com a instância. Com todas as dependências instaladas, podemos nos conectar à QPU Aquila. ``` from braket.aws import AwsDevice aquila_qpu = AwsDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila") ``` Para tornar nosso programa AHS adequado para a máquina QuEra, precisamos arredondar todos os valores para cumprir os níveis de precisão permitidos pela QPU Aquila. Esses requisitos são regidos pelos parâmetros do dispositivo com “Resolução” no nome. Podemos vê-los executando `aquila_qpu.properties.dict()` em um caderno. Para obter mais detalhes sobre os recursos e requisitos do Aquila, consulte a [Introdução ao caderno Aquila](https://github.com/aws/amazon-braket-examples/blob/main/examples/analog_hamiltonian_simulation/01_Introduction_to_Aquila.ipynb). Podemos fazer isso chamando o método `discretize`. ``` discretized_ahs_program = ahs_program.discretize(aquila_qpu) ``` Agora podemos executar o programa (executando apenas 100 fotos por enquanto) na QPU Aquila. **nota** A execução desse programa no processador Aquila acarretará um custo. O Amazon Braket SDK inclui [um rastreador de custos](https://aws.amazon.com/blogs/quantum-computing/managing-the-cost-of-your-experiments-in-amazon-braket/) que permite aos clientes definir limites de custo e monitorar seus custos quase em tempo 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 ``` Devido à grande variação de quanto tempo uma tarefa quântica pode levar para ser executada (dependendo das janelas de disponibilidade e da utilização da QPU), é uma boa ideia anotar o ARN da tarefa quântica, para que possamos verificar seu status posteriormente com o seguinte trecho 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 ``` Depois que o status for CONCLUÍDO (o que também pode ser verificado na página de tarefas quânticas do [console](https://us-east-1.console.aws.amazon.com/braket/home?region=us-east-1#/tasks) Amazon Braket), podemos consultar os resultados com: ``` result_aquila = task.result() ``` ## Analisando os resultados da QPU Usando as mesmas funções `get_counts` de antes, podemos calcular as contagens: ``` counts_aquila = get_counts(result_aquila) print(counts_aquila) ``` ``` *[Output]* {'dddududd': 2, 'dudududu': 18, 'ddududud': 4, ...} ``` e plote-os com `plot_counts`: ``` plot_counts(counts_aquila) ``` ![\[Gráfico de barras mostrando um grande número de fotos sem configurações vizinhas de estados “ativos”.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/QPUPlotCounts1.png) ![\[Gráfico de barras mostrando fotos de algumas configurações de estados “ativos” vizinhos, com 4 estados em 1,0 fotos.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/QPUPlotCounts2.png) Observe que uma pequena fração das fotos tem locais vazios (marcados com “e”). Isso se deve a imperfeições de 1 a 2% por átomo na preparação do QPU Aquila. Além disso, os resultados coincidem com a simulação dentro da flutuação estatística esperada devido ao pequeno número de disparos. ## Próximas etapas Parabéns, agora você executou sua primeira workload de AHS no Amazon Braket usando o simulador AHS local e a QPU Aquila. Para saber mais sobre a física de Rydberg, a simulação hamiltoniana analógica e o dispositivo Aquila, consulte nossos [exemplos de cadernos](https://github.com/aws/amazon-braket-examples/tree/main/examples/analog_hamiltonian_simulation). # Envie um programa analógico usando Aquila QuEra Esta página fornece uma documentação abrangente sobre os recursos da máquina Aquila a partir de QuEra. Os detalhes abordados aqui são os seguintes: 1. O hamiltoniano parametrizado simulado por Aquila 1. Parâmetros do programa AHS 1. Conteúdo do resultado do AHS 1. Parâmetro de capacidades Aquila **Topics** + [Hamiltoniano](#braket-quera-aquila-device-hamiltonian) + [Esquema do programa Braket AHS](#braket-quera-ahs-program-schema) + [Esquema de resultados de tarefas do Braket AHS](#braket-quera-ahs-task-result-schema) + [QuEra esquema de propriedades do dispositivo](#braket-quera-device-properties-schema) ## Hamiltoniano A máquina Aquila do QuEra simula o seguinte hamiltoniano (dependente do tempo) nativamente. ![\[Equação matemática com somatórios representando o hamiltoniano de um sistema, envolvendo termos de acionamento, desajuste local e acoplamento entre pontos.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/TimeDependentDrivingHamiltonian.png) **nota** O acesso ao desajuste local é um [recurso experimental](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html) e está disponível mediante solicitação por meio do Braket Direct. para onde + 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) é a amplitude de condução global dependente do tempo (também conhecida como frequência Rabi), em unidades de (rad/s) + θ (t) é a fase global dependente do tempo, medida em radianos + S−,k​ e S\$1,k​ são os operadores de redução e aumento de spin do átomo k (na base \$1↓⟩=\$1g⟩, \$1↑⟩=\$1r⟩, são S−​=\$1g⟩⟨r\$1, S\$1​=(S−​)†=\$1r⟩⟨g\$1) + Δ global (t) é o desajuste global dependente do tempo + n k é o operador de projeção no estado de Rydberg do átomo k (ou seja, n=\$1r⟨r\$1) + H local detuning,k (t) =-Δ local (t) h n k k + Δ local (t) é o fator dependente do tempo da mudança de frequência local, em unidades de (rad/s) + h k é o fator dependente do local, um número adimensional entre 0,0 e 1,0 + Vvdw,k,l​=C6​/(dk,l​)6nk​nl​, + C6 é o coeficiente de van der Waals, em unidades de (rad/s) \$1 (m) ^6 + dk,l é a distância euclidiana entre os átomos k e l, medida em metros. Os usuários têm controle sobre os seguintes parâmetros por meio do esquema do programa Braket AHS. + Arranjo de átomos 2-d (coordenadas xk​ e yk​ de cada átomo k, em unidade de um), que controla as distâncias atômicas entre pares dk,l​ com k,l=1,2,…N + Ω (t), a frequência Rabi global dependente do tempo, em unidades de (rad/ s) + θ (t), a fase global dependente do tempo, em unidades de (rad) + Δ global (t), o desajuste global dependente do tempo, em unidades de (rad/ s) + Δ local (t), o fator (global) dependente do tempo da magnitude do desajuste local, em unidades de (rad/ s) + hk, o fator (estático) dependente do local da magnitude do desajuste local, um número adimensional entre 0,0 e 1,0 **nota** O usuário não pode controlar quais níveis estão envolvidos. (ou seja, operadores S−​,S\$1​, n são fixos) nem a intensidade do coeficiente de interação Rydberg-Rydberg (C6​). ## Esquema do programa Braket AHS **braket.ir.ahs.program\$1v1.Program object** (exemplo) **nota** Se o recurso de [desajuste local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) não estiver habilitado para sua conta, use `localDetuning=[]` no exemplo a seguir. ``` 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** (exemplo) **nota** Se o recurso de [desajuste local](https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html#braket-access-local-detuning) não estiver habilitado para sua conta, use `"localDetuning": []` no exemplo a seguir. ``` { "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] } } ] } } ``` **Principais campos** | Campo do programa | type | descrição | | --- | --- | --- | | setup.ahs\$1register.sites | Lista [Lista [Decimal]] | Lista de coordenadas 2-d em que as pinças capturam átomos | | setup.ahs\$1register.filling | List[int] | Marca os átomos que ocupam os locais da armadilha com 1 e os locais vazios com 0 | | hamiltonian.drivingFields[].amplitude.time\$1series.times | List[Decimal] | pontos de tempo da amplitude de condução, Omega (t) | | hamiltonian.drivingFields[].amplitude.time\$1series.values | List[Decimal] | valores de amplitude de condução, Omega (t) | | hamiltonian.drivingFields[].amplitude.pattern | str | padrão espacial de amplitude de condução, Omega (t); deve ser “uniforme” | | hamiltonian.drivingFields[].phase.time\$1series.times | List[Decimal] | pontos temporais da fase de condução, phi (t) | | hamiltonian.drivingFields[].phase.time\$1series.values | List[Decimal] | valores da fase de condução, phi (t) | | hamiltonian.drivingFields[].phase.pattern | str | padrão espacial da fase de condução, phi (t); deve ser “uniforme” | | hamiltonian.drivingFields[].detuning.time\$1series.times | List[Decimal] | pontos temporais de desajuste, Delta\$1global(t) | | hamiltonian.drivingFields[].detuning.time\$1series.values | List[Decimal] | valores do desajuste de direção, Delta\$1global(t) | | hamiltonian.drivingFields[].detuning.pattern | str | padrão espacial de desajuste de direção, Delta\$1global(t); deve ser 'uniforme' | | hamiltonian.localDetuning[].magnitude.time\$1series.times | List[Decimal] | pontos temporais do fator dependente do tempo da magnitude de desajuste local, Delta\$1local(t) | | hamiltonian.localDetuning[].magnitude.time\$1series.values | List[Decimal] | valores do fator dependente do tempo da magnitude de desajuste local, Delta\$1local(t) | | hamiltonian.localDetuning[].magnitude.pattern | List[Decimal] | fator dependente do site da magnitude de desajuste local, h\$1k (os valores correspondem aos sites em setup.ahs\$1register.sites) | **Campos de metadados** | Campo do programa | type | descrição | | --- | --- | --- | | braketSchemaHeader.name | str | nome do esquema; deve ser 'braket.ir.ahs.program' | | braketSchemaHeader.versão | str | versão do esquema | ## Esquema de resultados de tarefas do Braket AHS **braket.tasks.analog\$1hamiltonian\$1simulation\$1quantum\$1task\$1result. AnalogHamiltonianSimulationQuantumTaskResult**(exemplo) ``` 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** (exemplo) ``` { "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 } } } ``` **Principais campos** | Campo de resultado da tarefa | type | descrição | | --- | --- | --- | | measurements[].shotResult.preSequence | List[int] | Bits de medição de pré-sequência (um para cada local atômico) para cada disparo: 0 se o local estiver vazio, 1 se o local estiver cheio, medidos antes das sequências de pulsos que executam a evolução quântica | | measurements[].shotResult.postSequence | List[int] | Bits de medição pós-sequência para cada disparo: 0 se o átomo estiver no estado de Rydberg ou o local estiver vazio, 1 se o átomo estiver no estado fundamental, medidos no final das sequências de pulsos que executam a evolução quântica | **Campos de metadados** | Campo de resultado da tarefa | type | descrição | | --- | --- | --- | | braketSchemaHeader.name | str | nome do esquema; deve ser 'braket.task\$1result.analog\$1hamiltonian\$1simulation\$1task\$1result' | | braketSchemaHeader.versão | str | versão do esquema | | Metadados da tarefa. braketSchemaHeader.nome | str | nome do esquema; deve ser 'braket.task\$1result.task\$1metadata' | | Metadados da tarefa. braketSchemaHeader.versão | str | versão do esquema | | taskMetadata.id | str | A identificação da tarefa quântica. Para tarefas AWS quânticas, essa é a tarefa quântica ARN. | | taskMetadata.shots | int | O número de disparos para a tarefa quântica | | taskMetadata.shots.deviceId | str | O ID do dispositivo no qual a tarefa quântica foi executada. Para AWS dispositivos, esse é o ARN do dispositivo. | | taskMetadata.shots.createdAt | str | O carimbo de data/hora da criação; o formato deve estar em ISO-8601/string RFC3339 format:MM:SS.SSSZ. YYYY-MM-DDTHH Padrão é Nenhum. | | taskMetadata.shots.endedAt | str | A data e hora de quando a tarefa quântica terminou; o formato deve estar em ISO-8601/string format:MM:SS.SSSZRFC3339 . YYYY-MM-DDTHH Padrão é Nenhum. | | taskMetadata.shots.status | str | O status da tarefa quântica (CRIADA, ENFILEIRADA, EM EXECUÇÃO, CONCLUÍDA, FALHA). Padrão é Nenhum. | | taskMetadata.shots.failureReason | str | O motivo da falha da tarefa quântica. Padrão é Nenhum. | | additionalMetadata.action | braket.ir.ahs.program\$1v1.Programa | (Consulte a seção [Esquema do programa Braket AHS](#braket-quera-ahs-program-schema)) | | Metadados adicionais. Ação. braketSchemaHeader.querametadata.name | str | nome do esquema; deve ser 'braket.task\$1result.quera\$1metadata' | | Metadados adicionais. Ação. braketSchemaHeader.queraMetadata.Versão | str | versão do esquema | | Metadados adicionais. Ação. numSuccessfulShots | int | número de disparos completamente bem-sucedidos; deve ser igual ao número solicitado de disparos | | measurements[].shotMetadata.shotStatus | int | O status da foto (sucesso, sucesso parcial, falha); deve ser “Sucesso” | ## QuEra esquema de propriedades do dispositivo **braket.device\$1schema.quera.quera\$1device\$1capabilities\$1v1. QueraDeviceCapabilities**(exemplo) ``` 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** (exemplo) ``` { "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 propriedades de serviços** | Campo de propriedades do serviço | type | descrição | | --- | --- | --- | | service.executionWindows[].executionDay | ExecutionDay | Dias da janela de execução; devem ser 'Todos os dias', 'Dias úteis', 'Fim de semana', 'Segunda-feira', 'Terça', 'Quarta', Quinta-feira ',' Sexta ',' Sábado 'ou' Domingo ' | | Service.ExecutionWindows []. windowStartHour | datetime.time | Formato UTC de 24 horas da hora em que a janela de execução começa | | Service.ExecutionWindows []. windowEndHour | datetime.time | Formato UTC de 24 horas da hora em que a janela de execução termina | | service.qpu\$1capabilities.service.shotsRange | Tupla [int, int] | Número mínimo e máximo de fotos para o dispositivo | | service.qpu\$1capabilities.service.deviceCost.price | flutuação | Preço do aparelho em dólares americanos | | service.qpu\$1capabilities.service.deviceCost.unit | str | unidade para cobrar o preço, por exemplo: 'minuto', 'hora', 'tiro', 'tarefa' | **Campos de metadados** | Campos de metadados | type | descrição | | --- | --- | --- | | ação [] .versão | str | versão do esquema do programa AHS | | ação [] .actionType | ActionType | Nome do esquema do programa AHS; deve ser 'braket.ir.ahs.program' | | serviço. braketSchemaHeader.nome | str | nome do esquema; deve ser 'braket.device\$1schema.device\$1service\$1properties' | | serviço. braketSchemaHeader.versão | str | versão do esquema | | service.deviceDocumentation.imageUrl | str | URL para a imagem do dispositivo | | service.deviceDocumentation.summary | str | breve descrição no dispositivo | | Documentação do serviço.dispositivo. externalDocumentationUrl | str | URL de documentação externa | | service.deviceLocation | str | localização geográfica do dispositivo | | service.updatedAt | datetime | hora em que as propriedades do dispositivo foram atualizadas pela última vez |