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á. # Execute seus circuitos com o OpenQASM 3.0 Amazon Braket agora dá suporte ao [OpenQASM 3.0](https://openqasm.com/) para dispositivos e simuladores quânticos baseados em portas. Este guia do usuário fornece informações sobre o subconjunto do OpenQASM 3.0 suportado pelo Braket. Os clientes do Braket agora têm a opção de enviar circuitos Braket com o [SDK](braket-constructing-circuit.md) ou fornecendo diretamente strings OpenQASM 3.0 para todos os dispositivos baseados em portas lógicas com a [Amazon Braket API](https://docs.aws.amazon.com/braket/latest/APIReference/Welcome.html) e o [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python). Os tópicos deste guia explicam vários exemplos de como concluir as seguintes tarefas quânticas. + [Crie e envie tarefas quânticas do OpenQASM em diferentes dispositivos Braket](braket-openqasm-create-submit-task.md) + [Acesse as operações com suporte e os tipos de resultados](braket-openqasm-device-support.md#braket-openqasm-supported-operations-results-result-types) + [Simule ruídos com o OpenQASM](braket-openqasm-noise-simulation.md) + [Use a compilação literal com o OpenQASM](braket-openqasm-verbatim-compilation.md) + [Solucionar problemas do OpenQASM](https://docs.aws.amazon.com/braket/latest/developerguide/braket-troubleshooting-openqasm.html) Este guia também fornece uma introdução a certos recursos específicos de hardware que podem ser implementados com o OpenQASM 3.0 no Braket e links para recursos adicionais. **Topics** + [O que é o OpenQASM 3.0?](#braket-openqasm-what-is) + [Quando usar o OpenQASM 3.0](#braket-openqasm-when-to-use) + [Como o OpenQASM 3.0 funciona](#braket-openqasm-how-it-works) + [Pré-requisitos](#braket-openqasm-prerequisites) + [Quais recursos do OpenQASM o Braket suporta?](braket-openqasm-supported-features.md) + [Crie e envie um exemplo de tarefa quântica do OpenQASM 3.0](braket-openqasm-create-submit-task.md) + [Suporte para OpenQASM em diferentes dispositivos Braket](braket-openqasm-device-support.md) + [Simule ruídos com o OpenQASM 3.0](braket-openqasm-noise-simulation.md) + [Reconexão Qubit com o OpenQASM 3.0](braket-openqasm-rewire-qubits.md) + [Compilação literal com o OpenQASM 3.0](braket-openqasm-verbatim-compilation.md) + [O console do Braket](#braket-openqasm-braket-console) + [Recursos adicionais do](#braket-openqasm-more-resources) + [Gradientes de computação com o OpenQASM 3.0](braket-openqasm-computing-gradients.md) + [Medindo qubits específicos com o OpenQASM 3.0](braket-openqasm-measure-qubits.md) ## O que é o OpenQASM 3.0? A Open Quantum Assembly Language (OpenQASM) é uma [representação intermediária](https://en.wikipedia.org/wiki/Intermediate_representation) para instruções quânticas. O OpenQASM é uma estrutura de código aberto e é amplamente usado para a especificação de programas quânticos para dispositivos baseados em portas. Com o OpenQASM, os usuários podem programar as portas quânticas e as operações de medição que formam os blocos de construção da computação quântica. A versão anterior do OpenQASM (2.0) foi usada por várias bibliotecas de programação quântica para descrever programas básicos. A nova versão do OpenQASM (3.0) estende a versão anterior para incluir mais recursos, como controle de nível de pulso, temporização de portas e fluxo de controle clássico para preencher a lacuna entre a interface do usuário final e a linguagem de descrição do hardware. Detalhes e especificações da versão 3.0 atual estão disponíveis na GitHub [OpenQASM 3.x](https://github.com/openqasm/openqasm) Live Specification. O desenvolvimento futuro do OpenQASM é governado pelo [Comitê de Direção Técnica](https://aws.amazon.com/blogs/quantum-computing/aws-joins-the-openqasm-3-0-technical-steering-committee/) do OpenQASM 3.0, do qual AWS é membro ao lado da IBM, da Microsoft e da Universidade de Innsbruck. ## Quando usar o OpenQASM 3.0 O OpenQASM fornece uma estrutura expressiva para especificar programas quânticos por meio de controles de baixo nível que não são específicos da arquitetura, tornando-o adequado como representação em vários dispositivos baseados em portas. O suporte do Braket ao OpenQASM promove sua adoção como uma abordagem consistente para o desenvolvimento de algoritmos quânticos baseados em portas, reduzindo a necessidade de os usuários aprenderem e manterem bibliotecas em várias estruturas. Se você tiver bibliotecas de programas existentes no OpenQASM 3.0, poderá adaptá-las para uso com o Braket em vez de reescrever completamente esses circuitos. Pesquisadores e desenvolvedores também devem se beneficiar de um número crescente de bibliotecas de terceiros disponíveis com suporte para desenvolvimento de algoritmos no OpenQASM. ## Como o OpenQASM 3.0 funciona O suporte para o OpenQASM 3.0 da Braket fornece paridade de recursos com a representação intermediária atual. Isso significa que tudo o que você pode fazer hoje em dispositivos de hardware e simuladores sob demanda com o Braket, você pode fazer com o OpenQASM usando o API Braket. Você pode executar programas OpenQASM 3.0 fornecendo diretamente cadeias de caracteres OpenQASM a todos os dispositivos baseados em portas de uma maneira semelhante à forma como os circuitos são fornecidos atualmente aos dispositivos no Braket. Os usuários do Braket também podem integrar bibliotecas de terceiros que suportam o OpenQASM 3.0. O restante deste guia detalha como desenvolver representações do OpenQASM para uso com o Braket. ## Pré-requisitos Para usar o OpenQASM 3.0 no Amazon Braket, você precisa ter a versão v1.8.0 dos [esquemas do Amazon Braket Python](https://github.com/aws/amazon-braket-schemas-python) e a versão v1.17.0 ou superior do [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python). Se você é um usuário iniciante do Amazon Braket, você precisa habilitar o Amazon Braket. Para obter instruções, consulte [Habilitar o Amazon Braket](https://docs.aws.amazon.com/braket/latest/developerguide/braket-enable-overview.html). # Quais recursos do OpenQASM o Braket suporta? A seção a seguir lista os tipos de dados, declarações e instruções pragmáticas do OpenQASM 3.0 suportados pelo Braket. **Topics** + [Tipos de dados do OpenQASM com suporte](#braket-openqasm-supported-features-datatypes) + [Declarações do OpenQASM compatíveis](#braket-openqasm-supported-features-statements) + [Pragmas Braket OpenQASM](#braket-openqasm-supported-features-pragmas) + [Suporte de recursos avançados para o OpenQASM no simulador local](#braket-openqasm-supported-features-advanced-feature-local-simulator) + [Operações e gramática suportadas com OpenPulse](#braket-openpulse-supported-operations-grammar) ## Tipos de dados do OpenQASM com suporte Os seguintes tipos de dados são compatíveis com o Amazon Braket: + Números inteiros não negativos são usados para índices de qubit (virtuais e físicos): + `cnot q[0], q[1];` + `h $0;` + Números ou constantes de ponto flutuante podem ser usados para ângulos de rotação da porta: + `rx(-0.314) $0;` + `rx(pi/4) $0;` **nota** pi é uma constante embutida no OpenQasm e não pode ser usada como nome de parâmetro. + Matrizes de números complexos (com a notação `im` OpenQASM para parte imaginária) são permitidas em pragmas de tipo de resultado para definir observáveis hermitianos gerais e em pragmas unitários: + `#pragma braket unitary [[0, -1im], [1im, 0]] q[0]` + `#pragma braket result expectation hermitian([[0, -1im], [1im, 0]]) q[0]` ## Declarações do OpenQASM compatíveis As seguintes declarações do OpenQASM são apoiadas pelo Amazon Braket. + `Header: OPENQASM 3;` + Declarações de bits clássicas: + `bit b1;` (equivalentemente, `creg b1;`) + `bit[10] b2;` (equivalentemente, `creg b2[10];`) + Declarações de qubit: + `qubit b1;` (equivalentemente, `qreg b1;`) + `qubit[10] b2;` (equivalentemente, `qreg b2[10];`) + Indexação em matrizes: `q[0]` + Entrada: `input float alpha;` + especificação do qubits físico: `$0` + Portas e operações compatíveis em um dispositivo: + `h $0;` + `iswap q[0], q[1];` **nota** As portas compatíveis de um dispositivo podem ser encontradas nas propriedades do dispositivo para ações do OpenQASM; nenhuma definição de porta é necessária para usar essas portas. + Declarações textuais. Atualmente, não oferecemos suporte à notação de duração da caixa. Portas qubits nativas e físicas são obrigatórias em caixas textuais. ``` #pragma braket verbatim box{ rx(0.314) $0; } ``` + Medição e atribuição de medições em qubits ou em um registro qubit completo. + `measure $0;` + `measure q;` + `measure q[0];` + `b = measure q;` + `measure q → b;` + As declarações de barreira fornecem controle explícito sobre a compilação e execução do circuito, impedindo a reordenação e as otimizações das portas além dos limites das barreiras. Eles também impõem uma ordem temporal estrita durante a execução, garantindo que todas as operações antes de uma barreira sejam concluídas antes do início das operações subsequentes. + `barrier;` + `barrier q[0], q[1];` + `barrier $3, $6;` ## Pragmas Braket OpenQASM As seguintes instruções do pragma OpenQASM são compatíveis pelo Amazon Braket. + Pragmas de ruído + `#pragma braket noise bit_flip(0.2) q[0]` + `#pragma braket noise phase_flip(0.1) q[0]` + `#pragma braket noise pauli_channel` + Pragmas literais + `#pragma braket verbatim` + Pragmas de tipos de resultados + Tipos de resultados invariantes básicos: + Vetor de estado: `#pragma braket result state_vector` + Matriz de densidade: `#pragma braket result density_matrix` + Pragmas de computação de gradiente: + Gradiente adjunto: `#pragma braket result adjoint_gradient expectation(2.2 * x[0] @ x[1]) all` + Tipos de resultados básicos Z: + Amplitude `#pragma braket result amplitude "01"` + Probabilidade `#pragma braket result probability q[0], q[1]` + Tipos de resultados rotacionados de base + Expectativa: `#pragma braket result expectation x(q[0]) @ y([q1])` + Variância: `#pragma braket result variance hermitian([[0, -1im], [1im, 0]]) $0` + Amostra: `#pragma braket result sample h($1)` **nota** O OpenQASM 3.0 é compatível com versões anteriores do OpenQASM 2.0, portanto, programas escritos usando 2.0 podem ser executados no Braket. No entanto, os recursos do OpenQASM 3.0 suportados pelo Braket têm algumas pequenas diferenças de sintaxe, como `qreg` vs `creg` e `qubit` vs `bit`. Também há diferenças na sintaxe de medição, e elas precisam ser compatíveis com a sintaxe correta. ## Suporte de recursos avançados para o OpenQASM no simulador local `LocalSimulator` suporta recursos avançados do OpenQASM que não são oferecidos como parte dos QPUs ou simuladores sob demanda da Braket. A lista de recursos a seguir só é compatível no `LocalSimulator`: + Modificadores de porta + Portas embutidas OpenQASM + Variáveis clássicas + Operações clássicas + Portas personalizadas + Controle do Classic + Arquivos ASM + Sub-rotinas Para ver exemplos de cada recurso avançado, consulte este [exemplo de caderno](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Advanced_OpenQASM_Programs_with_the_Local_Simulator.ipynb). [Para obter a especificação completa do OpenQASM, consulte o site do OpenQASM](https://openqasm.com/language/index.html). ## Operações e gramática suportadas com OpenPulse **Tipos OpenPulse de dados compatíveis** Blocos de chamadas: ``` cal { ... } ``` Blocos decalques: ``` // 1 qubit defcal x $0 { ... } // 1 qubit w. input parameters as constants defcal my_rx(pi) $0 { ... } // 1 qubit w. input parameters as free parameters defcal my_rz(angle theta) $0 { ... } // 2 qubit (above gate args are also valid) defcal cz $1, $0 { ... } ``` Quadros: ``` frame my_frame = newframe(port_0, 4.5e9, 0.0); ``` Formas de onda: ``` // prebuilt waveform my_waveform_1 = constant(1e-6, 1.0); //arbitrary waveform my_waveform_2 = {0.1 + 0.1im, 0.1 + 0.1im, 0.1, 0.1}; ``` **Exemplo de calibração de porta personalizada:** ``` cal { waveform wf1 = constant(1e-6, 0.25); } defcal my_x $0 { play(wf1, q0_rf_frame); } defcal my_cz $1, $0 { barrier q0_q1_cz_frame, q0_rf_frame; play(q0_q1_cz_frame, wf1); delay[300ns] q0_rf_frame shift_phase(q0_rf_frame, 4.366186381749424); delay[300ns] q0_rf_frame; shift_phase(q0_rf_frame.phase, 5.916747563126659); barrier q0_q1_cz_frame, q0_rf_frame; shift_phase(q0_q1_cz_frame, 2.183093190874712); } bit[2] ro; my_x $0; my_cz $1,$0; c[0] = measure $0; ``` **Exemplo de pulso arbitrário:** ``` bit[2] ro; cal { waveform wf1 = {0.1 + 0.1im, 0.1 + 0.1im, 0.1, 0.1}; barrier q0_drive, q0_q1_cross_resonance; play(q0_q1_cross_resonance, wf1); delay[300ns] q0_drive; shift_phase(q0_drive, 4.366186381749424); delay[300dt] q0_drive; barrier q0_drive, q0_q1_cross_resonance; play(q0_q1_cross_resonance, wf1); ro[0] = capture_v0(r0_measure); ro[1] = capture_v0(r1_measure); } ``` # Crie e envie um exemplo de tarefa quântica do OpenQASM 3.0 Você pode usar o Amazon Braket Python SDK, o Boto3 AWS CLI ou o para enviar tarefas quânticas do OpenQASM 3.0 para um dispositivo Amazon Braket. **Topics** + [Um exemplo do programa OpenQASM 3.0](#braket-openqasm-example-program) + [Use o SDK do Python para criar tarefas quânticas do OpenQASM 3.0](#braket-openqasm-create-tasks-with-python-sdk) + [Use o Boto3 para criar tarefas quânticas do OpenQASM 3.0](#braket-openqasm-create-tasks-with-boto3) + [Use o AWS CLI para criar tarefas do OpenQASM 3.0](#braket-openqasm-create-tasks-with-aws-cli) ## Um exemplo do programa OpenQASM 3.0 Para criar uma tarefa OpenQASM 3.0, você pode começar com um programa OpenQASM 3.0 básico (ghz.qasm) que prepara um [estado GHZ](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state), conforme mostrado no exemplo a seguir. ``` // ghz.qasm // Prepare a GHZ state OPENQASM 3; qubit[3] q; bit[3] c; h q[0]; cnot q[0], q[1]; cnot q[1], q[2]; c = measure q; ``` ## Use o SDK do Python para criar tarefas quânticas do OpenQASM 3.0 Você pode usar o [Amazon Braket Python SDK](https://github.com/aws/amazon-braket-sdk-python) para enviar esse programa para um dispositivo Amazon Braket com o código a seguir. Certifique-se de substituir o exemplo de localização de bucket do Amazon S3 “amzn-s3-demo-bucket” por seu próprio nome de bucket do Amazon S3. ``` with open("ghz.qasm", "r") as ghz: ghz_qasm_string = ghz.read() # Import the device module from braket.aws import AwsDevice # Choose the Rigetti device device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3") from braket.ir.openqasm import Program program = Program(source=ghz_qasm_string) my_task = device.run(program) # Specify an optional s3 bucket location and number of shots s3_location = ("amzn-s3-demo-bucket", "openqasm-tasks") my_task = device.run( program, s3_location, shots=100, ) ``` ## Use o Boto3 para criar tarefas quânticas do OpenQASM 3.0 Você também pode usar o [AWS Python SDK para Braket (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/braket.html) para criar as tarefas quânticas usando strings do OpenQASM 3.0, conforme mostrado no exemplo a seguir. O trecho de código a seguir faz referência ao ghz.qasm, que prepara um [estado GHZ](https://en.wikipedia.org/wiki/Greenberger%E2%80%93Horne%E2%80%93Zeilinger_state) conforme mostrado acima. ``` import boto3 import json my_bucket = "amzn-s3-demo-bucket" s3_prefix = "openqasm-tasks" with open("ghz.qasm") as f: source = f.read() action = { "braketSchemaHeader": { "name": "braket.ir.openqasm.program", "version": "1" }, "source": source } device_parameters = {} device_arn = "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3" shots = 100 braket_client = boto3.client('braket', region_name='us-west-1') rsp = braket_client.create_quantum_task( action=json.dumps( action ), deviceParameters=json.dumps( device_parameters ), deviceArn=device_arn, shots=shots, outputS3Bucket=my_bucket, outputS3KeyPrefix=s3_prefix, ) ``` ## Use o AWS CLI para criar tarefas do OpenQASM 3.0 O [AWS Command Line Interface (CLI)](https://aws.amazon.com/cli/) também pode ser usado para enviar programas OpenQASM 3.0, conforme mostrado no exemplo a seguir. ``` aws braket create-quantum-task \ --region "us-west-1" \ --device-arn "arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3" \ --shots 100 \ --output-s3-bucket "amzn-s3-demo-bucket" \ --output-s3-key-prefix "openqasm-tasks" \ --action '{ "braketSchemaHeader": { "name": "braket.ir.openqasm.program", "version": "1" }, "source": $(cat ghz.qasm) }' ``` # Suporte para OpenQASM em diferentes dispositivos Braket Para dispositivos que suportam o OpenQASM 3.0, o campo `action` suporta uma nova ação por meio da resposta `GetDevice`, conforme mostrado no exemplo a seguir para os dispositivos Rigetti e IonQ. ``` //OpenQASM as available with the Rigetti device capabilities { "braketSchemaHeader": { "name": "braket.device_schema.rigetti.rigetti_device_capabilities", "version": "1" }, "service": {...}, "action": { "braket.ir.jaqcd.program": {...}, "braket.ir.openqasm.program": { "actionType": "braket.ir.openqasm.program", "version": [ "1" ], …. } } } //OpenQASM as available with the IonQ device capabilities { "braketSchemaHeader": { "name": "braket.device_schema.ionq.ionq_device_capabilities", "version": "1" }, "service": {...}, "action": { "braket.ir.jaqcd.program": {...}, "braket.ir.openqasm.program": { "actionType": "braket.ir.openqasm.program", "version": [ "1" ], …. } } } ``` Para dispositivos que suportam controle de pulso, o campo `pulse` é exibido na resposta `GetDevice`. O exemplo a seguir mostra esse campo `pulse` para o dispositivo Rigetti. ``` // Rigetti { "pulse": { "braketSchemaHeader": { "name": "braket.device_schema.pulse.pulse_device_action_properties", "version": "1" }, "supportedQhpTemplateWaveforms": { "constant": { "functionName": "constant", "arguments": [ { "name": "length", "type": "float", "optional": false }, { "name": "iq", "type": "complex", "optional": false } ] }, ... }, "ports": { "q0_ff": { "portId": "q0_ff", "direction": "tx", "portType": "ff", "dt": 1e-9, "centerFrequencies": [ 375000000 ] }, ... }, "supportedFunctions": { "shift_phase": { "functionName": "shift_phase", "arguments": [ { "name": "frame", "type": "frame", "optional": false }, { "name": "phase", "type": "float", "optional": false } ] }, ... }, "frames": { "q0_q1_cphase_frame": { "frameId": "q0_q1_cphase_frame", "portId": "q0_ff", "frequency": 462475694.24460185, "centerFrequency": 375000000, "phase": 0, "associatedGate": "cphase", "qubitMappings": [ 0, 1 ] }, ... }, "supportsLocalPulseElements": false, "supportsDynamicFrames": false, "supportsNonNativeGatesWithPulses": false, "validationParameters": { "MAX_SCALE": 4, "MAX_AMPLITUDE": 1, "PERMITTED_FREQUENCY_DIFFERENCE": 400000000 } } } ``` Os campos anteriores detalham o seguinte: **Portas:** Descreve as portas de dispositivos externos (`extern`) pré-fabricadas declaradas na QPU, além das propriedades associadas à porta especificada. Todas as portas listadas nessa estrutura são pré-declaradas como identificadores válidos no programa `OpenQASM 3.0` enviado pelo usuário. As propriedades adicionais de uma porta incluem: + ID da porta (portId) + O nome da porta declarado como identificador no OpenQASM 3.0. + Direção (direção) + A direção da porta. As portas de acionamento transmitem pulsos (direção “tx”), enquanto as portas de medição recebem pulsos (direção “rx”). + Tipo de porta (PortType) + O tipo de ação pela qual essa porta é responsável (por exemplo, drive, capture ou ff - fast-flux). + Dt (dt) + O tempo em segundos que representa uma única etapa de tempo de amostra na porta especificada. + Mapeamentos de Qubit (mapeamentos de qubit) + Os qubits associados à porta fornecida. + Frequências centrais (frequências centrais) + Uma lista das frequências centrais associadas para todos os quadros pré-declarados ou definidos pelo usuário na porta. Para obter mais informações, consulte Quadros. + Propriedades específicas do QHP () qhpSpecificProperties + Um mapa opcional detalhando as propriedades existentes sobre a porta específica do QHP. **Quadros:** Descreve os quadros externos pré-fabricados declarados na QPU, bem como as propriedades associadas aos quadros. Todos os quadros listados nessa estrutura são pré-declarados como identificadores válidos dentro do programa `OpenQASM 3.0` enviado pelo usuário. As propriedades adicionais de uma moldura incluem: + ID do quadro (frameId) + O nome do quadro declarado como um identificador no OpenQASM 3.0. + ID da porta (portId) + A porta de hardware associada ao quadro. + Frequência (frequência) + A frequência inicial padrão do quadro. + Frequência central (centerFrequency) + O centro da largura de banda de frequência do quadro. Normalmente, os quadros só podem ser ajustados para uma determinada largura de banda em torno da frequência central. Como resultado, os ajustes de frequência devem permanecer dentro de um determinado delta da frequência central. Você pode encontrar o valor da largura de banda nos parâmetros de validação. + Fase (fase) + A fase inicial padrão do quadro. + Porta associada (associatedGate) + As portas associadas ao quadro fornecido. + Mapeamentos de Qubit (mapeamentos de qubit) + Os qubits associados ao frame fornecido. + Propriedades específicas do QHP () qhpSpecificProperties + Um mapa opcional detalhando as propriedades existentes sobre o quadro específico do QHP. **SupportsDynamicFrames:** Descreve se um quadro pode ser declarado em blocos `cal` ou `defcal` por meio da função OpenPulse `newframe`. Se isso for falso, somente os quadros listados na estrutura do quadro poderão ser usados no programa. **SupportedFunctions:** Descreve as funções OpenPulse que são compatíveis pelo dispositivo, além dos argumentos, tipos de argumentos e tipos de retorno associados às funções fornecidas. Para ver exemplos de uso das OpenPulse funções, consulte a [OpenPulseespecificação](https://openqasm.com/language/openpulse.html). No momento, o Braket suporta: + shift\$1phase + Desloca a fase de um quadro por um valor especificado + set\$1phase + Define a fase do quadro para o valor especificado + fases\$1troca + Troca as fases entre dois quadros. + frequência\$1de-turno + Desloca a frequência de um quadro por um valor especificado + frequência\$1definida + Define a frequência do quadro para o valor especificado + jogar + Agenda uma forma de onda + capture\$1v0 + Retorna o valor em um quadro de captura para um registro de bits **SupportedQhpTemplateWaveforms:** Descreve as funções de forma de onda pré-criadas disponíveis no dispositivo e os argumentos e tipos associados. Por padrão, o Braket Pulse oferece rotinas de forma de onda pré-criadas em todos os dispositivos, que são: ** *Constante* ** ![\[Equação matemática mostrando uma função constante com os parâmetros t, tau e iq em que a saída é sempre igual a iq.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/ConstantFunction.png) `τ` é o comprimento da forma de onda e `iq` é um número complexo. ``` def constant(length, iq) ``` ** *Gaussiano* ** ![\[Equação matemática mostrando a função gaussiana com os parâmetros t, tau, sigma, A=1 e ZaE=0.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/GaussianFunction.png) `τ` é o comprimento da forma de onda, `σ` é a largura da gaussiana e `A` é a amplitude. Se definido `ZaE` como `True`, o gaussiano é deslocado e redimensionado de forma que seja igual a zero no início e no final da forma de onda e atinja o máximo `A`. ``` def gaussian(length, sigma, amplitude=1, zero_at_edges=False) ``` ** *DRAG Gaussiano* ** ![\[Equação matemática para distribuição gaussiana DRAG com parâmetros t, tau, sigma, beta, A=1 e ZaE=0.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/DRAGGaussianFunction.png) `τ` é o comprimento da forma de onda, `σ` é a largura gaussiana, `β` é um parâmetro livre e `A` é a amplitude. Se definido `ZaE` como `True`, o Gaussiano de Remoção de Derivativa por Porta Adiabática (DRAG) é deslocado e reescalado de forma que seja igual a zero no início e no fim da forma de onda, e a parte real atinge o máximo `A`. Para obter mais informações sobre a forma de onda DRAG, consulte o artigo [Pulsos simples para eliminação de vazamento em qubits fracamente não lineares](https://doi.org/10.1103/PhysRevLett.103.110501). ``` def drag_gaussian(length, sigma, beta, amplitude=1, zero_at_edges=False) ``` ** *Quadrado Erf* ** ![\[Equação matemática para distribuição do quadrado Erf com os parâmetros t, comprimento, largura, sigma, A = 1 e zAE=0.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/ErfSquareFunction.PNG) Onde `L` é o comprimento, `W` é a largura da forma de onda, `σ` define a rapidez com que as bordas sobem e descem, `t1​=(L−W)/2` e `t22=(L+W)/2`, `A` é a amplitude. Se definido `ZaE` como `True`, o gaussiano é deslocado e redimensionado de forma que seja igual a zero no início e no final da forma de onda e atinja o máximo `A`. A equação a seguir é a versão redimensionada da forma de onda. ![\[Equação matemática para a distribuição do quadrado Erf redimensionado com os parâmetros ZaE=1.\]](http://docs.aws.amazon.com/pt_br/braket/latest/developerguide/images/RescaledErfSquareFunction.PNG) Onde `a=erf(W/2σ)` e `b=erf(-t1​/σ)/2+erf(t2​/σ)/2`. ``` def erf_square(length, width, sigma, amplitude=1, zero_at_edges=False) ``` **SupportsLocalPulseElements:** Descreve se elementos de pulso, como portas, estruturas e formas de onda, podem ser definidos localmente em blocos `defcal`. Se o valor for `false`, os elementos devem ser definidos em blocos `cal`. **SupportsNonNativeGatesWithPulses:** Descreve se podemos ou não usar portas não nativas em combinação com programas de pulso. Por exemplo, você não pode usar uma porta não nativa como uma porta `H` em um programa sem primeiro definir a porta de entrada `defcal` para o qubit usado. Você pode encontrar a lista de chaves `nativeGateSet` de portas nativas nos recursos do dispositivo. **ValidationParameters:** Descreve os limites de validação do elemento de pulso, incluindo: + Valores de escala máxima/amplitude máxima para formas de onda (arbitrárias e pré-construídas) + Largura de banda de frequência máxima da frequência central fornecida em Hz + Pulso mínimo length/duration em segundos + Pulso máximo length/duration em segundos ## Operações, resultados e tipos de resultados suportados com o OpenQASM Para descobrir quais recursos do OpenQASM 3.0 cada dispositivo suporta, você pode consultar a chave `braket.ir.openqasm.program` no campo `action` na saída de recursos do dispositivo. Por exemplo, a seguir estão as operações compatíveis e os tipos de resultados disponíveis para o simulador SV1 Braket State Vector. ``` ... "action": { "braket.ir.jaqcd.program": { ... }, "braket.ir.openqasm.program": { "version": [ "1.0" ], "actionType": "braket.ir.openqasm.program", "supportedOperations": [ "ccnot", "cnot", "cphaseshift", "cphaseshift00", "cphaseshift01", "cphaseshift10", "cswap", "cy", "cz", "h", "i", "iswap", "pswap", "phaseshift", "rx", "ry", "rz", "s", "si", "swap", "t", "ti", "v", "vi", "x", "xx", "xy", "y", "yy", "z", "zz" ], "supportedPragmas": [ "braket_unitary_matrix" ], "forbiddenPragmas": [], "maximumQubitArrays": 1, "maximumClassicalArrays": 1, "forbiddenArrayOperations": [ "concatenation", "negativeIndex", "range", "rangeWithStep", "slicing", "selection" ], "requiresAllQubitsMeasurement": true, "supportsPhysicalQubits": false, "requiresContiguousQubitIndices": true, "disabledQubitRewiringSupported": false, "supportedResultTypes": [ { "name": "Sample", "observables": [ "x", "y", "z", "h", "i", "hermitian" ], "minShots": 1, "maxShots": 100000 }, { "name": "Expectation", "observables": [ "x", "y", "z", "h", "i", "hermitian" ], "minShots": 0, "maxShots": 100000 }, { "name": "Variance", "observables": [ "x", "y", "z", "h", "i", "hermitian" ], "minShots": 0, "maxShots": 100000 }, { "name": "Probability", "minShots": 1, "maxShots": 100000 }, { "name": "Amplitude", "minShots": 0, "maxShots": 0 } { "name": "AdjointGradient", "minShots": 0, "maxShots": 0 } ] } }, ... ``` # Simule ruídos com o OpenQASM 3.0 Para simular o ruído com o OpenQASM3, você usa instruções *pragmáticas* para adicionar operadores de ruído. Por exemplo, para simular a versão ruidosa do [programa GHZ](braket-openqasm-create-submit-task.md#braket-openqasm-example-program) fornecida anteriormente, você pode enviar o seguinte programa OpenQASM. ``` // ghz.qasm // Prepare a GHZ state OPENQASM 3; qubit[3] q; bit[3] c; h q[0]; #pragma braket noise depolarizing(0.75) q[0] cnot q[0], q[1]; #pragma braket noise depolarizing(0.75) q[0] #pragma braket noise depolarizing(0.75) q[1] cnot q[1], q[2]; #pragma braket noise depolarizing(0.75) q[0] #pragma braket noise depolarizing(0.75) q[1] c = measure q; ``` As especificações de todos os operadores de ruído pragmático com suporte são fornecidas na lista a seguir. ``` #pragma braket noise bit_flip() #pragma braket noise phase_flip() #pragma braket noise pauli_channel(, , ) #pragma braket noise depolarizing() #pragma braket noise two_qubit_depolarizing() , #pragma braket noise two_qubit_dephasing() , #pragma braket noise amplitude_damping() #pragma braket noise generalized_amplitude_damping( ) #pragma braket noise phase_damping() #pragma braket noise kraus([[, ], ...], [[, ], ...], ...) [, ] // maximum of 2 qubits and maximum of 4 matrices for 1 qubit, 16 for 2 ``` ## Operador Kraus Para gerar um operador Kraus, você pode iterar por meio de uma lista de matrizes, imprimindo cada elemento da matriz como uma expressão complexa. Ao usar operadores de Kraus, lembre-se do seguinte: + O número de qubits não deve exceder 2. A [definição atual nos esquemas](https://github.com/aws/amazon-braket-sdk-python/blob/0d28a8fa89263daf5d88bc706e79200d8dc091a8/src/braket/circuits/noises.py#L811-L814)) define esse limite. + O tamanho da lista de argumentos deve ser múltiplo de 8. Isso significa que ele deve ser composto apenas por matrizes 2x2. + O comprimento total não excede matrizes 22\$1num\$1qubits. Isso significa 4 matrizes para 1 qubit e 16 para 2 qubits. + Todas as matrizes fornecidas [preservam traços completamente positivos (CPTP)](https://github.com/aws/amazon-braket-sdk-python/blob/0d28a8fa89263daf5d88bc706e79200d8dc091a8/src/braket/circuits/quantum_operator_helpers.py#L94-L108). + O produto dos operadores de Kraus com seus conjugados de transposição precisa se somar a uma matriz de identidade. # Reconexão Qubit com o OpenQASM 3.0 [O Amazon Braket suporta a notação qubit física no OpenQASM em dispositivos (para saber mais, consulte Rigetti esta página).](https://github.com/openqasm/openqasm/blob/main/source/language/types.rst) Ao usar o qubits físico com a [estratégia de reconexão ingênua](https://pyquil-docs.rigetti.com/en/v2.28.1/compiler.html#naive), certifique-se de que os qubits estejam conectados ao dispositivo selecionado. Como alternativa, se os registros qubit forem usados em vez disso, a estratégia de reconexão PARCIAL será ativada por padrão nos dispositivos Rigetti. ``` // ghz.qasm // Prepare a GHZ state OPENQASM 3; h $0; cnot $0, $1; cnot $1, $2; measure $0; measure $1; measure $2; ``` # Compilação literal com o OpenQASM 3.0 Quando você executa um circuito quântico em computadores quânticos fornecidos por fornecedores como Rigetti e IonQ, você pode direcionar o compilador para executar seus circuitos exatamente como definido, sem nenhuma modificação. Esse recurso é conhecido como *compilação literal*. Com os dispositivos Rigetti, você pode especificar com precisão o que é preservado: um circuito inteiro ou apenas partes específicas dele. Para preservar somente partes específicas de um circuito, você precisará usar portas nativas dentro das regiões preservadas. Atualmente, o IonQ suporta apenas compilação literal para todo o circuito, portanto, todas as instruções no circuito precisam ser incluídas em uma caixa literal. Com o OpenQASM, você pode especificar explicitamente um pragma literal em torno de uma caixa de código que é então deixada intocada e não otimizada pela rotina de compilação de baixo nível do hardware. O código de exemplo a seguir mostra como usar a diretiva `#pragma braket verbatim` para fazer isso. ``` OPENQASM 3; bit[2] c; #pragma braket verbatim box{ rx(0.314159) $0; rz(0.628318) $0, $1; cz $0, $1; } c[0] = measure $0; c[1] = measure $1; ``` Para obter informações mais detalhadas sobre o processo de compilação literal, incluindo exemplos e melhores práticas, consulte o caderno de amostra de [compilação Verbatim disponível](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb) no repositório github. amazon-braket-examples ## O console do Braket As tarefas do OpenQASM 3.0 estão disponíveis e podem ser gerenciadas no console do Amazon Braket. No console, você tem a mesma experiência ao enviar tarefas quânticas no OpenQASM 3.0 que tinha ao enviar tarefas quânticas existentes. ## Recursos adicionais do O OpenQASM está disponível em todas as regiões do Amazon Braket. [Para ver um exemplo de caderno para começar a usar o OpenQASM no Amazon Braket, consulte Tutoriais do Braket. GitHub](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Getting_Started_with_OpenQASM_on_Braket.ipynb) # Gradientes de computação com o OpenQASM 3.0 O Amazon Braket suporta o cálculo de gradientes em simuladores sob demanda e locais quando executado no modo (exato) `shots=0`. Isso é obtido por meio do uso do método de diferenciação adjunta. Para especificar o gradiente que você deseja calcular, você pode fornecer o pragma apropriado, conforme demonstrado no código no exemplo a seguir. ``` OPENQASM 3.0; input float alpha; bit[2] b; qubit[2] q; h q[0]; h q[1]; rx(alpha) q[0]; rx(alpha) q[1]; b[0] = measure q[0]; b[1] = measure q[1]; #pragma braket result adjoint_gradient h(q[0]) @ i(q[1]) alpha ``` Em vez de listar explicitamente todos os parâmetros individuais, você também pode especificar a palavra-chave `all` dentro do pragma. Isso calculará o gradiente em relação a todos os parâmetros `input` listados, o que pode ser uma opção conveniente quando o número de parâmetros é muito grande. Nesse caso, o pragma será semelhante ao código do exemplo a seguir. ``` #pragma braket result adjoint_gradient h(q[0]) @ i(q[1]) all ``` Todos os tipos observáveis são compatíveis com a implementação do OpenQASM 3.0 do Amazon Braket, incluindo operadores individuais, produtos tensores, observáveis Hermitian e `Sum` observáveis. O operador específico que você deseja usar ao calcular gradientes deve ser encapsulado na função `expectation()`, e os qubits sobre os quais cada termo do observável atua devem ser especificados explicitamente. # Medindo qubits específicos com o OpenQASM 3.0 O simulador vetorial estadual local e o simulador de matriz de densidade local fornecidos pela Amazon Braket oferecem suporte ao envio de programas em que um subconjunto OpenQASM dos qubits do circuito pode ser medido seletivamente. Essa capacidade, geralmente chamada de medição parcial, permite cálculos quânticos mais direcionados e eficientes. Por exemplo, no trecho de código a seguir, você pode criar um circuito de dois qubits e optar por medir somente o primeiro qubit, deixando o segundo qubit não medido. ``` partial_measure_qasm = """ OPENQASM 3.0; bit[1] b; qubit[2] q; h q[0]; cnot q[0], q[1]; b[0] = measure q[0]; """ ``` Neste exemplo, temos um circuito quântico com dois qubits `q[0]` e `q[1]`, mas estamos interessados apenas em medir o estado do primeiro qubit. Isso é obtido pela linha `b[0] = measure q[0]`, que mede o estado do qubit [0] e armazena o resultado no bit clássico b [0]. Para executar esse cenário de medição parcial, podemos executar o código a seguir no simulador vetorial estadual local fornecido pela Amazon Braket. ``` from braket.devices import LocalSimulator local_sim = LocalSimulator() partial_measure_local_sim_task = local_sim.run(OpenQASMProgram(source=partial_measure_qasm), shots = 10) partial_measure_local_sim_result = partial_measure_local_sim_task.result() print(partial_measure_local_sim_result.measurement_counts) print("Measured qubits: ", partial_measure_local_sim_result.measured_qubits) ``` Você pode verificar se um dispositivo suporta medição parcial inspecionando o campo `requiresAllQubitsMeasurement` em suas propriedades de ação; se for`False`, então a medição parcial é compatível. ``` from braket.devices import Devices AwsDevice(Devices.Rigetti.Ankaa3).properties.action['braket.ir.openqasm.program'].requiresAllQubitsMeasurement ``` Aqui, `requiresAllQubitsMeasurement` é `False`, o que indica que nem todos os qubits devem ser medidos.