Simulando a natureza

Assista a este vídeo de Olivia Lanes sobre a simulação da natureza com computadores quânticos, ou abra o vídeo em uma janela separada no YouTube.

Esta aula usa conteúdo deste tutorial:

Tutorial de mitigação de erros em escala de utilidade com amplificação probabilística de erros

Introdução

Uma das aplicações mais promissoras dos computadores quânticos é sua capacidade de simular fenômenos naturais. Nesta aula, vamos explorar como os computadores quânticos são usados para resolver problemas de dinâmica quântica — especificamente, como eles nos ajudam a entender a evolução temporal de um sistema quântico.

Primeiro, vamos dar uma visão ampla dos passos gerais envolvidos na realização dessas simulações. Em seguida, vamos examinar um exemplo concreto: o experimento que a IBM apresentou em 2023, que demonstrou o conceito de utilidade quântica. Esse experimento serve como um excelente estudo de caso para entender os passos práticos e as implicações de simular dinâmicas quânticas com hardware quântico real. Ao final, você terá uma imagem mais clara de como os pesquisadores abordam esses desafios e por que a simulação quântica é tão promissora para avançar nossa compreensão do mundo natural.

Richard Feynman deu uma palestra muito influente no Caltech em 1959. Ela foi famosamente intitulada "There's Plenty of Room at the Bottom," em alusão jocosa às vastas possibilidades inexploradas na escala microscópica. Feynman argumentou que grande parte da física nos níveis atômico e subatômico ainda estava por ser descoberta.

A importância da palestra cresceu na década de 1980 à medida que a tecnologia avançou. Durante esse período, Feynman revisitou essas ideias em outra palestra importante no Caltech, apresentando um artigo chamado "Simulating Nature with Computers." Lá, ele levantou uma questão ousada: os computadores poderiam ser usados para realizar simulações exatas que replicam o comportamento da natureza no nível quântico? Feynman sugeriu que, em vez de confiar em aproximações grosseiras para modelar processos atômicos, poderíamos usar computadores que aproveitam as próprias leis da mecânica quântica — não apenas para modelar a natureza, mas para emulá-la.

É esse tipo de simulação física que vamos examinar nesta aula.

Lembre-se deste gráfico de linha do tempo introduzido em um episódio anterior. Em uma extremidade do espectro, vemos problemas que são simples de resolver e não requerem a velocidade aprimorada que a computação quântica pode trazer.

Na extremidade oposta estão problemas extremamente desafiadores que exigem máquinas quânticas totalmente tolerantes a falhas — tecnologia que ainda não está disponível. Felizmente, acredita-se que muitos problemas de simulação se enquadrem em algum lugar no meio dessa linha do tempo, dentro do intervalo onde os computadores quânticos de hoje já podem ser efetivamente aplicados. Há muitas razões para estar animado e intrigado com essa perspectiva, pois simular a natureza forma a base para uma ampla gama de aplicações promissoras.

As informações a seguir cobrem o fluxo de trabalho geral em simulações da natureza e, em seguida, uma instância específica do fluxo de trabalho para replicar resultados de um estudo bem conhecido.

Fluxo de trabalho geral

Antes de qualquer pessoa poder aplicar a computação quântica a essas áreas empolgantes, é importante primeiro entender os passos básicos em um fluxo de trabalho típico de simulação:

1. Identificar o Hamiltoniano do sistema
2. Codificação do Hamiltoniano
3. Preparação do estado
4. Evolução temporal do estado
5. Otimização do circuito
6. Execução do circuito
7. Pós-processamento

O processo começa identificando um sistema quântico de interesse. Isso ajuda a determinar o Hamiltoniano que governa sua evolução temporal, bem como uma descrição significativa de suas propriedades iniciais, ou seu estado. Em seguida, você precisa selecionar um método apropriado para implementar a evolução temporal desse estado. Note que os primeiros quatro passos nesse fluxo de trabalho fazem parte da etapa de Mapeamento no framework de padrões Qiskit.

Após configurar o circuito de evolução temporal, as etapas subsequentes envolvem a realização do experimento propriamente dito. Isso normalmente inclui otimizar o circuito quântico que implementa o algoritmo de evolução temporal, executar o circuito no hardware quântico e pós-processar os resultados. Estes são os mesmos que os três últimos passos no framework de padrões Qiskit.

Em seguida, vamos discutir o que significam esses passos antes de passar à codificação.

1. Identificar o Hamiltoniano do sistema

O primeiro passo essencial na realização de um experimento de simulação é identificar o Hamiltoniano que descreve o sistema. Em muitos casos, o Hamiltoniano é bem estabelecido. No entanto, muitas vezes o construímos somando as contribuições de energia de partes menores do sistema. Isso é tipicamente expresso como uma soma de termos:

$$H=\sum_i^N {H_i}$$

onde cada termo $H_i$ atua em um dos $N$ subistemas locais (como uma única partícula ou um pequeno grupo de partículas) do Hamiltoniano total $H$. No caso de partículas elementares indistinguíveis, é importante determinar se o sistema envolve férmions ou bósons, onde os férmions obedecem ao Princípio de Exclusão de Pauli, o que significa que dois férmions idênticos não podem ocupar os mesmos estados quânticos, como os elétrons. Ao contrário dos férmions, vários bósons podem existir no mesmo estado quântico, e essa diferença afeta as estatísticas do sistema e como ele deve ser modelado.

Na prática, as pessoas geralmente estão interessadas em sistemas físicos nos quais os elementos são presumivelmente bem separados ou rotulados e, portanto, distinguíveis, como spins em uma rede.

Este sistema consiste em spins de dipolo magnético dispostos em uma rede, que são tratados como partículas distinguíveis contando seu endereço. Este sistema é descrito pelo Modelo de Ising de Campo Transversal, e seu Hamiltoniano é construído a partir da soma de duas partes:

$$H = \sum_i^N {H_i} = J \sum_{<i,j>}Z_iZ_j + h\sum_{i=0}^N X_i$$

Onde o primeiro termo representa a energia de interação entre spins vizinhos. Aqui o $<i,j>$ indica que somamos sobre todos os pares de spins que estão diretamente conectados na rede, $Z_i$ e $Z_j$ são as matrizes de Pauli-Z, que representam o estado dos spins no sítio $i$ e $j$, e $J$ é a constante de acoplamento, que define a intensidade dessa interação. O segundo termo representa a influência de um campo magnético externo aplicado em todo o sistema. Aqui $X_i$ é a matriz de Pauli-X atuando no spin individual no sítio $i$, e $h$ indica a intensidade desse campo externo.

2. Codificação do Hamiltoniano

O próximo passo é traduzir o Hamiltoniano para uma forma que um computador quântico possa processar, o que chamamos de codificação. Esse processo de codificação depende criticamente do tipo de partículas nos sistemas: distinguíveis ou indistinguíveis, e férmion ou bóson, se as partículas forem indistinguíveis.

Se você tem um sistema com partículas distinguíveis, como spins $1/2$ fixos em uma rede, que examinamos brevemente acima, o Hamiltoniano geralmente já é escrito em uma linguagem compatível com qubits. O operador Pauli-Z, por exemplo, descreve naturalmente o spin para cima ou para baixo de um spin, e nenhuma codificação especial é necessária.

Ao simular partículas indistinguíveis de férmions ou bósons, é necessário aplicar uma transformação de codificação. Essas partículas são usadas para descrever dentro de um framework matemático especial chamado segunda quantização, que acompanha o número de ocupação de cada estado quântico introduzindo operadores de criação e aniquilação, onde o operador de criação $\hat{a}_i^\dagger$ adiciona uma partícula ao estado $i$ enquanto o operador de aniquilação $\hat{a}_i$ remove uma partícula do estado $i$. Com base nesse framework de segunda quantização, o férmion pode ser transformado por Bravyi-Kitaev e Jordan-Wigner. A transformação de Jordan-Wigner define o operador de criação fermiônica $\hat{f}_j^\dagger = \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j + i Y_j}{2} \Bigr)$ que preenche o $j$-ésimo estado quântico com um férmion e o operador de aniquilação fermiônica $\hat{f}_j= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j - i Y_j}{2} \Bigr)$ que esvazia um férmion do $j$-ésimo estado. Você pode encontrar mais detalhes desta transformação de Jordan-Wigner em Computação Quântica na Prática, episódio 5 - Mapeamento. Da mesma forma, os bósons também requerem seus próprios métodos de codificação, como a transformação de Holstein-Primakoff, para serem representados por qubits.

Em última análise, seja o caminho direto ou exigindo uma tradução, o objetivo é o mesmo: expressar o Hamiltoniano do sistema na forma de operadores de spin de Pauli que um computador quântico possa entender e executar.

3. Preparação do estado

Após codificar o Hamiltoniano desejado no conjunto de portas do computador quântico, o próximo passo importante é selecionar um estado quântico inicial apropriado para começar a simulação. A escolha do estado inicial influencia não só a convergência de algoritmos variacionais como o Variational Quantum Eigensolver (VQE), mas também afeta a precisão e a eficiência da evolução temporal e da amostragem. Essencialmente, o estado inicial serve como ponto de partida para a computação, estabelecendo a base para extrair observáveis úteis do sistema quântico sendo modelado. Idealmente, esse estado deve representar uma configuração fisicamente significativa do sistema em estudo.

Para muitas simulações de química quântica, o estado Hartree-Fock pode ser um bom ponto de partida. Na linguagem da segunda quantização, o estado Hartree-Fock ($|\phi\rangle_{HF}$) é criado aplicando operadores de criação ($\hat{a}_i^\dagger$) para cada um dos orbitais de menor energia ao estado de vácuo ($|vac\rangle = |0_1 ... 0_k ... 0_N\rangle = |0\rangle ^{\otimes N}$), um estado sem elétrons.

$$|\phi\rangle_{HF} = \prod\limits_{i=1}^k \hat{a}_i^\dagger |0\rangle ^{\otimes N} = \hat{a}_1^\dagger ... \hat{a}_k^\dagger |0_1 ... 0_k ... 0_N\rangle$$

Adicionalmente, um ansatz facilmente preparado com sobreposição significativa com o verdadeiro estado fundamental pode servir como um bom estado inicial para problemas de química, como encontrar a energia do estado fundamental.

De forma mais geral, podemos escrever um estado arbitrário de $n$ qubits como uma superposição de estados de base computacional $∣c_i\rangle$ com coeficientes $a_i$, satisfazendo condições de normalização. Preparar esse estado pode geralmente ser abordado aplicando um operador específico $\hat{O}$ ao estado inicial, que por convenção é tipicamente o estado de base padrão com todos zeros.

$$|\psi\rangle = \sum_{i=0}^{2^n-1}{a_i |c_i\rangle}=\hat{O}|0\rangle^{\otimes n}\\ \text{with} \qquad \sum_{i=0}^{2^n-1}{|a_i^2|}=1$$

No entanto, esse processo muitas vezes requer um número exponencial de portas CNOT, tornando-o geralmente intensivo em recursos. Frequentemente nos concentramos na preparação de estados iniciais para os quais as demandas de recursos de implementação são mais modestas. Por essa razão, frequentemente focamos na preparação de estados iniciais menos complexos. Uma escolha comum e prática é um estado produto, onde os qubits não estão entrelaçados, podendo ser preparado usando apenas operações de qubit único, reduzindo significativamente as demandas de recursos da preparação do estado e a complexidade. 4. Evolução temporal do estado

Agora que o estado inicial está definido, podemos finalmente começar a simulação em si — examinar como o estado do sistema $|\phi(t=0)\rangle$ muda para $|\phi(t)\rangle$ após algum tempo, $t$. Na mecânica quântica, essa evolução é descrita por uma única operação matemática chamada operador de evolução temporal:

$$U(t) = e^{-iHt}$$

onde definimos $\hbar=1$ por convenção. Aplicar esse operador ao nosso estado inicial nos dá o estado final: $|\phi(t)\rangle = e^{-iHt}|\phi(t=0)\rangle$

No entanto, construir um circuito quântico que implemente diretamente o operador completo $e^{-iHt}$ é tipicamente impossível quando nosso Hamiltoniano é uma soma de partes diferentes. Portanto, precisamos da Trotterização.

Em termos simples, a Trotterização é uma técnica para aproximar a exponenciação de uma matriz (aqui o Hamiltoniano, $H$), especialmente quando o expoente contém operadores que não comutam ($[H_A, H_B] \neq 0$). Frequentemente o Hamiltoniano $H$ consiste em múltiplos operadores que não comutam. Nesse caso, você não pode separar seus exponenciais:

$$e^{-i(H_A + H_B)t} \neq e^{-iH_A t}e^{-iH_B t}$$

Uma abordagem útil é aplicar alternadamente seus exponenciais de evolução temporal ao longo de pequenas durações, $t/n$, um total de $n$ vezes. No caso dessas duas contribuições que não comutam, escreveríamos

$$e^{−i H t}\approx \left(e^{−i H_A t/n}e^{−i H_B t/n}\right)^n$$

O erro introduzido por essa aproximação é chamado de erro de Trotter. Podemos reduzir esse erro aumentando $n$, mas isso tem um custo. Fórmulas mais avançadas de ordem mais alta (a fórmula de segunda ordem e outras variantes) também existem. Por exemplo, a fórmula de segunda ordem oferece melhor precisão aplicando os passos em um padrão simétrico.

$$\begin{aligned} \text{Primeira ordem:} & \qquad e^{-iHt}\approx \left(\prod_j{e^{-iH_i t/n}}\right)^n\\ \text{Segunda ordem:} & \qquad e^{-iHt}\approx \left(\prod_{j=1}^N{e^{-iH_j t/2n}}\right)^n\left(\prod_{k=N}^1{e^{-iH_k t/2n}}\right)^n \end{aligned}$$

Aqui, $N$ é o número de termos que não comutam, $H_j$, no Hamiltoniano a ser dividido dessa forma, e $n$ é o número de pequenos passos de tempo nos quais essa evolução é dividida. Note a ordem inversa dos operadores no segundo produto no tratamento de segunda ordem.

Veja a seção de Trotterização no curso de Algoritmos de Diagonalização Quântica para mais detalhes. 5. Otimização do circuito

Após gerar o circuito trotterizado, a etapa de mapeamento está completa e podemos prosseguir para a otimização do circuito. Esse processo envolve várias tarefas principais:

• Estabelecer um layout de qubits que mapeie os qubits abstratos do circuito para os qubits físicos no hardware. Esta etapa é necessária porque a arquitetura do hardware muitas vezes tem restrições específicas de conectividade, enquanto os designs de circuitos quânticos tipicamente assumem que qualquer qubit pode interagir com qualquer outro.
• Inserir portas swap conforme necessário para permitir interações entre qubits que não estão diretamente conectados no dispositivo.
• Traduzir as portas do circuito para instruções ISA (Instruction Set Architecture) que o hardware pode executar diretamente.
• Realizar otimizações de circuito para reduzir a profundidade do circuito e a contagem de portas. Essa otimização também pode ser aplicada mais cedo, no circuito virtual antes que os qubits sejam atribuídos a conexões específicas de hardware.

É importante notar que grande parte desse processo de otimização é tratado automaticamente pelas ferramentas do Qiskit. Vamos explorar exatamente como isso funciona mais tarde nesta aula.

6. Execução do circuito

Após completar a etapa de otimização, estamos prontos para executar o circuito usando uma primitiva. Estamos considerando um experimento de simulação cujo objetivo é entender como certas propriedades do sistema mudam ao longo do tempo. Para esse fim, a primitiva Estimator é a escolha mais adequada, pois permite medir os valores de expectativa de observáveis que correspondem a essas propriedades.

Em seguida, usamos opções incluindo técnicas de supressão e mitigação de erros, para melhorar a precisão do Estimator. Por fim, executamos o experimento para coletar os resultados.

7. Pós-processamento

O passo final é pós-processar os dados coletados. Isso envolve extrair os valores de expectativa medidos ou, se a primitiva Sampler foi usada, a distribuição de probabilidade amostrada na base computacional. Quando apenas os valores de expectativa dos observáveis relevantes são necessários, eles podem ser obtidos diretamente da primitiva Estimator, disponíveis tanto como resultados brutos quanto com mitigação de erros aplicada. Frequentemente, esses valores de expectativa medidos servem como ponto de partida para cálculos adicionais envolvendo outras quantidades de interesse. Tais cálculos adicionais normalmente não requerem computação quântica e podem ser eficientemente realizados em um computador clássico.

Replicando o artigo de "Utilidade"

nota

Esta parte é um passo a passo em alto nível do tutorial Mitigação de erros em escala de utilidade com amplificação probabilística de erros, que replica o resultado do artigo Evidence for the Utility of Quantum Computing Before Fault Tolerance. Recomendamos fortemente que você abra o tutorial referenciado junto com esta sessão.

Agora vamos examinar um exemplo concreto de um artigo altamente influente publicado pela IBM em 2023, intitulado Evidence for the Utility of Quantum Computing Before Fault Tolerance, frequentemente referido como o "artigo de Utilidade".

Com seu lançamento, esse trabalho rapidamente se tornou um estudo marcante na comunidade de computação quântica. Sua tese central é que um computador quântico ruidoso, utilizando 127 qubits e 2.880 portas, pode produzir valores de expectativa precisos para circuitos quânticos que estão além do alcance dos métodos clássicos de simulação de força bruta, que tentam uma simulação exata dos mesmos circuitos.

Esse estudo foi particularmente significativo porque demonstrou que os computadores quânticos podem ser usados para verificar ou comparar resultados com métodos aproximados de simulação clássica, como algoritmos de rede tensorial — especialmente em cenários onde a solução exata é desconhecida de antemão.

Outro aspecto notável desse trabalho é que foi amplamente reproduzido: pesquisadores e usuários agora têm a capacidade de replicar e verificar o experimento usando os sistemas quânticos acessíveis via nuvem da IBM e o framework de software Qiskit. A seguir, vamos guiá-lo pelos passos para realizar essa replicação por conta própria, revisando o tutorial da IBM passo a passo.

Nesta aula, discutimos os passos específicos necessários para traduzir o problema em entradas que um dispositivo quântico possa processar. Focamos em simular a dinâmica da magnetização total em um sistema de spins de dipolo magnético dispostos em uma rede, submetidos a um campo magnético externo. Esse sistema pode ser descrito por um modelo de Ising com um campo magnético transversal. Nós o representamos usando um circuito quântico parametrizado, onde os parâmetros correspondem aos valores ajustáveis das interações spin-spin ($ZZ$) e a intensidade do campo magnético externo transversal ($B_x$, parametrizado usando $X$).

Como esta série se chama Computação Quântica na Prática, vamos cobrir detalhes adicionais das técnicas experimentais usadas para melhorar a qualidade dos resultados. Um procedimento importante envolve identificar e remover qubits "ruins" — aqueles com baixas fidelidades de porta ou tempos de decoerência curtos — que poderiam impactar significativamente o resultado do experimento. Esses qubits problemáticos podem surgir de calibração ruim ou interações com sistemas de dois níveis (TLS). Remover esses qubits altera a topologia nativa do hardware, mudando efetivamente a rede na qual o sistema é simulado.

Além disso, vamos discutir como construir o circuito quântico parametrizado que implementa a evolução temporal do sistema usando Trotterização. Uma parte fundamental desse processo é identificar camadas de entrelaçamento dentro do circuito, que desempenham um papel crucial na principal técnica de mitigação de erros.

Passo 1 dos padrões Qiskit: Mapear

O tutorial realiza a etapa de mapeamento de forma semelhante à abordagem geral descrita acima. Específico para esse problema, o tutorial faz o seguinte:

• Cria um circuito de modelo de Ising parametrizado
• Cria camadas de entrelaçamento e remove qubits ruins
• Gera uma versão trotterizada do circuito

No tutorial, começamos criando uma série de funções auxiliares no início do notebook. Essas funções são projetadas para simplificar o processo à medida que avançamos. Não são uma parte obrigatória do procedimento, mas essa é uma boa prática comum ao trabalhar em experimentos semelhantes: dividir o problema em componentes gerenciáveis. As funções incluem

• Remover acoplamentos de qubits
• Definir acoplamentos de qubits
• Construir os acoplamentos de camadas
• Construir a camada de entrelaçamento
• Definir o circuito trotterizado

Aqui, vamos explorar tópicos relacionados a essas funções um pouco mais. Acoplamentos de camadas

Os acoplamentos de camadas definem como os qubits interagem com seus vizinhos durante a simulação. Nossos dispositivos quânticos utilizam um layout hexagonal pesado, um padrão distinto para conectar qubits. Dentro desse layout, as conexões entre qubits — conhecidas como "arestas" — podem ser divididas em três conjuntos distintos. Importante, nenhuma duas conexões no mesmo conjunto compartilham um qubit. Essa organização aborda uma restrição fundamental do hardware: em um computador quântico real, um qubit pode participar de apenas uma porta de dois qubits em qualquer momento dado.

Ao estruturar todas as conexões em três camadas separadas, as portas de dois qubits podem ser aplicadas em todo o dispositivo em três rodadas sucessivas. Isso garante que nenhum qubit esteja envolvido em mais de uma porta por camada. Essas portas implementam a interação ZZ no modelo de Ising, e são repetidas em cada passo de tempo da simulação (cada passo de Trotter).

Além disso, uma técnica chamada twirling é empregada para modificar as características de ruído no dispositivo. O twirling transforma o ruído de tal forma que mesmo modelos de ruído simples se tornam representações mais precisas dos erros físicos. Esse refinamento permite uma caracterização mais precisa do ruído, que pode então ser aproveitada para melhorar as estratégias de mitigação de erros. Removendo qubits "ruins"

O próximo passo envolve remover os qubits "ruins" da lista de qubits físicos disponíveis para o experimento. Um qubit pode se tornar "ruim" por vários motivos. Às vezes é simplesmente uma questão de calibração ruim, que pode ser corrigida por recalibração. Em outros casos, o problema é mais complexo e relacionado ao que é conhecido como defeito de sistema de dois níveis (TLS). Esses defeitos TLS causam flutuações nos parâmetros dos qubits e relaxamento. Resolver isso geralmente requer aquecer todo o sistema e depois resfriá-lo novamente — um processo que pode levar algum tempo e não é viável ao acessar hardware quântico remotamente pela nuvem.

Por enquanto, a abordagem mais simples é excluir esses qubits problemáticos do conjunto de qubits físicos que serão usados no experimento. A Plataforma IBM Quantum® facilita identificar quais qubits estão com desempenho abaixo do esperado em um QPU. Você pode abrir o QPU e visualizar suas características diretamente na plataforma ou baixar os dados da plataforma como um arquivo CSV. Em seguida, crie uma lista de qubits a excluir e remova-os do conjunto total de qubits físicos no dispositivo.

Remover qubits não confiáveis garante que o comportamento do sistema seja mais previsível, o que melhora a precisão do experimento. Também permite uma melhor modelagem de ruído, que é essencial para implementar estratégias eficazes de mitigação de erros. Circuito trotterizado

Agora é hora de construir nosso circuito trotterizado. Como discutido anteriormente, a Trotterização divide a evolução temporal em passos discretos, portanto precisamos escolher quantos passos usar. Para este exemplo, selecionaremos seis passos. Geralmente, a abordagem envolve equilibrar o erro de Trotter — um erro de aproximação introduzido pelo algoritmo — com erros causados pela decoerência. Aumentar o número de passos de Trotter reduz o erro de aproximação, mas requer circuitos quânticos mais profundos, que são mais suscetíveis ao ruído de decoerência.

O circuito será definido usando vários parâmetros: o parâmetro theta representando a intensidade do campo magnético externo, os acoplamentos entre camadas, o número de passos, o número de qubits e, é claro, a escolha do backend do dispositivo. Como a magnetização do sistema depende da intensidade do campo magnético externo, é valioso executar a simulação em diferentes valores de campo magnético. Essa variação corresponde a diferentes ângulos de rotação para a porta RX no circuito.

from qiskit.circuit import Parameter

num_steps = 6           #Trotter steps
theta = Parameter("theta")
circuit = trotter_circuit(
        theta, layer_couplings, num_steps, qubits = good_qubits, backend = backend
)
num_params = 12

# 12 parameter values for Rx between [0,p/2].
#Reshape to outer product broadcast with observables

parameter_values = np.linespace(0,np.pi/2,num_params).reshape((num_params,1))
num_params = parameter_values.size

Passo 2 dos padrões Qiskit: Otimizar

Agora que geramos nosso circuito, o próximo passo é otimizá-lo. A primeira parte desse processo envolve definir um gerenciador de passagens. No contexto do SDK Qiskit, a transpilação é o processo de transformar um circuito de entrada em uma forma adequada para execução em um dispositivo quântico. Essa transformação acontece por meio de uma sequência de etapas conhecidas como passagens do transpilador. Um gerenciador de passagens é um objeto que contém uma lista dessas passagens do transpilador e pode aplicá-las a um circuito. Para criar um, você inicializa um PassManager com a lista desejada de passagens do transpilador. Em última análise, o gerenciador de passagens produz um circuito ISA — um circuito expresso em termos da Arquitetura de Conjunto de Instruções (ISA) do backend. Isso significa que o circuito é representado usando portas que são nativas ao hardware do backend, embora ainda não inclua as informações de temporização necessárias para executar o circuito no dispositivo.

Passo 3 dos padrões Qiskit: Executar usando primitivas

Agora é hora de executar nosso circuito. Vamos usar o Estimator como nossa ferramenta principal para este experimento porque nosso objetivo é medir a magnetização total do sistema. O Estimator é especificamente projetado para estimar os valores de expectativa de observáveis, tornando-o a escolha ideal aqui. Neste estágio, também é essencial configurar nossas definições de mitigação de erros. Vamos aplicar a Extrapolação de Ruído Zero (ZNE) para melhorar a precisão dos nossos resultados. No tutorial, você vai ver que especificamos dois ou mais valores de fator de ruído nos quais avaliar os modelos extrapolados, e selecionamos a "Amplificação Probabilística de Erros" (PEA) como nosso método de amplificação. O PEA é preferível para este experimento porque escala significativamente melhor do que outras opções, o que é crucial ao trabalhar com sistemas de 100 ou mais qubits.

Isso é tudo que é necessário para executar o experimento.

Interlúdio sobre mitigação de erros

Antes de prosseguirmos para o pós-processamento, vamos tomar um breve momento para esclarecer o que se entende por Extrapolação de Ruído Zero (ZNE). Abordamos esse conceito em episódios anteriores, mas vale a pena revisar brevemente. O ZNE é uma técnica de mitigação de erros projetada para reduzir o impacto do ruído desconhecido que ocorre durante a execução de circuitos quânticos, desde que esse ruído possa ser escalonado de forma controlada. O método baseia-se na suposição de que os valores de expectativa escalam com o ruído de acordo com uma função conhecida:

$$\langle A(\lambda)\rangle = \langle A(0)\rangle + \sum_{k=0}^m {a_k \lambda^k}+R,$$

onde $λ$ representa a intensidade do ruído, que pode ser amplificada intencionalmente.

O processo de implementação do ZNE consiste nas seguintes etapas:

1. Amplificar o ruído do circuito para vários fatores de ruído $λ_1$, $λ_2$, … .
2. Executar cada circuito com ruído amplificado para medir os valores de expectativa correspondentes $\langle A(\lambda_1)\rangle$, $\langle A(\lambda_2)\rangle$, ….
3. Extrapolar esses resultados de volta ao limite de ruído zero $\langle A(\lambda_0)\rangle$.

Essa técnica nos permite estimar qual seria o resultado se não houvesse ruído, melhorando a precisão das computações quânticas.

O principal desafio em implementar o ZNE efetivamente é desenvolver um modelo de ruído preciso para o valor de expectativa e amplificar o ruído de forma controlada e bem compreendida. As técnicas comuns de amplificação de erros no ZNE incluem escalamento da duração do pulso por meio de calibração, repetição de portas usando ciclos de identidade e adição de ruído via amostragem de canais de Pauli — um método conhecido como Amplificação Probabilística de Erros (PEA).

Entre estes, o PEA é frequentemente a escolha preferida por várias razões:

• O alongamento de pulsos incorre em um alto custo computacional.
• O dobramento de portas, que usa inserções de identidade, carece de garantias teóricas fortes para preservar o viés de ruído.
• O PEA é aplicável a qualquer circuito executado com um fator de ruído nativo, embora requeira aprender o modelo de ruído com antecedência.

O PEA opera sob a suposição de um modelo de ruído baseado em camadas semelhante ao usado no cancelamento probabilístico de erros (PEC). No entanto, ao contrário do PEC, ele evita a sobrecarga de amostragem exponencial que normalmente cresce com o ruído do circuito. Essa eficiência torna o PEA uma abordagem prática e robusta para amplificação de ruído no ZNE, facilitando uma mitigação de erros quânticos mais confiável. Para caracterizar o modelo de ruído, primeiro precisamos identificar as camadas distintas de operações de dois qubits dentro do circuito. Para cada uma dessas camadas, aplicamos um procedimento de twirling de Pauli às portas de dois qubits, o que ajuda a garantir que o ruído possa ser descrito com precisão por um modelo de ruído de amortecimento. Em seguida, repetimos pares de camadas de identidade em várias profundidades e, finalmente, ajustamos os valores de fidelidade para determinar as taxas de erro para cada canal de ruído.

Embora seja benéfico entender esse método conceitualmente, implementá-lo manualmente no Qiskit é muito mais simples, como demonstrado no tutorial que acompanha.

Passo 4 dos padrões Qiskit: Pós-processar

Após o experimento terminar, você pode ver o resultado pós-processando-o. A linha pontilhada cinza nos dados plotados representa os resultados obtidos usando métodos clássicos aproximados, com o erro de aproximação reduzido a um baixo limiar. Os pontos de dados brutos para os vários fatores de ruído, selecionados no início, estão claramente deslocados dessa linha pontilhada. Em contraste, a linha azul sólida exibe os dados após aplicar nosso processamento ZNE, que visivelmente aproxima os resultados dos valores exatos. Em resumo, os valores obtidos sob condições normais de ruído (fator de ruído nf=1.0) mostram desvio significativo dos resultados exatos. Enquanto isso, os valores mitigados se alinham estreitamente com os exatos, demonstrando a eficácia da técnica de mitigação de ruído baseada em PEA.

Resumo

Para resumir rapidamente o que aprendemos:

• A simulação quântica é uma das áreas de aplicação mais promissoras no curto a médio prazo.
• Tem aplicações de amplo espectro, de produtos farmacêuticos à física de altas energias, ciência de materiais e muito mais.
• O artigo de Utilidade da IBM, publicado em 2023, apontou o caminho para poder usar computadores quânticos para descobertas científicas, e trabalhamos no tutorial associado que acompanha esse artigo.
• Os passos para resolver um problema de simulação do início ao fim são relativamente diretos, e esperamos que você possa agora usar este vídeo e tutorial como guia para ainda mais problemas de simulação.

Pesquisa pós-curso

Parabéns por completar este curso! Reserve um momento para nos ajudar a melhorar nosso curso preenchendo a seguinte pesquisa rápida. Seu feedback será usado para aprimorar nossa oferta de conteúdo e experiência do usuário. Obrigado!