IBM on kenji.blog

Uma Super Introdução à Programação Quântica usando Qiskit

Fri, 11 Sep 2026 20:00:00 +0900

1. Introdução

Os computadores modernos (computadores clássicos) mudaram drasticamente as nossas vidas, apoiando todos os aspectos da sociedade através de seu alto poder computacional. No entanto, sabe-se que para certos problemas específicos (como a fatoração de números primos gigantescos, a simulação de estruturas moleculares complexas, problemas de otimização, etc.), mesmo os supercomputadores mais avançados da atualidade precisariam de um tempo superior à idade do universo para resolvê-los.

O que possui o potencial para quebrar esses “limites dos computadores clássicos” é o computador quântico (Quantum Computer). Acredita-se que, utilizando propriedades fascinantes da mecânica quântica (sobreposição e emaranhamento quântico) como recursos computacionais, é possível acelerar drasticamente a resolução de determinados problemas.

Neste artigo, daremos o primeiro passo no mundo da programação quântica utilizando o Qiskit, um framework de computação quântica de código aberto fornecido pela IBM. Este é um guia de introdução extremamente detalhado, cobrindo tudo de forma minuciosa, desde os fundamentos da física e da matemática, até escrever código na prática em Python e executar circuitos quânticos em um simulador.

2. Fundamentos de Física e Matemática que Sustentam a Computação Quântica

Para compreender a programação quântica, é necessário primeiro entender os conceitos fundamentais da mecânica quântica. Aqui, explicaremos três pilares importantes: qubits, sobreposição e emaranhamento quântico.

2.1 Bits Clássicos e Qubits (Quantum bits)

A unidade de informação de um computador clássico é o “bit (Bit)”. Um bit sempre assume um de dois estados: 0 ou 1.

Por outro lado, a menor unidade de informação de um computador quântico é chamada de qubit (Qubit: Quantum bit). Um qubit não só pode assumir o estado 0 ou 1, mas também é capaz de manter ambos os estados simultaneamente.

Matematicamente, o estado de um qubit $|\psi\rangle$ é expresso como uma combinação linear (sobreposição) dos estados base $|0\rangle$ e $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Aqui, $\alpha$ e $\beta$ são números complexos e representam as amplitudes de probabilidade de observar os estados $|0\rangle$ e $|1\rangle$, respectivamente. Com base nos princípios fundamentais da mecânica quântica, a soma das probabilidades deve ser 1, de modo que satisfaçam a seguinte condição de normalização:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Isso significa que, quando este qubit é “medido (observado)”, a probabilidade de se obter $|0\rangle$ é $|\alpha|^2$ e a probabilidade de se obter $|1\rangle$ é $|\beta|^2$. O fato de que o estado é determinado apenas de forma probabilística antes da medição é a diferença crucial em relação aos bits clássicos.

graph LR A["Bit Clássico (Classical Bit)"] --> B["Estado determinado: 0 ou 1"] C["Qubit (Quantum bit)"] --> D["Sobreposição: ambos 0 e 1"] D --> E["O estado é determinado probabilisticamente pela medição"]

2.2 Sobreposição (Superposition)

Como mencionado anteriormente, o estado onde $|0\rangle$ e $|1\rangle$ estão misturados é chamado de sobreposição (Superposition).

Por exemplo, quando um qubit está em um estado de sobreposição perfeitamente uniforme, temos $\alpha = \frac{1}{\sqrt{2}}$ e $\beta = \frac{1}{\sqrt{2}}$.

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

Quando medimos este estado, $|0\rangle$ e $|1\rangle$ são observados com 50% de probabilidade cada. Se tivermos 2 qubits, podemos criar uma sobreposição de 4 estados: $|00\rangle, |01\rangle, |10\rangle, |11\rangle$. Com $n$ qubits, $2^n$ estados podem ser representados simultaneamente, e essa é uma das fontes do poder de processamento paralelo dos computadores quânticos.

2.3 Emaranhamento Quântico (Entanglement)

A propriedade mais poderosa e misteriosa da computação quântica é o emaranhamento quântico (Entanglement). Este fenômeno, que Einstein chamou de “ação fantasmagórica à distância”, é a propriedade em que dois ou mais qubits se tornam fortemente interligados, de modo que quando o estado de um qubit é determinado, o estado do outro qubit é determinado instantaneamente, independentemente da distância física que os separe.

Um dos mais famosos estados de emaranhamento quântico, o “Estado de Bell (Bell State)” $\Phi^+$, é expresso da seguinte forma:

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

Neste estado, os estados $|01\rangle$ e $|10\rangle$ não existem. Portanto, se o primeiro qubit for medido e resultar em $|0\rangle$, é certo que o segundo qubit também será $|0\rangle$, sem nem mesmo precisar medi-lo. Inversamente, se o primeiro for $|1\rangle$, o segundo também será necessariamente $|1\rangle$.

3. Portas Lógicas Quânticas (Quantum Logic Gates)

Assim como computadores clássicos usam portas lógicas como AND, OR e NOT para realizar cálculos, os computadores quânticos usam portas quânticas para manipular o estado dos qubits. Como um estado quântico é um vetor, uma porta quântica é representada como uma “matriz unitária” que atua nesse vetor.

3.1 Portas de Pauli (Pauli-X, Y, Z)

As portas de Pauli são operações básicas em um único qubit.

・Porta Pauli-X (Porta NOT) Equivale à porta NOT clássica. Inverte o estado $|0\rangle$ para $|1\rangle$, e $|1\rangle$ para $|0\rangle$. (Rotação de 180 graus em torno do eixo X na Esfera de Bloch).

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

・Porta Pauli-Y Realiza uma rotação de 180 graus em torno do eixo Y. Tem o efeito de inverter tanto a fase quanto o bit.

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Porta Pauli-Z (Porta de inversão de fase) Mantém o estado $|0\rangle$ como está, e inverte a fase (multiplica por $-1$) do estado $|1\rangle$. (Rotação de 180 graus em torno do eixo Z).

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

3.2 Porta Hadamard (Hadamard Gate)

A porta Hadamard (Porta H) é uma porta extremamente importante que converte estados definidos ($|0\rangle$ ou $|1\rangle$) em estados de sobreposição.

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

Aplicando a porta H a $|0\rangle$, obtemos $|+\rangle$, que é um estado de sobreposição uniforme.

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 Portas de Fase (Phase Gates)

A porta de fase é uma generalização da porta Z, que gira a fase do estado $|1\rangle$ por um ângulo especificado $\theta$.

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

Exemplos típicos são a porta S ($\theta = \pi/2$) e a porta T ($\theta = \pi/4$).

3.4 Porta CNOT (Controlled-NOT Gate)

A porta CNOT (Porta CX) opera entre dois qubits e é essencial para criar emaranhamento quântico. Consiste em um “bit de controle (Control)” e um “bit alvo (Target)”.

Aplica-se uma porta X (operação NOT) no bit alvo apenas se o bit de controle for $|1\rangle$, e não faz nada se o bit de controle for $|0\rangle$.

$$ CNOT = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

4. Noções Básicas e Configuração do Ambiente Qiskit

A partir daqui, vamos de fato usar Python e Qiskit para escrever um programa quântico.

4.1 O que é o Qiskit?

Qiskit é um kit de desenvolvimento de software (SDK) de código aberto para computação quântica desenvolvido pela IBM Quantum. Ele permite construir circuitos quânticos intuitivamente usando Python e executá-los em um simulador local ou em um computador quântico real da IBM através da nuvem.

4.2 Como Instalar

Para usar o Qiskit, é necessário um ambiente Python. Você pode instalar o Qiskit e pacotes relacionados (como simuladores e bibliotecas de visualização) com o seguinte comando:

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 Fluxo Básico de Programação

A programação quântica usando o Qiskit prossegue principalmente nas seguintes etapas:

graph TD A["1. Construção do Circuito (Build)"] --> B["2. Compilação/Transpilação (Compile)"] B --> C["3. Execução (Execute)"] C --> D["4. Análise e Visualização dos Resultados (Analyze)"]

Construção do Circuito: Criar um objeto QuantumCircuit e adicionar portas a ele.
Compilação: Otimizar o circuito de acordo com o backend (hardware real ou simulador) onde será executado.
Execução: Enviar o trabalho (job) para o backend e obter os resultados.
Análise: Plotar um histograma dos resultados da medição, etc.

5. Prática: Construindo um Circuito para Criar um Estado de Bell (Emaranhamento Quântico)

Vamos agora usar o Qiskit para criar na prática o “emaranhamento quântico (Estado de Bell)” que aprendemos na teoria. O estado alvo é $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$.

5.1 Projeto do Circuito

Para criar o estado de Bell, seguiremos os seguintes passos:

Preparar 2 qubits (ambos inicialmente no estado $|0\rangle$).
Aplicar a porta Hadamard (H) ao primeiro qubit para colocá-lo em um estado de sobreposição.
Aplicar a porta CNOT, usando o primeiro qubit como “bit de controle” e o segundo qubit como “bit alvo”.
Realizar a medição (Measure) para ler os resultados.

5.2 Implementação do Código em Python/Qiskit

Vejamos agora o código real.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. Inicialização do Circuito
# Criar um circuito quântico com 2 qubits e 2 bits clássicos
qc = QuantumCircuit(2, 2)

# 2. Aplicação da porta H
# Aplicar a porta Hadamard ao qubit 0 (q0)
qc.h(0)

# 3. Aplicação da porta CNOT
# Aplicar CNOT usando q0 como bit de controle e q1 como bit alvo
qc.cx(0, 1)

# 4. Medição
# Medir os qubits 0 e 1, e escrever os resultados nos bits clássicos 0 e 1, respectivamente
qc.measure([0, 1], [0, 1])

# Desenhar o diagrama do circuito (usando matplotlib)
# qc.draw('mpl')
print(qc.draw())

Ao executar este código, o seguinte diagrama de circuito quântico será exibido em arte ASCII no console:

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H representa a porta Hadamard, a combinação de ■ e X representa a porta CNOT, e M representa a medição.

5.3 Execução no Simulador e Interpretação dos Resultados

Em seguida, executaremos este circuito no simulador de alto desempenho da IBM, Aer, e verificaremos os resultados.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Obter o backend do simulador Aer
simulator = Aer.get_backend('qasm_simulator')

# Transpilar (otimizar) o circuito para o simulador
compiled_circuit = transpile(qc, simulator)

# Executar o circuito (aqui, realizamos 1000 execuções ou "shots")
job = simulator.run(compiled_circuit, shots=1000)

# Obter o resultado
result = job.result()

# Obter a contagem de vezes que cada estado foi observado
counts = result.get_counts(compiled_circuit)
print("\nResultados da medição:", counts)

# Plotar o histograma
# plot_histogram(counts)
# plt.show()

Interpretação dos Resultados

A saída do console deve ser algo semelhante a isto: Resultados da medição: {'00': 495, '11': 505} (Nota: como as probabilidades são aleatórias, os números variam ligeiramente a cada execução)

Em um ambiente de simulação ideal, os resultados da medição mostrarão 00 e 11 sendo observados com cerca de 50% de probabilidade cada um, e 01 e 10 não serão observados em absoluto. Isto corresponde perfeitamente à previsão teórica para o estado de Bell $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ que criamos. O “emaranhamento quântico” foi simulado com precisão, confirmando que se o primeiro qubit for 0, o segundo também será necessariamente 0, e se o primeiro for 1, o segundo também será necessariamente 1.

No entanto, se for executado em um hardware quântico real (IBM Quantum Hardware), os estados 01 ou 10 podem ser levemente observados devido à influência de ruídos (decoerência quântica e erros de portas). Como reduzir esse ruído (correção de erros quânticos) é atualmente um dos maiores desafios no desenvolvimento de computadores quânticos.

6. Escalando para Algoritmos Mais Avançados

A criação do estado de Bell pode ser considerada o “Hello World” da programação quântica. Ao nos desenvolvermos a partir daqui, podemos construir algoritmos poderosos que superam os computadores clássicos.

6.1 Algoritmo de Deutsch-Jozsa (Deutsch-Jozsa Algorithm)

Este é um problema para determinar se uma dada função $f(x)$ é “constante” (sempre gera 0 ou sempre 1 independentemente da entrada) ou “balanceada” (gera 0 para metade das entradas e 1 para a outra metade). Em um computador clássico, no pior dos casos, seriam necessárias $2^{n-1} + 1$ avaliações da função, mas usando o algoritmo de Deutsch-Jozsa, podemos usar o paralelismo quântico para determinar a resposta com apenas 1 avaliação. Isto demonstra o padrão básico de algoritmos quânticos: inserir um estado de sobreposição e usar a interferência (Interference) para cancelar estados indesejados e amplificar a resposta desejada.

6.2 Algoritmo de Grover (Grover’s Algorithm)

Em um problema de busca onde procuramos por dados específicos em um banco de dados não ordenado de $N$ itens, um algoritmo clássico requer em média $N/2$ cálculos, enquanto o algoritmo de Grover pode encontrar os dados desejados em cerca de $\sqrt{N}$ vezes. Este algoritmo usa uma caixa preta chamada “Oráculo (Oracle)” para inverter a fase da solução desejada e, em seguida, realiza uma “Amplificação de Amplitude (Amplitude Amplification)”, o que aumenta drasticamente a probabilidade de a solução desejada ser observada.

graph TD A["Inicialização (Sobreposição de todos os estados)"] --> B["Oráculo (Inversão da fase da resposta correta)"] B --> C["Operador de difusão (Amplificação da amplitude por inversão em torno da média)"] C --> D{"Alcançou uma probabilidade suficiente?"} D -- "Não" --> B D -- "Sim" --> E["Medição"]

7. Conclusão e Próximos Passos no Aprendizado

Neste artigo, explicamos detalhadamente, desde os conceitos fundamentais da computação quântica como sobreposição e emaranhamento quântico, passando pela manipulação de portas lógicas quânticas usando o Qiskit, até a construção, simulação prática de um estado de Bell e interpretação de seus resultados.

O Qiskit é uma ferramenta poderosa que, por poder ser escrita em uma linguagem familiar como o Python, permite superar barreiras matemáticas e físicas para que você possa se concentrar na construção de algoritmos. Os computadores quânticos estão atualmente na era dos Dispositivos Quânticos Ruidosos de Escala Intermediária (NISQ: Noisy Intermediate-Scale Quantum), mas a pesquisa aplicada está avançando rapidamente ao redor do mundo em muitos campos, como Aprendizado de Máquina Quântico (Quantum Machine Learning), Simulação Química (Quantum Chemistry) e Criptografia.

Por favor, aproveite esta oportunidade para criar por conta própria vários circuitos quânticos usando o Qiskit e tente executá-los em processadores reais do IBM Quantum. Você certamente poderá experimentar com as próprias mãos o paradigma da computação do futuro.

Materiais de Referência

Documentação Oficial do Qiskit
Qiskit Textbook - Um livro didático oficial recomendado para quem deseja aprender mais profundamente os fundamentos matemáticos e os algoritmos (disponível em vários idiomas).
IBM Quantum Learning

Bem-vindo ao mundo quântico!

O que é Supremacia Quântica? As últimas tendências do Google e da IBM

Fri, 11 Sep 2026 18:00:00 +0900

1. Introdução: O Amanhecer da Computação Quântica e a “Supremacia Quântica”

A computação quântica tem o potencial de resolver problemas complexos, que não podem ser resolvidos em um tempo realista por computadores clássicos (os PCs e supercomputadores que usamos diariamente hoje), aplicando a mecânica quântica, o princípio fundamental da física, ao processamento de informações. Este campo tem sido predominantemente de pesquisa teórica por muito tempo, mas nos últimos anos, o rápido avanço do hardware tem intensificado a competição pela sua aplicação prática.

Nesse contexto, uma das palavras-chave que mais chamou a atenção foi “Supremacia Quântica” (Quantum Supremacy). Isso se refere ao momento em que um computador quântico demonstra uma capacidade de computação que supera a de um computador clássico em uma tarefa de cálculo específica. Neste artigo, partindo da definição rigorosa de supremacia quântica, explicaremos em detalhes o experimento do processador “Sycamore” do Google, que anunciou ter alcançado este marco pela primeira vez no mundo em 2019, as contra-argumentações e abordagens únicas da IBM em relação a isso, e o mais recente roteiro para a “Correção Quântica de Erros” (Quantum Error Correction: QEC) e a “Computação Quântica Tolerante a Falhas” (Fault-Tolerant Quantum Computing: FTQC), que são as maiores barreiras para a verdadeira aplicação prática, aprofundando-se nos aspectos técnicos e matemáticos.

2. Antecedentes Teóricos: Fundamentos da Computação Quântica e Classes de Complexidade

Para entender a supremacia quântica, é primeiro necessário entender os fundamentos matemáticos da computação quântica e seu posicionamento na teoria da complexidade computacional.

Qubits e Sobreposição

A menor unidade de informação em um computador clássico é o bit (0 ou 1), mas em um computador quântico, utiliza-se o qubit (Qubit). O estado de um único qubit $|\psi\rangle$ é representado por uma combinação linear complexa dos estados de base $|0\rangle$ e $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Onde $\alpha, \beta \in \mathbb{C}$, e satisfaz a condição de normalização $|\alpha|^2 + |\beta|^2 = 1$. Esta propriedade é chamada de “Sobreposição” (Superposition).

Emaranhamento (Entanglement) e Produto Tensorial

Quando existem múltiplos qubits, o estado de todo o sistema é representado pelo produto tensorial dos espaços de estados dos qubits individuais. Um sistema de $n$ qubits é um vetor em um espaço de Hilbert $\mathcal{H}^{\otimes n}$ de $2^n$ dimensões.

$$ |\Psi\rangle = \sum_{x \in \{0, 1\}^n} c_x |x\rangle $$

Onde $\sum |c_x|^2 = 1$. O estado em que os qubits não são independentes entre si e o estado de um depende do outro é chamado de “Emaranhamento Quântico” (Quantum Entanglement). Isso dá aos computadores quânticos o potencial de processar simultaneamente um espaço de estados exponencialmente vasto.

Definição na Teoria da Complexidade Computacional da Supremacia Quântica

Na teoria da complexidade computacional, a classe de problemas que um computador clássico pode resolver eficientemente (em tempo polinomial) é chamada de BPP (Bounded-error Probabilistic Polynomial time). Por outro lado, a classe de problemas que um computador quântico pode resolver eficientemente é a BQP (Bounded-error Quantum Polynomial time).

A demonstração da supremacia quântica significa “executar uma tarefa específica incluída em BQP, mas não incluída em BPP (ou com uma probabilidade extremamente alta de não ser), em hardware quântico real e superar a simulação por supercomputadores clássicos em termos de tempo e recursos”. Pode-se dizer que é uma tentativa histórica de refutar a tese de Church-Turing estendida (“todos os modelos de computação fisicamente realizáveis podem ser simulados eficientemente por uma máquina de Turing probabilística em tempo polinomial”) por meio de um experimento físico.

3. 2019: Demonstração da Supremacia Quântica pelo Google

Em outubro de 2019, a equipe do Google Quantum AI anunciou na revista científica “Nature” que havia alcançado a supremacia quântica usando o processador supercondutor de 53 qubits “Sycamore”.

Arquitetura do Processador Sycamore

O processador Sycamore consiste em 54 qubits supercondutores do tipo Transmon dispostos em uma grade bidimensional (no experimento, 53 foram usados devido ao mau funcionamento de um). Acopladores variáveis (Tunable Couplers) foram colocados entre qubits adjacentes, realizando portas de 2 qubits (um híbrido de portas iSWAP e portas Z controladas) de alta velocidade e alta precisão.

graph TD A["Entrada de Algoritmo Quântico"] --> B["Processador Sycamore (53 Qubits)"] B --> C["Aplicar Portas Quânticas Aleatórias"] C --> D["Medir Estados Quânticos (Cadeias de Bits)"] D --> E["Benchmarking de Entropia Cruzada (XEB)"] E --> F["Verificar Supremacia Quântica"]

Amostragem de Circuito Quântico Aleatório (Random Circuit Sampling: RCS)

A tarefa escolhida pelo Google foi a “amostragem de circuito quântico aleatório”. Isso envolve a aplicação de portas de um único qubit e portas de dois qubits escolhidas aleatoriamente ao longo de vários ciclos (profundidade $m$) e, em seguida, a realização de amostragem a partir da distribuição de probabilidade das cadeias de bits obtidas medindo o estado final.

A probabilidade de uma cadeia de bits $x$ ser produzida por um circuito quântico aleatório ideal (sem ruído) não é uma distribuição uniforme, mas mostra um padrão semelhante a franjas de interferência chamado distribuição de Porter-Thomas. Para amostrar dessa distribuição em um computador clássico, é necessária a simulação de todo o vetor de estado, e a complexidade computacional aumenta exponencialmente com o número de qubits $n$ e a profundidade do circuito $m$.

Avaliação de Fidelidade (Fidelity): Benchmarking de Entropia Cruzada Linear (XEB)

Para provar que os resultados do experimento não eram mero ruído, mas os resultados de cálculos quânticos reais, o Google usou o benchmarking de entropia cruzada linear (Linear Cross-Entropy Benchmarking: XEB). Eles calcularam a probabilidade ideal $P(x_i)$ do circuito para a cadeia de bits $x_i$ obtida no experimento usando um computador clássico e calcularam a fidelidade $\mathcal{F}_{\text{XEB}}$ com a seguinte fórmula:

$$ \mathcal{F}_{\text{XEB}} = 2^n \langle P(x_i) \rangle_{i} - 1 $$

Se $\mathcal{F}_{\text{XEB}}$ for 0, significa ruído puro, e se for 1, significa um processador quântico ideal sem ruído. O processador Sycamore alcançou $\mathcal{F}_{\text{XEB}} \approx 0.002$ (0,2%) em um circuito de profundidade 20. Embora pareça baixo à primeira vista, é um valor estatisticamente significativo maior que zero, sendo uma conquista impressionante de controle de um espaço de estados de $2^{53} \approx 9 \times 10^{15}$.

A taxa de erro geral foi modelada de forma aproximada como o produto de erros de portas individuais, erros de medição, etc.

$$ \mathcal{F} \approx (1 - e_1)^{N_1}(1 - e_2)^{N_2} \cdots \approx \prod_{g \in 1Q} (1 - e_g) \prod_{g \in 2Q} (1 - e_g) \prod_{q} (1 - e_{RO}) $$

（※ Onde $e_g$ é o erro da porta e $e_{RO}$ é o erro de medição）

O Google argumentou que levaria cerca de 10.000 anos para simular esse circuito em um supercomputador clássico (Summit). Em contraste, o Sycamore completou a amostragem em apenas 200 segundos.

4. A Contra-argumentação da IBM: Da “Supremacia” para a “Utilidade” (Utility)

O anúncio do Google chocou o mundo, mas a IBM, que desenvolveu o maior supercomputador do mundo, o “Summit”, e que também lidera o desenvolvimento de computadores quânticos, publicou rapidamente um artigo refutando essa afirmação.

Melhoria da Simulação Clássica pela Contração de Redes Tensoriais

O núcleo da contra-argumentação da IBM era que “a otimização de algoritmos e recursos no lado do computador clássico foi insuficiente”. O Google fez uma estimativa de 10.000 anos presumindo um simulador de vetor de estado que calcula diretamente a evolução temporal da equação de Schrödinger, mas a IBM apontou que o tempo de simulação poderia ser drasticamente reduzido pelo uso de um método chamado “Redes Tensoriais” (Tensor Network).

Nas redes tensoriais, as operações das portas do circuito quântico são representadas como operações de matrizes multidimensionais (tensores), e a ordem de “contração” (Contraction) da rede é otimizada. Além disso, eles argumentaram que, se a enorme capacidade de armazenamento de 250 PB do Summit (uma hierarquia de discos e memória) fosse totalmente utilizada, uma simulação de maior precisão seria possível em apenas “dois dias e meio”, mantendo todo o vetor de estado.

Vantagem Quântica (Quantum Advantage) e Utilidade Quântica (Quantum Utility)

Impulsionada por esse debate, a tendência de toda a indústria mudou da fixação em “executar uma tarefa artificial impossível em meios clássicos (Supremacia)” para “demonstrar uma vantagem substancial sobre a abordagem clássica em problemas úteis do mundo real (Vantagem Quântica)”, e ainda mais para a fase em que “os computadores quânticos funcionam como uma nova ferramenta para a descoberta científica (Utilidade Quântica)”.

A própria IBM evita o termo “supremacia” e propôs o “Volume Quântico” (Quantum Volume) e “CLOPS (Circuit Layer Operations Per Second)” como indicadores de desempenho abrangentes para processadores quânticos, promovendo o desenvolvimento com ênfase no equilíbrio entre a escala e a qualidade do hardware.

timeline title "A Evolução dos Marcos Quânticos" 2019 : "Google Sycamore (53Q)" : "Anúncio de Supremacia Quântica" 2019 : "Refutação da IBM" : "Simulação no supercomputador Summit em 2,5 dias" 2021 : "IBM Eagle (127Q)" : "Quebrando a barreira dos 100 qubits" 2022 : "IBM Osprey (433Q)" : "Avanço na escala do processador" 2023 : "Google Surface Code" : "Escalando a correção de erros (d=3 para d=5)" 2023 : "Utilidade Quântica da IBM" : "Simulação de modelo de spin complexo em 127Q" 2024 : "Além" : "Era dos Qubits Lógicos e Mitigação de Erros"

5. A Próxima Fronteira: Mitigação de Erros (Error Mitigation) e Correção Quântica de Erros (QEC)

Os computadores quânticos atuais são chamados de “NISQ (Noisy Intermediate-Scale Quantum)” e são suscetíveis a ruídos (erros devido à interação com o ambiente externo e controle imperfeito), de modo que, se cálculos longos forem executados, os resultados serão encobertos por ruídos. As abordagens para superar esse problema são amplamente divididas em “Mitigação de Erros” (Error Mitigation) e “Correção Quântica de Erros” (Quantum Error Correction).

Mitigação de Erros (Error Mitigation)

A mitigação de erros é um método para remover o efeito do ruído do valor esperado do resultado do cálculo por meio de pós-processamento clássico, sem alterar o hardware quântico. Em 2023, a IBM demonstrou a “Utilidade Quântica” combinando o processador “Eagle” de 127 qubits com técnicas de mitigação de erros, como a “Extrapolação de Ruído Zero” (Zero-Noise Extrapolation: ZNE), para alcançar uma precisão superior ao método avançado de aproximação de rede tensorial na simulação da evolução temporal de modelos complexos de Ising.

Correção Quântica de Erros (QEC) e Qubits Lógicos

No entanto, para executar algoritmos arbitrariamente complexos (por exemplo, o algoritmo de fatoração de Shor ou cálculos de química quântica complexos) em última análise, a mitigação de erros por si só não é suficiente, e a “Correção Quântica de Erros” (QEC), que detecta e corrige erros dinamicamente, é indispensável.

A principal abordagem em QEC é o “Código de Superfície” (Surface Code). Este é um método em que vários qubits físicos (qubits de dados) são dispostos em uma grade bidimensional, e qubits de medição (qubits de ancila) são colocados entre eles para realizar verificações de paridade contínuas chamadas “Estabilizadores” (Stabilizers).

graph LR Q1["Qubit de Dados (Dados)"] --- M1["Medir Estabilizador X (Ancila)"] Q2["Qubit de Dados (Dados)"] --- M1 Q3["Qubit de Dados (Dados)"] --- M2["Medir Estabilizador Z (Ancila)"] Q4["Qubit de Dados (Dados)"] --- M2 M1 --> EC["Decodificação de Síndrome de Erro (Clássico)"] M2 --> EC EC --> LQ["Atualização de Estado do Qubit Lógico"]

Teorema do Limiar (Threshold Theorem) e Distância $d$

Existe um “Teorema do Limiar” para a correção quântica de erros. Quando a taxa de erro $p$ dos qubits físicos está abaixo de um determinado limiar $p_{th}$ (em torno de 1% para o código de superfície), a taxa de erro lógico $p_L$ pode ser reduzida exponencialmente aumentando a distância (Distance) do código $d$ (alocando mais qubits físicos a um qubit lógico).

A fórmula de aproximação para a taxa de erro lógico é expressa da seguinte forma:

$$ p_L \approx \Lambda \left( \frac{p}{p_{th}} \right)^{\frac{d+1}{2}} $$

Onde $\Lambda$ é uma constante. Se $p < p_{th}$, quanto maior o valor de $d$, menor será $p_L$. No entanto, se $p > p_{th}$, o aumento do número de qubits físicos acumula mais ruído, piorando a taxa de erro lógico.

Marco do Google em 2023: Demonstração de Redução de Erros Ampliando a Distância

Em fevereiro de 2023, o Google publicou um artigo monumental na “Nature”. Eles usaram seu processador Sycamore de 3ª geração para demonstrar, pela primeira vez no mundo, que ao estender a distância do código de superfície de $d=3$ (usando 17 qubits físicos) para $d=5$ (usando 49 qubits físicos), a taxa de erro lógico diminuiu ligeiramente de 3,028% para 2,914%.

Isso significa que eles entraram no regime $p < p_{th}$, indicando a conclusão da mais importante Prova de Conceito (Proof of Concept) em direção à FTQC, onde o desempenho melhora à medida que o número de qubits físicos aumenta.

6. Roteiro e Perspectivas para FTQC (Computação Quântica Tolerante a Falhas)

Embora o Google e a IBM adotem arquiteturas e abordagens diferentes, eles estão envolvidos em uma competição acirrada de desenvolvimento em direção ao seu objetivo final: a FTQC (Fault-Tolerant Quantum Computing).

A Abordagem da IBM: Modularidade e Grade Heavy-Hex

A IBM está se concentrando em aumentar a escala de seus processadores em paralelo com a redução rigorosa da taxa de erro. Enquanto desafiam os limites de chips individuais com “Eagle (127Q)”, “Osprey (433Q)” e “Condor (1121Q)”, eles anunciaram uma arquitetura modular chamada “Quantum System Two”. Além disso, para a topologia de acoplamento dos qubits, eles adotaram uma “Grade Heavy-Hex”, que reduz o crosstalk (interferência) indesejado e melhora a estabilidade. A estratégia da IBM é uma abordagem híbrida: buscar a utilidade a curto prazo por meio da mitigação avançada de erros, ao mesmo tempo em que introduz a QEC em etapas.

A Abordagem do Google: Melhoria da Qualidade dos Qubits Lógicos

A estratégia do Google dá maior ênfase em reduzir drasticamente a taxa de erro de um único qubit lógico (por exemplo, reduzindo para $10^{-6}$), em vez de aumentar rapidamente o número de qubits físicos. Com base nisso, eles visam estabelecer tecnologia de transferência de estados quânticos entre módulos (Interconexões Quânticas) em direção a um sistema em grande escala que opera milhares a dezenas de milhares de qubits físicos em paralelo.

A implementação de protocolos para executar portas não Clifford, como a destilação de estados mágicos (Magic State Distillation), de maneira tolerante a falhas será um grande obstáculo tecnológico no futuro. Diz-se que a execução do algoritmo de Shor na prática para decifrar a criptografia RSA de 2048 bits exigirá milhares de qubits lógicos com uma taxa de erro de $10^{-8}$ ou inferior, o que se traduz em milhões a dezenas de milhões de qubits físicos, o que indica que o caminho ainda é longo.

7. Conclusão

A “Supremacia Quântica” foi um marco importante na história dos computadores quânticos, provando fisicamente o potencial teórico das máquinas de computação. A demonstração do Google em 2019 e a refutação construtiva da IBM impulsionaram a indústria inteira de uma prova puramente teórica para a busca pela utilidade real (Utility) e, finalmente, para a era de engenharia de larga escala voltada à Computação Quântica Tolerante a Falhas (FTQC).

Estamos atualmente testemunhando o período de transição de dispositivos NISQ ruidosos para dispositivos de qubits lógicos equipados com correção de erros. Nos próximos anos a décadas, a descoberta de novos materiais científicos, a revolução nos processos de descoberta de medicamentos e os avanços nos problemas de otimização se tornarão realidade junto com esta evolução do hardware quântico.

Devemos continuar de olho nas tendências do Google e da IBM, bem como dos pesquisadores em todo o mundo, à medida que moldam a ciência da computação do futuro.