Quantum Computing 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.

Como a blockchain e as criptomoedas mudarão na era pós-quântica?

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

1. Introdução: Os passos da era pós-quântica e a crise da blockchain

Desde a criação do Bitcoin por Satoshi Nakamoto em 2009, a tecnologia blockchain cresceu para se tornar a base de sistemas financeiros e aplicativos em todo o mundo como um “livro-razão descentralizado e à prova de adulteração”. Essa segurança robusta é sustentada pela criptografia moderna, especificamente a Criptografia de Chave Pública (Public Key Cryptography) e as Funções Hash Criptográficas (Cryptographic Hash Functions).

Essas tecnologias criptográficas garantem a segurança com base na “dificuldade computacional” matemática, segundo a qual computadores clássicos (os PCs e supercomputadores que usamos atualmente) levariam um tempo equivalente à idade do universo para decifrá-las.

No entanto, essa premissa está prestes a ser fundamentalmente derrubada pelo rápido desenvolvimento e implementação prática de Computadores Quânticos (Quantum Computers), a fronteira da física e da ciência da informação. Utilizando a “Superposição (Superposition)” e o “Emaranhamento Quântico (Entanglement)” exclusivos da mecânica quântica, os computadores quânticos exibem um poder computacional que supera os computadores clássicos convencionais em problemas matemáticos específicos, alcançando a chamada “Supremacia Quântica (Quantum Supremacy)”.

Neste artigo, exploraremos detalhadamente, de uma perspectiva técnica e matemática, as ameaças específicas que a tecnologia blockchain enfrenta devido aos computadores quânticos. Também discutiremos a solução: as últimas tendências em Criptografia Pós-Quântica (PQC: Post-Quantum Cryptography) e os cenários de transição para redes de criptoativos.

2. Fundamentos da computação quântica e duas grandes ameaças à blockchain

Os sistemas de blockchain atuais são compostos principalmente pelos dois elementos criptográficos a seguir, cada um exposto a diferentes ameaças de algoritmos quânticos.

graph TD A["Incrível poder de computação dos computadores quânticos"] --> B["Algoritmo de Shor (Shor's Algorithm)"] A --> C["Algoritmo de Grover (Grover's Algorithm)"] B --> D["Colapso da criptografia de chave pública (ECDSA/RSA/DSA)"] C --> E["Impacto na função hash criptográfica (SHA-256)"] D --> F["Identificação de chaves privadas de terceiros e falsificação de transações"] E --> G["Vantagem na mineração PoW e ataques a alguns endereços"] F --> H["Ameaça fatal e direta na blockchain"] G --> I["Ameaça contornável por ajustes de algoritmo (ex: expansão do tamanho da chave)"] style H fill:#ff9999,stroke:#cc0000,stroke-width:2px; style I fill:#ffff99,stroke:#cccc00,stroke-width:2px;

2.1. Fundamentos e dificuldade computacional da Criptografia de Curva Elíptica (ECDSA)

Muitas blockchains, incluindo Bitcoin e Ethereum, adotam o Algoritmo de Assinatura Digital de Curva Elíptica (ECDSA: Elliptic Curve Digital Signature Algorithm) como seu algoritmo de assinatura digital. Especificamente, o Bitcoin usa uma curva elíptica com o parâmetro secp256k1.

A segurança da criptografia de curva elíptica depende da dificuldade computacional do Problema do Logaritmo Discreto em Curvas Elípticas (ECDLP: Elliptic Curve Discrete Logarithm Problem). Uma curva elíptica é definida pela equação na forma padrão de Weierstrass a seguir:

$$ y^2 \equiv x^3 + ax + b \pmod{p} $$

No secp256k1 do Bitcoin, $a = 0, b = 7$, e $p$ é um número primo extremamente grande. Seja $G$ o ponto base (ponto de referência) nesta curva, e $k$ a chave privada, que é um número inteiro gigante de 256 bits escolhido aleatoriamente. Neste caso, a chave pública $K$ é obtida pela adição (multiplicação escalar) do ponto base por $k$ vezes.

$$ K = k \times G = \underbrace{G + G + \dots + G}_{k \text{ vezes}} $$

Usar um computador clássico para calcular reversamente (encontrar o logaritmo discreto) a chave privada $k$ a partir da chave pública publicada $K$ e do ponto base $G$ leva um tempo computacional exponencial de $\mathcal{O}(\sqrt{p})$, mesmo usando os melhores algoritmos clássicos, como o método de fatoração rho de Pollard. Para uma chave de 256 bits, seriam necessárias cerca de $2^{128}$ operações, um nível impossível de resolver mesmo executando os supercomputadores atuais por bilhões de anos.

2.2. Colapso pelo Algoritmo de Shor (Shor’s Algorithm)

No entanto, o Algoritmo de Shor, publicado por Peter Shor em 1994, destruiu completamente essa premissa. O algoritmo de Shor foi originalmente proposto para resolver o problema de fatoração de inteiros (a base da criptografia RSA) em tempo polinomial, mas também pode ser aplicado ao problema do logaritmo discreto e ao problema do logaritmo discreto em curvas elípticas.

O núcleo do algoritmo de Shor reside em sua capacidade de encontrar rapidamente o “Período (Period)” de uma função usando a Transformada de Fourier Quântica (QFT: Quantum Fourier Transform).

$$ \text{Complexidade clássica} = \mathcal{O}(2^{n/2}) \quad (\text{onde } n \text{ é o comprimento em bits}) $$ $$ \text{Complexidade do algoritmo quântico} = \mathcal{O}(n^3) $$

Dessa forma, o algoritmo de Shor reduz drasticamente o tempo exponencial para Tempo Polinomial (Polynomial Time). Se um computador quântico com qubits lógicos suficientes for concluído, será possível identificar a chave privada $k$ a partir de uma chave pública $K$ publicada na rede em minutos ou até segundos. Isso permite que os invasores obtenham facilmente as chaves privadas das carteiras de outras pessoas e assumam o controle total de seus fundos.

2.2.1 Passo a passo da decodificação do ECDLP com o Algoritmo de Shor

Vamos observar, passo a passo, o processo interno de como um computador quântico resolve o Problema do Logaritmo Discreto em Curvas Elípticas (ECDLP).

Definição do problema: Em $K = k \times G$, $G$ e $K$ são conhecidos e queremos encontrar o número inteiro desconhecido $k$ (chave privada). Seja $N$ a ordem da curva elíptica.

Passo 1: Criação do estado de superposição Primeiro, preparamos dois registradores quânticos e aplicamos uma porta Hadamard (Hadamard Gate) a cada um para criar um estado de superposição de todas as combinações de números inteiros possíveis.

$$ |\psi_1\rangle = \frac{1}{N} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} |x\rangle |y\rangle |0\rangle $$

Passo 2: Aplicação do oráculo quântico (avaliação da função) Em seguida, usando um circuito quântico (oráculo) que realiza a adição de pontos na curva elíptica, calculamos a função $f(x, y) = x \times G + y \times K$ no terceiro registrador.

$$ |\psi_2\rangle = \frac{1}{N} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} |x\rangle |y\rangle |x \times G + y \times K\rangle $$

O ponto importante aqui é que, como $K = k \times G$, a função pode ser reescrita como $f(x, y) = (x + y \cdot k) \times G$.

Passo 3: Medição do terceiro registrador A medição do terceiro registrador o colapsa para um determinado ponto $R$ na curva elíptica. Como resultado, o primeiro e o segundo registradores colapsam para uma superposição de pares $(x, y)$ que satisfazem $x + y \cdot k \equiv c \pmod{N}$ (onde $c$ é uma constante).

$$ |\psi_3\rangle = \frac{1}{\sqrt{N}} \sum_{y=0}^{N-1} |c - y \cdot k \pmod{N}\rangle |y\rangle $$

Passo 4: Aplicação da Transformada de Fourier Quântica (QFT) Este estado possui uma periodicidade relacionada ao período $k$. Ao aplicar a Transformada de Fourier Quântica Inversa (Inverse QFT) a isso, causamos interferência de fase e convertemos a informação do período em amplitude.

Passo 5: Medição e pós-processamento clássico Ao medir o primeiro e o segundo registradores, obtemos valores contendo informações sobre $k$ com alta probabilidade. Aplicando algoritmos clássicos de teoria dos números, como Frações Contínuas (Continued Fractions), aos valores medidos, a chave privada desconhecida $k$ pode ser perfeitamente identificada.

O número de portas quânticas exigido para todo esse processo é $\mathcal{O}(\log^3 N)$, o que revela a chave privada a uma velocidade incomparável em relação à busca $\mathcal{O}(\sqrt{N})$ realizada por computadores clássicos.

2.3. O Algoritmo de Grover (Grover’s Algorithm) e o impacto nas funções hash

Outra ameaça é o Algoritmo de Grover, proposto por Lov Grover em 1996. Ele tem um impacto significativo nas funções hash (ex: SHA-256).

Na blockchain, as funções hash são usadas para garantir a integridade dos dados, gerar endereços e servir como base para a mineração PoW (Proof of Work) no Bitcoin. O cálculo reverso (cálculo de pré-imagem) de uma função hash pode ser visto como um “problema de busca em banco de dados não estruturado” no qual, para um valor de saída específico $y$, buscamos um valor de entrada $x$ tal que $H(x) = y$.

Com computadores clássicos, para encontrar a resposta correta dentre $N$ possibilidades, é necessária uma média de $\frac{N}{2}$ tentativas, ou $N$ tentativas no pior dos casos. Ou seja, a complexidade é $\mathcal{O}(N)$. No entanto, o algoritmo de Grover usa uma técnica quântica chamada “Amplificação de Amplitude (Amplitude Amplification)”. Ele amplifica repetidamente a amplitude de probabilidade do estado que é a resposta correta dentre todas as possibilidades em superposição, reduzindo assim o tempo de busca para a raiz quadrada.

$$ \text{Complexidade do Algoritmo de Grover} = \mathcal{O}(\sqrt{N}) $$

No caso do SHA-256, $N = 2^{256}$, então uma busca de força bruta clássica requer cerca de $2^{256}$ tentativas. No entanto, o uso do algoritmo de Grover exigiria apenas $\sqrt{2^{256}} = 2^{128}$ tentativas. Isso significa que, para computadores quânticos, uma função hash de 256 bits terá sua força de segurança efetivamente cortada pela metade, para 128 bits.

2.3.1. O SHA-256 sobreviverá? (Supremacia Quântica no Hashing)

Embora a segurança caia pela metade, “128 bits de segurança” ainda é incrivelmente forte. O número de cálculos $2^{128}$ é astronômico e, do ponto de vista do nível de tecnologia atual, levaria um tempo na escala de vida do universo. Portanto, considera-se amplamente que “o SHA-256 manterá a segurança prática mesmo contra computadores quânticos”. Se for necessário aumentar a margem de segurança no futuro, a segurança clássica de 256 bits pode ser mantida no mundo quântico simplesmente dobrando o comprimento de saída do hash (ex: migrando do SHA-256 para o SHA-512).

Em conclusão, embora a ameaça quântica às funções hash seja “leve e contornável”, a ameaça à criptografia de chave pública (ECDSA) pode ser considerada “fatal”.

3. Análise detalhada do impacto atual nos criptoativos (Bitcoin, Ethereum)

Em um mundo onde a quebra do ECDSA por computadores quânticos se torna possível, com quais vulnerabilidades específicas as redes de criptoativos lidarão? Aqui, com base na estrutura do Bitcoin, conduzimos uma análise detalhada da perspectiva do “momento em que a chave pública é exposta”.

3.1. Geração de endereços e “não divulgação” de chaves públicas

Os endereços do Bitcoin (P2PKH: Pay-to-Public-Key-Hash e P2WPKH: Pay-to-Witness-Public-Key-Hash) não usam a própria chave pública, mas a chave pública com hash aplicado múltiplas vezes.

$$ \text{Endereço Bitcoin} = \text{Base58Check}(\text{RIPEMD160}(\text{SHA256}(\text{Chave Pública}))) $$

Como mencionado, como as funções hash são resistentes a ataques quânticos (algoritmo de Grover), não é possível reverter da “chave pública” original a partir do “endereço”, que é um valor de hash, mesmo com um computador quântico. Ou seja, para “endereços não utilizados (que nunca enviaram fundos)”, a chave pública não foi exposta de forma alguma na blockchain, e apenas o valor hash foi registrado. Portanto, contanto que a chave pública seja desconhecida, não há alvo para o algoritmo de Shor, impossibilitando a identificação da chave privada. Uma carteira nesse estado pode ser considerada quanticamente segura (Quantum-safe).

3.2. A vulnerabilidade fatal no momento do envio da transação (Ataque Front-running)

O problema ocorre quando os usuários enviam fundos. Ao transmitir (enviar) uma transação para a rede, o usuário deve incluir sua chave pública nos dados da transação juntamente com a assinatura digital, expondo-a para toda a rede para verificação.

sequenceDiagram participant User as "Usuário (Alice)" participant Mempool as "Mempool (Pool de transações não confirmadas)" participant QuantumAttacker as "Invasor Quântico" participant Miner as "Minerador (Geração de bloco)" User->>Mempool: Envia transação (incluindo chave pública + assinatura) Mempool-->>QuantumAttacker: Intercepta a chave pública na rede note right of QuantumAttacker: Executa o algoritmo de Shor em minutos
(Calcula a chave privada a partir da chave pública) QuantumAttacker->>QuantumAttacker: Gera uma nova assinatura usando a chave privada da Alice QuantumAttacker->>Mempool: Transmite transferência fraudulenta com taxa de mineração mais alta Miner->>Miner: Prioriza transações fraudulentas com taxa (Gas) alta e as inclui no bloco Miner-->>User: Registrado na blockchain (perda de fundos da Alice)

Uma vez que a chave pública é enviada ao Mempool (área de espera para transações não confirmadas), os dados são compartilhados com os nós ao redor do mundo. Se um invasor possuísse um computador quântico super-rápido, ele poderia roubar os fundos através do seguinte processo:

Interceptar a transação do usuário legítimo (Alice) no Mempool e extrair a chave pública.
Executar o algoritmo de Shor e calcular a chave privada a partir da chave pública em minutos (antes que o bloco seja confirmado).
Usar a chave privada obtida para criar uma transação falsa transferindo os fundos da Alice para o endereço do invasor.
Enviar essa transação falsa para a rede definindo uma taxa de mineração (Fee) muito maior do que a da transação original da Alice.

Seguindo o incentivo econômico, os mineradores priorizarão a transação com as taxas mais altas e a incluirão no bloco. Como resultado, a transferência fraudulenta do invasor é aprovada (Confirm) primeiro e a transferência legítima da Alice é rejeitada como “saldo insuficiente (Double Spend)”. Essa sequência de eventos é chamada de Ataque Front-running (Front-running Attack) e, em um mundo onde computadores quânticos são colocados em uso prático, as pessoas terão seus fundos roubados por hackers no instante em que clicarem no botão enviar.

3.3. A crise dos endereços reutilizados e endereços antigos (P2PK)

Um problema ainda mais sério é que os endereços que enviaram fundos pelo menos uma vez no passado (por exemplo, quando reutilizados como endereços de troco) já têm suas chaves públicas registradas permanentemente na blockchain. Essas carteiras correm o risco de ter as chaves privadas calculadas e os saldos roubados a qualquer momento, sem precisar aguardar que enviem novas transações.

Além disso, o formato P2PK (Pay-to-Public-Key), popular em 2009-2010 e que inclui as recompensas iniciais de mineração de Satoshi Nakamoto (mais de 1 milhão de BTC), registra a chave pública em si, e não o hash, diretamente na blockchain como endereço. Esses enormes Bitcoins inativos se tornarão os alvos mais fáceis para os computadores quânticos, podendo ser roubados de uma vez e despejados (dumping) no mercado, o que poderia causar um crash no preço.

4. O cenário de transição para a Criptografia Pós-Quântica (PQC)

Para evitar tal catástrofe no “Q-Day (o dia em que os computadores quânticos romperão a criptografia)”, a comunidade acadêmica de criptografia e a comunidade blockchain estão planejando migrar para a Criptografia Pós-Quântica (PQC), que é extremamente difícil de decifrar até mesmo com algoritmos quânticos. O Instituto Nacional de Padrões e Tecnologia dos EUA (NIST) tem promovido a padronização da PQC há muitos anos e, após múltiplas rodadas de avaliação rigorosa, selecionou vários sistemas de criptografia promissores como padrões finais.

Abaixo, detalhamos os principais algoritmos de PQC que estão chamando atenção como alternativas de assinatura digital para a blockchain, bem como seus mecanismos matemáticos.

4.1. Assinaturas Baseadas em Hash (Hash-Based Signatures)

As assinaturas baseadas em hash são esquemas de criptografia cuja segurança baseia-se puramente em um alicerce muito simples e robusto: a “resistência a colisões das funções hash”. Como a segurança das funções hash contra computadores quânticos já foi provada (como mencionado, uma margem de segurança de 128 bits é suficiente), esta é uma abordagem incrivelmente confiável. Alguns exemplos representativos incluem a Assinatura de Lamport (Lamport Signatures), e as suas extensões como a WOTS (Winternitz One-Time Signature), e o candidato à padronização do NIST, o SPHINCS+ (atualmente chamado de SLH-DSA como FIPS 205).

4.1.1. Detalhes matemáticos da Assinatura de Lamport (One-Time Signature)

Vejamos mais a fundo os detalhes matemáticos do funcionamento da assinatura de Lamport. Seja a função hash $H: \{0, 1\}^* \to \{0, 1\}^{256}$.

[Geração de chaves] Alice (a remetente) usa um gerador de números aleatórios verdadeiros (TRNG) para gerar 256 pares de chaves privadas.

$$ \text{sk}_{i,0} \in \{0, 1\}^{256}, \quad \text{sk}_{i,1} \in \{0, 1\}^{256} \quad (1 \le i \le 256) $$

Com isso, a chave privada $\text{sk}$ consistirá de um total de 512 strings de 256 bits (Tamanho: $512 \times 32 = 16.384$ bytes).

Em seguida, calcula-se a chave pública $\text{pk}$. Aplica-se hash em cada um dos componentes da chave privada.

$$ \text{pk}_{i,0} = H(\text{sk}_{i,0}), \quad \text{pk}_{i,1} = H(\text{sk}_{i,1}) $$

A chave pública será também de $16.384$ bytes. Ela publicará isso na rede da blockchain.

[Geração de assinatura] Alice, para assinar os dados da transação $M$, primeiro calculará seu valor de hash.

$$ h = H(M) \in \{0, 1\}^{256} $$

Seja o $i$-ésimo bit do valor de hash $h$ expresso como $h_i \in \{0, 1\}$. A assinatura $\sigma$ de Alice será um conjunto de componentes da chave privada correspondente a cada bit $h_i$.

$$ \sigma = (\text{sk}_{1, h_1}, \text{sk}_{2, h_2}, \dots, \text{sk}_{256, h_{256}}) $$

Ou seja, se o bit do hash da mensagem for 0, será revelado o $\text{sk}_{i,0}$, se for 1, será revelado o $\text{sk}_{i,1}$. O tamanho da assinatura será de $256 \times 32 = 8.192$ bytes.

[Verificação de assinatura] O minerador (o verificador) fará a verificação usando a transação $M$ recebida, a assinatura $\sigma = (s_1, s_2, \dots, s_{256})$ e a chave pública $\text{pk}$. O hash da transação $h = H(M)$ é recalculado e, em seguida, verifica-se se o hash de cada $s_i$ corresponde ao elemento da chave pública, $\text{pk}_{i, h_i}$.

$$ H(s_i) \overset{?}{=} \text{pk}_{i, h_i} \quad (\text{para todo } 1 \le i \le 256) $$

Este processo é matematicamente extremamente simples e impossível de forjar assinaturas a menos que o computador quântico consiga reverter $H$. No entanto, ao assinar uma vez, metade da chave privada é exposta à rede. Isso resulta em uma forte limitação de que pode ser usada “apenas uma vez (One-Time)”, pois se a mesma chave for usada para assinar outra mensagem, a combinação das chaves privadas expostas daria ao invasor espaço para falsificações. Para tornar isso prático, foram desenvolvidas tecnologias como XMSS, que agrupa várias chaves one-time sob uma chave pública raiz através da Árvore de Merkle, e o SPHINCS+ sem estado, mas com o lado negativo de que o tamanho da assinatura pode chegar a dezenas de kilobytes.

4.2. Criptografia Baseada em Reticulados (Lattice-Based Cryptography)

Atualmente, a mais promissora forma de PQC e que foi adotada como o principal padrão NIST (FIPS 204: ML-DSA / antigo CRYSTALS-Dilithium e Falcon) é a criptografia baseada em reticulados (Lattice-Based Cryptography).

A segurança da criptografia de reticulados depende de problemas matemáticos comprovadamente difíceis como o “Problema do Vetor Mais Curto em reticulados multidimensionais (SVP: Shortest Vector Problem)” e o “Aprendizado com Erros (LWE: Learning With Errors)”. Nenhum algoritmo eficiente, seja clássico ou quântico, foi descoberto para resolver problemas de reticulados.

O modelo matemático do LWE (Learning With Errors): A ideia fundamental por trás do problema LWE é adicionar intencionalmente um “pequeno ruído (erro)” a um sistema de equações lineares, tornando o problema dramaticamente mais difícil de ser resolvido. Seja o vetor secreto $\mathbf{s} \in \mathbb{Z}_q^n$. Existe uma matriz pública enorme, escolhida aleatoriamente, $\mathbf{A} \in \mathbb{Z}_q^{m \times n}$, e um pequeno vetor de ruído adicionado intencionalmente $\mathbf{e} \in \mathbb{Z}_q^m$. A chave pública $\mathbf{b}$ é calculada da seguinte forma:

$$ \mathbf{b} = \mathbf{A}\mathbf{s} + \mathbf{e} \pmod{q} $$

Mesmo que a matriz $\mathbf{A}$ e o vetor $\mathbf{b}$ (a chave pública) sejam de conhecimento público, devido ao ruído $\mathbf{e}$, calcular de trás pra frente a chave privada $\mathbf{s}$ será extremamente difícil. Sem o ruído, poderia ser resolvido via eliminação gaussiana simples, mas a adição do ruído causa um aumento explosivo no espaço de busca em todas as dimensões, o que confere forte segurança contra computadores clássicos e quânticos. Em algoritmos práticos usados pela blockchain (como Dilithium), utilizam-se essas instâncias em anéis polinomiais, conhecidos como Ring-LWE (ou Module-LWE), para reduzir o tamanho da chave e acelerar os cálculos.

Vantagens: Em relação às assinaturas baseadas em hash, a chave pública e as assinaturas têm um tamanho relativamente pequeno (por volta de alguns kilobytes), e as velocidades de verificação e geração de assinaturas são incrivelmente altas (iguais ou superiores às do ECDSA).
Desvantagens: Possui estruturas matemáticas complexas, e por conta do curto período de avaliação histórica, o risco do descobrimento de novos algoritmos de decodificação no futuro não é nulo.

5. Desafios técnicos na transição de PQC em Blockchains

Apenas a existência dos algoritmos de PQC (como Dilithium ou SPHINCS+) não significa que possam ser imediatamente implementados no Bitcoin ou no Ethereum amanhã. Sistemas descentralizados enfrentam diversos obstáculos enormes.

5.1. Aumento do tamanho das assinaturas e quebra da escalabilidade

O maior obstáculo na introdução de PQC é o aumento em larga escala dos dados. O tamanho atual da assinatura ECDSA ronda cerca de 70 bytes. Por outro lado, com o Dilithium da criptografia de reticulado (ML-DSA), o tamanho da assinatura está por volta de 2.420 bytes a 4.595 bytes (dependendo do nível de segurança), e a chave pública ultrapassa 1.300 bytes. O tamanho total por transação do SPHINCS+, que é baseado em hash, ultrapassa as dezenas de milhares de bytes só para a assinatura.

Se a rede Bitcoin implementar a PQC mas continuar a ter o mesmo limite do tamanho de blocos que possui no presente (aproximadamente o peso de 4MB, incluindo a SegWit), a quantidade de transações que caberão em 1 bloco despencará agressivamente. A velocidade das transações (TPS: Transactions Per Second) diminuirá absurdamente, e as paralisações das transferências se tornarão normais. Para resolver esse problema, é imprescindível um tremendo crescimento no tamanho do bloco, mas tal solução requer mais armazenamento e requisitos de banda de internet dos full nodes, tornando muito mais complicado executar um nó de forma independente. Como resultado, cairá no dilema de induzir uma forte centralização da rede.

pie title "Comparação dos tamanhos dos dados de assinatura em blockchain (Conceitual)" "ECDSA (aprox. 70 Bytes)" : 2 "Dilithium ML-DSA (aprox. 2.500 Bytes)" : 58 "SPHINCS+ (aprox. 17.000 Bytes)" : 40

(※ O aumento dos dados de transação que decorre com a implementação da PQC será um gargalo fatal para a escalabilidade)

5.2. O impacto no Ethereum Virtual Machine (EVM) e os Contratos Pré-compilados (Precompiled Contracts)

Em uma plataforma Turing completa como o Ethereum, a introdução de PQC precisa demandar uma atualização profunda do EVM (Ethereum Virtual Machine). Atualmente, no EVM, o ecrecover (no endereço: 0x01) é um Precompiled Contract oferecido especificamente para verificação da assinatura do ECDSA. Isso reduz o custo e serve como otimização para verificar as assinaturas gastando o mínimo possível de Gas (3000 Gas).

Todavia, os novos algoritmos de criptografia de reticulados, como o Dilithium e Falcon, requerem operações de matrizes e polinômios complexos na verificação, logo, seriam necessários milhões e até dezenas de milhões de gás, utilizando os Opcodes que já estão lá atualmente. Esse é o limite atual do Gas consumido no bloco inteiro (perto dos 30 milhões de Gas) sumindo inteiramente num único uso por uma transação.

A melhor maneira de combater essa questão é inserir um Precompiled Contract próprio para verificação PQC através de Hard Forks na rede (Ex.: usar o endereço 0x10 para DilithiumVerify) inseridos no próprio EVM. E isso, é claro, implica em uma colaboração profunda dos desenvolvedores principais do Ethereum de todos os clientes (Geth, Nethermind, Erigon, etc.), aplicando a verificação num nível mais denso pelas linguagens como C++, Go, e Rust; além de necessitar passar por auditorias duradouras pelo processo.

5.3. A dificuldade de formar consenso através do Hard Fork

Para alterar o algoritmo basilar de assinatura, é necessária uma forte mudança em toda a rede de blockchain, mais conhecida como Hard Fork. Porém, a comunidade, como a do Bitcoin que valoriza “ser imutável sob suas normas”, “descentralizada”, etc. tende a ter dificuldades para obter o consenso político. Assim, entre propor uma BIP (Bitcoin Improvement Proposal) e a implementação na mainnet, anos e mais anos de discussões e testnets seriam essenciais para esse salto com a PQC.

6. Quando o “Q-Day” chegará? Roadmap rumo à transição

Quando chegará o dia em que o computador quântico vai totalmente aniquilar a criptografia de curvas elípticas de 256-bit, chamado de “Q-Day”? Enquanto as previsões diferem de um perito para outro, muitos estipulam algo “de meados de 2030 aos anos 2040”. Acreditam na aparição de um computador quântico de nível escalar (com qubits livres de interferência - Logical Qubits) de fato funcional na escala de milhares e talvez até dezenas de milhares. Mas também não se descarta que a grande evolução da tecnologia possa acontecer bem mais cedo, de volta aos anos 2030, antecipando uma série de arquiteturas.

Aqui está um mapa básico delineando as rotas da comunidade antes de sucumbir para sempre:

Fase 1: Assinatura Híbrida e Abstração de Contas (Hoje - 2028)

No campo de desenvolvimento atual, o corpo principal da blockchain do Ethereum (Vitalik Buterin e cia.) foca nas “Assinaturas Híbridas (Hybrid Signatures)”, que englobam a PQC (seja baseada em hash, reticulados, ou outros métodos) e a clássica ECDSA. Essa transação exige ambos e, mesmo quando uma é corrompida, as barreiras da outra impedem os estragos, assim validando o procedimento de forma pacífica. Ao invés de contar só com forks pesados a nível de protocolo, implementações adicionais como a Abstração da Conta (Account Abstraction, ERC-4337) em Smart Contract Wallets com formato Opt-in já estão sendo oferecidas por aqueles que desejam testar a PQC em suas próprias chaves.

Fase 2: Uso de Provas de Conhecimento Zero (ZK-Rollups) (2025 -)

Para combater a “ampliação do tamanho das assinaturas”, um defeito crônico da PQC, o salvador parece ser o advento da tecnologia Layer-2 focada em ZK-Rollups (Zero-Knowledge Proofs). Os dados superpesados da PQC serão registrados inicialmente e verificados nas transações fora da cadeia da Main Layer (Layer 1). A Layer-2 consolida todos em blocos enormes utilizando a criptografia de ZK-SNARKs ou ZK-STARKs. Transformados nessas singulares “provas minúsculas (Proof)”, eles serão arquivados na rede original em fração do tamanho da PQC. Detalhando, um pequeno grupo de SNARKs, na sua total base estrutural do Groth16, também é indefeso contra ataques quânticos. Então a solução foca puramente no que usa Hash, as ZK-STARKs.

Fase 3: Hard Fork em Nível de Protocolo (em torno de 2030)

E então a padronização oficial através das avaliações do NIST. Ao se solidificarem e as bibliotecas estarem sendo usadas por um bom momento, cadeias centrais como Bitcoin ou Ethereum implementarão sem dúvidas os Hard Forks definitivos em nível padrão e primário. A imensa migração demandaria o incentivo global do mercado por inúmeras campanhas aconselhando “migrar os fundos das carteiras velhas para uma recém adaptada para PQC”.

Projetos Pioneiros

Existem alguns projetos inovadores na era blockchain focados exclusivamente nessa barreira quântica:

QRL (Quantum Resistant Ledger): A XMSS (eXtended Merkle Signature Scheme) em formato hash serviu de alicerce da blockchain com PQC inserida na base desde seus primórdios em mainnets mais antigos.
Algorand / Cellframe: Sistemas modelados com foco na evolução para PQC de camadas mais flexíveis da criptografia, abraçando e aprofundando o formato nos reticulados num momento precoce.

7. Conclusão: Para o futuro e a salvaguarda de nossas moedas

A era pós-quântica está deixando de ser uma premissa da FC (Ficção Científica) para transformar-se numa ameaça tangível de problemas e riscos graves na própria infraestrutura do ecossistema criptográfico hoje.

Com o machado de ponta-dupla do Algoritmo de Shor e do Algoritmo de Grover pelas frentes quânticas, tanto o ECDSA da Chave Pública quanto a Função Hash encaram o seu extermínio respectivo. Notoriamente a fragilidade destrutiva do ECDSA dita as regras: os perigos vindos da extração dos fundos via ataques front-running (Front-Running Attacks) exigirão medidas impetuosas para o PQC sem demora.

Felizmente, não é apenas um fim apocalíptico onde sentam-se à espera. As soluções de reticulados, hashes sob novos padrões validados do PQC, os recursos Layer-2 ZK-STARKs provaram ser barreiras excelentes no desafio iminente, controlando por fim a praga da enorme quantia e tamanho que as transações requerem.

Para qualquer indivíduo normal investido nesse campo, não precisa de ataques de pânico momentâneos hoje. Contudo, todos necessitarão portar os conhecimentos de auto-preservação:

Evitar reciclar endereços: Evite endereços (os já manuseados e cujas chaves públicas perambulam na blockchain exposta). E também manter no radar as regras básicas de privacidade.
Ficar atento nas tecnologias e relatórios: Como ler BIPs e EIPs da comunidade de Bitcoin/Ethereum focadas nos Hard Forks. Isso propicia que seja fácil fazer a manobra da sua carteira se requerido num anúncio do tipo, da melhor maneira possível.

A resiliência das Blockchains define seu ciclo imortal e histórico, superando e vencendo a escalabilidade (a conversão brutal que aconteceu no PoW e PoS no ecossistema atual e a própria camada sustentável ambiental) com melhoria vital. Em frente as crises de magnitude quântica global, é um embate que exigirá todos de nós no coletivo inteiro das rotas descentralizadas para superar o dilema sem igual. E no decorrer dessa odisseia, quem dirá se o choque dessas duas esferas intelectuais criadas pelas mentes humanas (A tecnologia Blockchain imutável versus a capacidade máxima Quântica), gerem não apenas destruição e escombros, mas uma transcendência suprema da tecnologia baseada em segurança superior no amanhecer sem fim da posteridade!

Referências e links úteis:

National Institute of Standards and Technology (NIST) - Post-Quantum Cryptography Standardization Project
Shor, P. W. (1994). Algorithms for quantum computation: discrete logarithms and factoring.
Grover, L. K. (1996). A fast quantum mechanical algorithm for database search.
Buterin, V. (2024). How to hard-fork to save most users’ funds in a quantum emergency.

A diferença entre Annealing Quântico e Modelo de Porta Quântica explicada de forma simples

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

A diferença entre Annealing Quântico e Modelo de Porta Quântica explicada de forma simples

A computação quântica é uma tecnologia de computação de próxima geração com o potencial de resolver de forma incrivelmente rápida, utilizando princípios da mecânica quântica (sobreposição e emaranhamento quântico), problemas específicos que levariam um tempo enorme para serem processados por computadores clássicos modernos (incluindo supercomputadores convencionais).

Atualmente, existem dois paradigmas principais na abordagem para a realização de computadores quânticos: “Annealing Quântico” (Quantum Annealing) e o “Modelo de Porta Quântica” (Quantum Gate Model). Esses dois métodos diferem significativamente em sua abordagem física fundamental, nas tarefas computacionais em que se destacam e nos desafios de hardware na sua implementação.

Neste artigo, compararemos e explicaremos detalhadamente esses dois métodos a partir de uma perspectiva altamente técnica e detalhada, abrangendo os princípios físicos, modelos matemáticos (modelo de Ising, QUBO, transformações unitárias, etc.), as limitações tecnológicas atuais e os casos de uso específicos.

1. Fundamentos da Computação Quântica: A diferença fundamental em relação aos computadores clássicos

Os computadores clássicos processam informações como “Bits”, que assumem o estado “0” ou “1”. Em contraste, os computadores quânticos usam “Qubits” (Bits Quânticos). Graças ao princípio da “sobreposição” (Superposition) da mecânica quântica, os qubits podem manter os estados 0 e 1 simultaneamente de forma probabilística.

Além disso, utilizando um fenômeno chamado “emaranhamento quântico” (Entanglement), o estado de múltiplos qubits torna-se fortemente correlacionado, de modo que uma operação em um único qubit afeta instantaneamente todo o sistema. Isso possibilita a realização de cálculos semelhantes ao processamento paralelo (paralelismo quântico).

No entanto, os estados quânticos são extremamente vulneráveis a ruídos externos (como calor e ondas eletromagnéticas), e a “decoerência” (Decoherence) – onde o estado colapsa e retorna a um estado clássico – é um grande desafio. A diferença na abordagem a esse problema de ruído levou a grandes diferenças nas filosofias de design do annealing e do modelo de portas.

2. Detalhes do Annealing Quântico (Quantum Annealing)

O annealing quântico é uma arquitetura de computação especializada, focada principalmente em resolver “problemas de otimização combinatória”. Baseia-se na teoria proposta em 1998 por Hidetoshi Nishimori e Tadashi Kadowaki do Instituto de Tecnologia de Tóquio (Tokyo Tech), e tornou-se amplamente conhecido após ser comercializado pela primeira vez no mundo pela empresa canadense D-Wave Systems.

2.1. Mecanismo Físico: Modelo de Ising de campo transversal e flutuação quântica

O annealing quântico usa a propriedade natural dos sistemas físicos de tentar se acomodar no “estado de menor energia” (estado fundamental) para realizar cálculos.

Na abordagem clássica do “Simulated Annealing” (Recozimento Simulado), a flutuação térmica é usada para escapar das soluções ótimas locais (mínimos locais). Por outro lado, no annealing quântico, a “flutuação quântica” (Quantum Fluctuation) é usada para atravessar barreiras de energia por meio do “efeito de tunelamento quântico” (Quantum Tunneling), explorando de maneira mais eficiente a solução ótima global (mínimo global).

A evolução temporal do sistema de annealing quântico é descrita pelo seguinte Hamiltoniano (operador que representa a energia total do sistema) $H(t)$:

$$ H(t) = A(t) H_0 + B(t) H_P $$

Onde $t$ é o tempo, $A(t)$ é uma função que diminui gradualmente e $B(t)$ é uma função que aumenta gradualmente.

$H_0$ (Hamiltoniano inicial): Representa o campo transversal (Transverse field) e gera flutuações quânticas. $$ H_0 = - \sum_{i} \sigma_i^x $$ ($\sigma_i^x$ é a matriz de Pauli X e representa a inversão de bits.)
$H_P$ (Hamiltoniano do problema): O modelo de Ising (Ising Model) que expressa o problema de otimização a ser resolvido.

No estado inicial ($t=0$), $A(0)$ está no seu máximo e o sistema está no estado fundamental de $H_0$ (um estado onde todos os estados possíveis estão uniformemente sobrepostos). A partir daí, o campo transversal é lentamente reduzido ao longo do tempo, enquanto simultaneamente a interação do Hamiltoniano do problema é aumentada.

2.2. Computação Quântica Adiabática (Adiabatic Quantum Computation)

O “Teorema Adiabático” (Adiabatic Theorem) é importante neste processo. De acordo com o teorema adiabático, se o sistema for alterado de forma “suficientemente lenta (adiabática)”, o sistema permanecerá constantemente no estado fundamental do Hamiltoniano daquele momento.

Em outras palavras, quando no final tivermos $A(t) \to 0$ e $B(t) \to 1$, o sistema terá atingido o estado fundamental de $H_P$, ou seja, a “solução exata do problema de otimização”.

graph TD A["Hamiltoniano H_0 (Estado Inicial)"] -->|"Mudança Adiabática (Suficientemente lenta)"| B["Mantém o estado fundamental o tempo todo"] A -->|"Mudança não adiabática (Muito rápida/Ruído térmico)"| C["Transição para estados excitados (Erro)"] B --> D["Hamiltoniano H_P (Solução ótima global)"] C --> E["Preso em um ótimo local"] D --> F["Leitura da solução"] E --> F

2.3. Mapeamento de QUBO para o Modelo de Ising

Para resolver problemas do mundo real em um annealer quântico, o problema deve ser formulado no formato QUBO (Quadratic Unconstrained Binary Optimization).

A função objetivo do QUBO é definida da seguinte forma:

$$ \min_{x \in \{0,1\}^n} \sum_{i} Q_{ii} x_i + \sum_{i < j} Q_{ij} x_i x_j $$

Onde $x_i \in \{0, 1\}$ são variáveis binárias e $Q$ é a matriz de pesos.

Como o hardware (como os da D-Wave) lida com spins físicos (para cima / para baixo), é necessário converter as variáveis para o modelo de Ising usando $\sigma_i \in \{-1, +1\}$. A fórmula de conversão é a seguinte:

$$ x_i = \frac{1 - \sigma_i}{2} \quad \text{ou} \quad \sigma_i = 1 - 2x_i $$

Substituindo isso na equação do QUBO e simplificando, obtemos o Hamiltoniano do modelo de Ising $H_P$:

$$ H_P = - \sum_{i

$J_{ij}$: A interação entre os spins (coeficiente de acoplamento). Força do acoplamento entre os qubits físicos.

$h_i$: Campo magnético local (bias) aplicado a cada spin.

2.4. Hardware e desafios do Annealing Quântico (Exemplo da D-Wave)

Os processadores quânticos da D-Wave são realizados usando Dispositivos Supercondutores de Interferência Quântica (SQUID). O acoplamento entre qubits físicos depende do cabeamento de hardware e não apresenta acoplamento total (um estado em que todos os bits estão interconectados). Embora o grau de acoplamento tenha melhorado, evoluindo do “Gráfico Chimera (Chimera graph)” original para o “Gráfico Pegasus (Pegasus)” e “Gráfico Zephyr (Zephyr)”, ainda há limitações.

Por esse motivo, é necessário um processo chamado “Incorporação de Menores (Minor Embedding)”, que mapeia problemas com estruturas gráficas complexas nos gráficos físicos. Isso resulta em uma única variável lógica sendo representada por múltiplos qubits físicos (cadeias), o que reduz o número de qubits utilizáveis na prática e gera o problema de degradação da precisão do cálculo.

3. Detalhes do Modelo de Porta Quântica (Quantum Gate Model)

O modelo de porta quântica é uma extensão quântica das portas lógicas de computadores clássicos (AND, OR, NOT, etc.) e é uma arquitetura que permite a “Computação Quântica Universal” (Universal Quantum Computation). Muitas empresas, como IBM, Google, Rigetti e IonQ, adotam esse método.

3.1. Transformações Unitárias e Vetores de Estado

No modelo de porta quântica, o estado de todo o sistema de qubits é expresso como um “Vetor de Estado” (State Vector) $|\psi\rangle$. O estado de 1 qubit é expresso como uma combinação linear dos estados base $|0\rangle$ e $|1\rangle$, como mostrado abaixo:

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

Onde $\alpha$ e $\beta$ são amplitudes de probabilidade complexas, e satisfazem $|\alpha|^2 + |\beta|^2 = 1$. Esse estado é visualizado geometricamente como um ponto na “Esfera de Bloch” (Bloch Sphere).

As etapas da computação quântica são descritas como a aplicação de um Operador Unitário (Unitary Operator) $U$ ao vetor de estado. Matrizes unitárias possuem a propriedade $U^\dagger U = I$ (o produto pelo seu conjugado hermitiano resulta na matriz identidade), sendo uma operação reversível que corresponde à evolução temporal da equação de Schrödinger na mecânica quântica.

$$ |\psi_{t+1}\rangle = U_t |\psi_t\rangle $$

3.2. Portas Quânticas Básicas e Modelo de Circuito

Algoritmos de computação quântica são projetados como uma sequência de portas quânticas (um circuito quântico).

Portas de Pauli (X, Y, Z): Rotações de 180 graus em torno de cada eixo na esfera de Bloch. A porta X equivale à porta clássica NOT.
Porta Hadamard (H): Transforma $|0\rangle$ em $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$, criando um estado de sobreposição. $$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$
Porta CNOT (Controlled-NOT): Uma porta de 2 qubits. Aplica a porta X ao bit alvo apenas quando o bit de controle é $|1\rangle$. Isso gera emaranhamento quântico (Entanglement).

Qualquer algoritmo quântico pode ser expresso de forma aproximada através da combinação de um pequeno número de portas de 1 qubit e portas CNOT (conjunto de portas universais).

graph LR Q0["Qubit 0: |0>"] --> H1["Porta Hadamard (H)"] Q1["Qubit 1: |0>"] --> I1["Operação Identidade (I)"] H1 --> C1["Bit de Controle (Control)"] I1 --> T1["Bit Alvo (Target)"] C1 -. "Emaranhamento" .- T1 C1 --> M0["Medição (Measurement)"] T1 --> M1["Medição (Measurement)"] M0 --> Result["Resultado Clássico (0 ou 1)"] M1 --> Result

3.3. Correção de Erros e o Caminho do NISQ para o FTQC

O maior desafio do modelo de porta quântica é a “decoerência”, onde os estados quânticos são destruídos por ruídos. Conforme os passos de cálculo (profundidade das portas) aumentam, os erros se acumulam.

Para realizar cálculos ideais, a Correção de Erros Quânticos (Quantum Error Correction) é essencial. Por exemplo, em métodos como o “Código de Superfície” (Surface Code), agrupa-se múltiplos qubits físicos para formar 1 “qubit lógico” (Logical Qubit) sem erros. No entanto, são necessários milhares a dezenas de milhares de qubits físicos para criar 1 qubit lógico, resultando em um enorme custo indireto (overhead).

O estágio em que estamos agora é a era dos dispositivos NISQ (Noisy Intermediate-Scale Quantum) de dezenas a centenas de qubits sem correção de erros. Para alcançar o FTQC (Fault-Tolerant Quantum Computing) com correção de erros total, muitos avanços ainda são necessários.

4. Resumo da Comparação Técnica e Matemática

Vamos comparar as diferenças fundamentais entre as duas arquiteturas.

Item de Comparação	Annealing Quântico (Quantum Annealing)	Modelo de Porta Quântica (Gate Model)
Modelo Computacional	Computação quântica adiabática (Evolução temporal contínua do Hamiltoniano)	Transformações unitárias (Sequência de operações discretas em portas)
Problemas Adequados	Problemas de otimização combinatória (QUBO, modelo de Ising)	Universal (Simulação química quântica, fatoração de primos, busca, etc.)
Poder de Expressão	Otimização heurística (Soluções aproximadas)	Equivalente à Máquina de Turing Quântica Universal (Teoricamente capaz de todos os cálculos)
Exemplos de Implementação	D-Wave Systems	IBM, Google, Quantinuum, IonQ, etc.
Tolerância a Ruídos	Relativamente alta (Permanece perto do estado fundamental, certo ruído térmico é aceitável)	Muito fraca (O mínimo ruído causa desalinhamento de fase e destrói o cálculo)
Escalabilidade	Milhares a dezenas de milhares de qubits (Depende da estrutura física. A conversão para qubits lógicos é difícil)	Escala de centenas de qubits (Milhões são necessários para FTQC)

O Annealing Quântico atua como um “coprocessador para fins específicos”, sendo adequado para resolver problemas de otimização complementando os limites dos computadores clássicos. Por outro lado, o Modelo de Porta Quântica é a versão quântica de um “computador de propósito geral” e visa fundamentalmente superar as capacidades de cálculo dos computadores clássicos (supremacia quântica), mas a construção do hardware é extremamente difícil.

5. Limitações e Desafios Atuais

Limitações do Annealing Quântico

Limitação de Conectividade (Connectivity): Devido à incorporação de menores (minor embedding) mencionada acima, à medida que a escala do problema aumenta, o número de qubits físicos necessários cresce exponencialmente.
Precisão dos Coeficientes (Precision): Os erros físicos ao configurar os parâmetros analógicos, como $J_{ij}$ e $h_i$, no hardware, afetam diretamente a qualidade da solução.
Temperatura e Transição Não Adiabática: Como a temperatura do sistema não é o zero absoluto, há uma probabilidade de se desviar da solução ótima devido à excitação térmica.

Limitações do Modelo de Porta Quântica

Tempo de Coerência (Coherence Time): O tempo em que o estado quântico pode ser mantido é de apenas alguns microssegundos a milissegundos, limitando severamente o número de portas (profundidade do circuito) que podem ser executadas nesse intervalo.
Fidelidade da Porta (Gate Fidelity): A taxa de erro nas operações de portas de 2 qubits (como a CNOT) ainda não é suficientemente baixa (geralmente em torno de 99,x%). Para realizar o FTQC, isso precisará ser elevado para mais de 99,99%.
Volume Quântico (Quantum Volume): O maior desafio atual é escalar não apenas o número de qubits puros, mas a capacidade computacional efetiva (Volume Quântico), que leva em conta a interconexão e a taxa de erros.

6. Casos de Uso Específicos e Algoritmos

Vamos ver as áreas de aplicação específicas em que cada método se destaca.

6.1. Casos de Uso do Annealing Quântico

Logística e Roteamento: Otimização de rotas de entrega para vários veículos (Variação do problema do caixeiro viajante). Busca de rotas em tempo real considerando o congestionamento do tráfego.
Engenharia Financeira: Otimização de portfólios. Exploração da combinação de ativos para maximizar retornos enquanto se minimizam os riscos.
Aprendizado de Máquina (Machine Learning): Seleção de Características (Feature Selection). Extrair a combinação de variáveis que mais contribui para as previsões de um enorme conjunto de dados.
Manufatura: O problema de escalonamento job-shop nas fábricas (qual máquina deve processar qual peça e em que ordem para ser a mais rápida).

6.2. Casos de Uso do Modelo de Porta Quântica

Simulação Química Quântica: Simulação de alta precisão dos estados energéticos de moléculas e reações químicas.
Fatoração em Primos (Algoritmo de Shor): Um algoritmo para fatorar enormes números compostos em tempo polinomial. Se for colocado em uso prático, a infraestrutura atual de criptografia de chave pública, como o RSA, será quebrada, tornando urgente a transição para a criptografia pós-quântica (PQC).
Busca em Banco de Dados (Algoritmo de Grover): Quando se pesquisa dados em bancos de dados não classificados, computadores clássicos exigem etapas de $O(N)$, enquanto o algoritmo de Grover pode pesquisar em etapas de $O(\sqrt{N})$.

6.3. Algoritmos Híbridos na Era NISQ: VQE e QAOA

Para superar as limitações dos circuitos quânticos rasos dos dispositivos NISQ, algoritmos como os “Algoritmos Quânticos Variacionais” (Variational Quantum Algorithms), que combinam os pontos fortes dos computadores quânticos e clássicos, estão chamando a atenção.

VQE (Variational Quantum Eigensolver): Um algoritmo para calcular a energia do estado fundamental de moléculas. Ele prepara os estados quânticos usando um circuito quântico parametrizado (Ansatz) e mede o valor esperado da energia $\langle \psi(\theta) | H | \psi(\theta) \rangle$. Usando esse valor esperado como função objetivo, algoritmos clássicos de otimização (como a descida de gradiente) são usados para atualizar os parâmetros $\theta$. A repetição disso até a convergência fornece o estado exato de energia da molécula.
QAOA (Quantum Approximate Optimization Algorithm): Um algoritmo para resolver problemas de otimização combinatória usando o modelo de portas quânticas. Ele aproxima a evolução temporal adiabática do annealing quântico em operações de portas discretas por meio da “Trotterização” (Trotterization), aplicando alternadamente os Hamiltonianos para obter soluções aproximadas. O QAOA é considerado um meio promissor de resolver problemas de otimização na abordagem por portas.

graph TD User["Problema do Usuário"] --> Formulation{"Natureza do Problema"} Formulation -- "Otimização Combinatória" --> QA_Path["Annealing Quântico / Máquina de Ising"] QA_Path --> QUBO["Formulação QUBO"] QUBO --> DWave["Execução D-Wave"] Formulation -- "Cálculos Químicos / Computação de Propósito Geral" --> Gate_Path["Modelo de Porta Quântica"] Gate_Path --> Circuit["Design de Circuito Quântico (VQE / QAOA)"] Circuit --> IBMGoogle["Execução de Hardware Quântico IBM / Google"]

7. Conclusão

Tanto o Annealing Quântico quanto o Modelo de Porta Quântica são semelhantes no sentido de que utilizam as misteriosas propriedades da mecânica quântica como um recurso computacional, mas suas abordagens e objetivos finais são amplamente diferentes.

O Annealing Quântico é um “motor heurístico especializado” voltado para entregar de forma antecipada resultados práticos para problemas reais específicos de otimização combinatória. Diversas provas de conceito (PoCs) já estão em andamento por várias empresas.
O Modelo de Porta Quântica é um “computador quântico de propósito geral” com o potencial de abalar fundamentalmente o paradigma da ciência da computação, que vai desde simulações rigorosas em física e química até decodificação de criptografia. No entanto, é necessária pesquisa e desenvolvimento a longo prazo para superar o enorme obstáculo da correção de erros.

No futuro, espera-se que um ambiente de “computação heterogênea” (Heterogeneous Computing) seja construído, tendo os supercomputadores clássicos (HPC) como o núcleo, enquanto as máquinas de annealing serão chamadas para tarefas de otimização e computadores quânticos baseados em portas para cálculos de química quântica.

Os computadores quânticos ainda são uma tecnologia em desenvolvimento, mas estão evoluindo a passos largos, tanto em hardware quanto em algoritmos. Compreender a matemática do modelo de Ising e os fundamentos dos circuitos quânticos será uma grande ferramenta para a era dos “nativos quânticos” que está por vir.

Este artigo é uma explicação abrangente dos conceitos básicos da computação quântica até as tendências mais recentes de hardware. Fique atento às futuras tendências de pesquisa.

Simulando o Algoritmo de Shor em Python

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

1. Introdução: A Crise da Criptografia Trazida pelos Computadores Quânticos

A maior parte da segurança na sociedade atual da internet depende de sistemas de criptografia de chave pública (especialmente a criptografia RSA). Quando enviamos informações de cartão de crédito em compras online ou trocamos dados altamente confidenciais, o conteúdo dessa comunicação é fortemente protegido pela criptografia RSA.

A base da segurança da criptografia RSA reside no fato matemático de que “fatorar números inteiros gigantescos em primos é extremamente difícil para computadores clássicos (os PCs e supercomputadores que normalmente usamos)”. No entanto, o “Algoritmo de Shor (Shor’s Algorithm)”, publicado por Peter Shor em 1994, virou essa premissa de cabeça para baixo. Foi matematicamente provado que, se o algoritmo de Shor for executado em um computador quântico de grande escala, a fatoração de primos, que levaria mais tempo que a idade do universo em um computador clássico, poderia ser resolvida em apenas alguns minutos a algumas horas.

Neste artigo, explicaremos de forma minuciosa e detalhada como o algoritmo de Shor realiza essa fatoração de primos em alta velocidade, desde o seu mecanismo matemático até a implementação de uma simulação específica usando Python e o framework de computação quântica Qiskit.

2. A Mudança Dramática na Complexidade Computacional: De Exponencial para Tempo Polinomial

Por que a fatoração de primos é difícil? Mesmo usando a “Peneira Geral dos Corpos de Números (General Number Field Sieve, GNFS)”, conhecida como o melhor algoritmo de fatoração em computadores clássicos, a sua complexidade computacional é subexponencial.

A complexidade de tempo para fatorar um número composto de $N$ dígitos usando métodos clássicos é a seguinte:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Por esse motivo, apenas aumentando o tamanho da chave (por exemplo, para 2048 bits ou 4096 bits), o tempo necessário para a decodificação em computadores clássicos passa a ser de milhares ou dezenas de milhares de anos, o que é um tempo irreal.

No entanto, ao usar o Algoritmo de Shor em um computador quântico, a complexidade computacional é drasticamente reduzida para tempo polinomial em relação ao número de bits da entrada, $\log N$.

$$ O((\log N)^3) $$

Isso significa que, se o número de bits for dobrado, enquanto o tempo de computação em um computador clássico aumentaria astronomicamente, no computador quântico o tempo aumentaria, no máximo, cerca de 8 vezes. Essa redução da classe de complexidade de tempo exponencial para tempo polinomial (inclusão na classe BQP) é o verdadeiro poder do algoritmo de Shor.

graph TD A["Aumento do tamanho da entrada (número de bits) N"] --> B{"Escolha do algoritmo"} B -->|Clássico: Peneira Geral dos Corpos de Números| C["Aumento subexponencial O(exp(...))"] B -->|Quântico: Algoritmo de Shor| D["Tempo polinomial O((log N)^3)"] C --> E["Milhares a bilhões de anos (Indecifrável)"] D --> F["Minutos a horas (Decifrável em tempo real)"]

3. Visão Geral do Algoritmo e Base Matemática

O algoritmo de Shor não realiza tudo no computador quântico, na verdade. Ele é composto pela cooperação entre o pré-processamento e o pós-processamento realizados em computadores clássicos e a parte central (o algoritmo de descoberta de período) executada em um computador quântico.

O fluxo geral do algoritmo é o seguinte:

graph TD A["Entrada: Número composto N a ser fatorado"] --> B["Escolher número aleatório a tal que a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["Imprimir fator trivial gcd(a, N) e encerrar"] C -- "No" --> E["Encontrar o período r de f(x) = a^x mod N com algoritmo quântico"] E --> F{"r é par E a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["Calcular os fatores p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Saída: p, q"]

Reduzindo a Fatoração de Primos ao Problema de Descoberta de Período

A genialidade de Shor consistiu em converter o “Problema de Fatoração de Primos” no “Problema de Descoberta de Período (Order Finding Problem)”.

Considere um inteiro $N$ (o número que queremos fatorar) e um inteiro $a$ co-primo a ele ($1 < a < N$). Definimos a seguinte função de exponenciação modular:

$$ f(x) = a^x \bmod N $$

Essa função possui um certo período $r$. Ou seja, para qualquer $x$, temos $f(x+r) = f(x)$. Especialmente quando $x=0$, o menor inteiro positivo $r$ tal que:

$$ a^r \equiv 1 \pmod N $$

é chamado de “ordem de $a$ módulo $N$”. Se conseguirmos encontrar esse período $r$, poderemos derivar os fatores primos da seguinte maneira.

Rearranjando a equação, temos:

$$ a^r - 1 \equiv 0 \pmod N $$

Se $r$ for par, podemos fatorá-la usando a fórmula da diferença de quadrados:

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Isso significa que $N$ compartilha um divisor comum com $(a^{r/2} - 1)$ ou com $(a^{r/2} + 1)$ (desde que satisfaça a condição de que $a^{r/2} \not\equiv -1 \pmod N$). Portanto, usando o algoritmo de Euclides, podemos calcular:

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

e encontrar os fatores primos não triviais $p, q$ de $N$. Esses cálculos (o cálculo do máximo divisor comum e a geração de números aleatórios) podem ser feitos muito rapidamente em computadores clássicos. O problema se resume a como encontrar rapidamente o período $r$. Em computadores clássicos, encontrar o próprio período $r$ exige tempo exponencial. É aqui que entram os computadores quânticos.

4. A Parte do Algoritmo Quântico: Como Funciona a Descoberta do Período

A sub-rotina para encontrar o período $r$ usando um computador quântico consiste nos 4 passos a seguir.

graph LR subgraph "Transição de Estados Quânticos" S1["|0⟩|0⟩ (Inicialização)"] --> S2["Porta H: Sobreposição Σ|x⟩|0⟩"] S2 --> S3["Oráculo U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Extração do período via interferência"] S4 --> S5["Medição: Obtenção do valor aproximado y"] end

Passo 1: Inicialização e Sobreposição do Registrador Quântico

Primeiro, preparamos dois registradores quânticos. O primeiro registrador é para a entrada de estados, e o segundo é para armazenar o resultado do cálculo da função. O estado inicial é todo $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Aplicamos uma Porta Hadamard (Hadamard Gate) a todos os qubits do primeiro registrador, criando um estado de sobreposição de igual probabilidade para todas as entradas possíveis $x$ (de $0$ a $Q-1$, onde $Q=2^n$).

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

Com isso, o computador quântico manterá os estados de todas as $Q$ entradas simultaneamente, em uma única operação. Essa é a poderosa fonte do paralelismo quântico.

Passo 2: Aplicação da Função Oráculo (Exponenciação Modular)

Em seguida, usamos o circuito de operação quântica $U_f$ para calcular a função $f(x) = a^x \bmod N$ e armazenamos o resultado no segundo registrador.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

Neste ponto, o primeiro e o segundo registradores estão em um estado de entrelaçamento quântico (Entanglement). Se (hipoteticamente) observarmos o segundo registrador e obtivermos um valor específico $k = a^{x_0} \bmod N$, o estado do primeiro registrador colapsará para uma sobreposição dos $x$ que resultam nesse valor $k$. Como o período da função é $r$, os estados restantes assumirão os valores $x_0, x_0+r, x_0+2r, \dots$ em saltos de $r$.

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

No entanto, não queremos saber $x_0$; queremos saber o próprio período $r$. Observar $r$ diretamente a partir deste estado é impossível. Portanto, utilizamos a Transformada Quântica de Fourier.

Passo 3: Interferência de Fase via Transformada Quântica de Fourier (QFT)

Aplicamos a Transformada Quântica de Fourier (Quantum Fourier Transform, QFT) ao primeiro registrador. A QFT é a versão quântica da clássica transformada discreta de Fourier, e transforma as amplitudes do vetor de estado. A ação da QFT em um estado de base $|x\rangle$ é definida como:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Onde $\omega = e^{2\pi i / Q}$.

Ao aplicar a QFT, as amplitudes dos estados sofrem interferência. Sem entrar nos detalhes matemáticos, quando aplicamos a QFT a um estado com período $r$, as ondas causarão interferência construtiva (Constructive Interference) apenas quando $y$ for extremamente próximo a um múltiplo inteiro de $Q/r$. Para os outros estados, as amplitudes de probabilidade serão canceladas por interferência destrutiva (Destructive Interference), aproximando-se de zero.

Passo 4: Medição e Expansão em Frações Contínuas

Por fim, medimos o primeiro registrador. O valor $y$ obtido pela medição satisfará a seguinte condição com alta probabilidade:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

($c$ é um inteiro desconhecido tal que $0 \le c < r$)

Aplicando o algoritmo clássico da Expansão em Frações Contínuas (Continued Fraction Expansion) ao número racional obtido $y/Q$, podemos calcular a fração aproximada $c/r$ e extrair o período $r$ do denominador.

5. Implementação da Simulação usando Python e Qiskit

Como apenas a teoria não transmite o sentido real da coisa, vamos simular de fato o algoritmo de Shor usando Python e o framework de computação quântica da IBM, o Qiskit.

Aqui, implementaremos o cenário clássico e mais famoso: “Fatorar $N=15$ utilizando $a=7$”.

Preparação do Ambiente de Execução

Por favor, instale o Qiskit previamente.

1

pip install qiskit qiskit-aer numpy

Visão Geral do Código de Implementação em Python

O código a seguir é um exemplo de implementação do algoritmo de Shor especializado para $N=15$ e $a=7$. Como construir um circuito genérico de exponenciação modular tem um custo computacional muito alto nos simuladores atuais, codificamos diretamente as operações das portas lógicas (hardcoding) especificamente para o caso de $a=7$.

 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
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Função para construir a Transformada Quântica de Fourier inversa (QFT†)
def qft_dagger(n):
 """Gera um circuito para a Transformada Quântica de Fourier inversa de n qubits"""
 qc = QuantumCircuit(n)
 # Porta SWAP para inverter a ordem
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Aplicação de portas de fase controlada e portas H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Função para construir a operação de exponenciação modular controlada de 7^x mod 15
def c_amod15(a, power):
 """Gera a porta U controlada para uma a e uma potência específicas (exclusivo para N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Lógica hardcoded para 7^x mod 15 no caso de a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Construção do circuito quântico principal
def shor_circuit(a, n_count):
 # n_count: número de bits do registrador de controle
 # O registrador alvo tem 4 bits para representar de 0 a 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Inicialização do primeiro registrador (registrador de controle, gerando a sobreposição)
 for q in range(n_count):
 qc.h(q)

 # Inicializando o segundo registrador (registrador alvo) para |1> (0001)
 qc.x(3 + n_count)

 # Aplicação da operação de exponenciação modular controlada (oráculo)
 for q in range(n_count):
 # Aplicação da operação elevada a 2^q
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Aplicação da QFT inversa no primeiro registrador
 qc.append(qft_dagger(n_count), range(n_count))

 # Medição do primeiro registrador
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Seção de Execução ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Usamos 8 qubits no registrador de controle (Q=256)

 print(f"Configuração da busca: N={N}, a={a}, qubits de controle={n_count}")

 # Geração do circuito
 qc = shor_circuit(a, n_count)

 # Execução no simulador
 sim = AerSimulator()
 # O transpile é recomendado nas versões mais recentes do Qiskit
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nResultados da medição (cadeia de bits: vezes observadas):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} vezes")

 # Pós-processamento clássico: identificação do período r através da expansão em frações contínuas
 print("\n--- Cálculo do período e fatoração em primos ---")
 phases = []
 for output in counts:
 # Converter cadeia de bits para decimal
 decimal = int(output, 2)
 # Fase = valor medido / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Obter a fração aproximada por meio de frações contínuas. O denominador máximo é N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Valor observado: {decimal:3d} | Fase: {phase:.4f} | Fração contínua: {frac} | Período estimado r = {r}")

 # Verificar se o período r é par e gera resultados válidos
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Sucesso! Os fatores primos de {N} são {guess1} e {guess2}.")
 else:
 print(f" => Apenas fatores triviais. Tente novamente.")
 else:
 print(f" => Falha, pois o período é ímpar.")

Análise do Código e Resultados da Execução

Quando executamos o código acima, obtemos picos específicos (valores observados) com alta probabilidade como resultado da medição do registrador de controle. Com n_count=8 ($Q=256$), em um computador quântico ideal (ou simulador), valores observados como 0, 64, 128, 192 aparecerão com probabilidades esmagadoras.

Se dividirmos esses por $Q=256$, a fase $y/Q$ será $0.0$, $0.25$, $0.5$ e $0.75$, respectivamente. Expandindo essas fases em frações contínuas, obtemos:

$0.25 \to 1/4$ (Período estimado $r=4$)
$0.50 \to 1/2$ (Período estimado $r=2$)
$0.75 \to 3/4$ (Período estimado $r=4$)

Usando o período obtido de $r=4$, calculamos os fatores primos. Como $a=7$ e $r=4$: $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

E assim, conseguimos fatorar magistralmente o número $15 = 3 \times 5$.

[!TIP] Se o valor de medição $y=128$ (fase $0.5$) for obtido, o denominador será $2$, e em vez do período real $r=4$, obteremos um divisor dele. Em casos como este, você pode encontrar o período real executando o algoritmo várias vezes ou verificando múltiplos do $r$ obtido.

6. Desafios para Aplicação Prática e os Limites da Era NISQ

Embora tenha sido fácil fatorar $N=15$ em um simulador, fatorar o RSA-2048 (um número de 617 dígitos decimais) usado no mundo real ainda esbarra em várias barreiras para os computadores quânticos atuais.

A época em que vivemos hoje é chamada de Era NISQ (Noisy Intermediate-Scale Quantum: computadores quânticos de escala intermediária com ruído). Os qubits são extremamente vulneráveis a ruídos ambientais externos e frequentemente sofrem “descoerência” (decoherence) no meio dos cálculos, quebrando o estado quântico.

Para executar circuitos profundos (com um grande número de portas) de maneira precisa, como o algoritmo de Shor, é essencial a Correção de Erros Quânticos (Quantum Error Correction), que corrige esses ruídos. Para criar um “qubit lógico” livre de ruído, é necessário codificar milhares de “qubits físicos” usando métodos como o Código de Superfície (Surface Code).

Para quebrar a criptografia RSA de 2048 bits, estima-se que sejam necessários milhares de qubits lógicos perfeitos, e para alcançá-los, seriam necessários computadores quânticos tolerantes a falhas (Fault-Tolerant Quantum Computers) equipados com milhões a dezenas de milhões de qubits físicos. Como até os processadores quânticos mais avançados atualmente possuem apenas algumas centenas a milhares de qubits físicos, a criptografia do mundo não será imediatamente quebrada.

[!WARNING] No entanto, existe um modelo de ameaça conhecido como “Store Now, Decrypt Later (Guarde Agora, Descriptografe Depois)”. Os invasores podem armazenar em massa comunicações confidenciais criptografadas atuais e planejar a estratégia de decifrá-las todas de uma vez daqui a 10 a 20 anos, quando computadores quânticos poderosos estiverem concluídos.

7. Transição para Criptografia Pós-Quântica (PQC)

Em preparação para a chegada desse “Q-Day (O dia em que os computadores quânticos quebrarão a criptografia)”, os pesquisadores de criptografia do mundo todo, liderados pelo Instituto Nacional de Padrões e Tecnologia dos EUA (NIST), estão avançando no desenvolvimento da Criptografia Pós-Quântica (Post-Quantum Cryptography, PQC).

A PQC se baseia em novos problemas matemáticos (como problemas de reticulados, polinômios multivariados, funções hash, etc.) que são matematicamente considerados como ineficientes de se resolver, mesmo utilizando o algoritmo de Shor (ou o algoritmo de Grover). Já foram escolhidos algoritmos como “CRYSTALS-Kyber” e “CRYSTALS-Dilithium” como normas padrão, e sua introdução gradual começou em serviços como o iMessage da Apple e em protocolos de comunicação de vários navegadores da web.

Para os engenheiros que gerenciam a infraestrutura de TI, incorporar a “Cripto-Agilidade (Crypto-Agility: a capacidade de alterar o esquema de criptografia rapidamente)” em seus sistemas para fazer a transição da criptografia RSA e de curvas elípticas existente para a PQC será uma grande missão nos próximos anos.

8. Conclusão

Neste artigo, fornecemos uma explicação minuciosa e abrangente — com cerca de 10.000 caracteres —, desde a base teórica e matemática do algoritmo de Shor, passando pelo mecanismo de extração de período usando a transformada quântica de Fourier, até chegarmos ao código específico de simulação em Python e Qiskit.

O fato de as leis físicas microscópicas da mecânica quântica virarem de cabeça para baixo a teoria da complexidade computacional e a teoria da criptografia, fundamentais para a ciência da informação em escala macro, é uma das mudanças de paradigma mais emocionantes da história da ciência. Vale a pena continuar acompanhando a evolução das tecnologias de computação quântica e a disputa contra as novas técnicas de criptografia que se desenvolvem para combatê-las.

Recomendo muito que você execute o código Python introduzido aqui em seu próprio ambiente e experimente a “magia da computação” gerada pela sobreposição e interferência dos estados quânticos.

Referências

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【Ilustrado PQC】Comparação dos principais algoritmos de criptografia pós-quântica

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

1. Introdução: A “crise da criptografia” trazida pelos computadores quânticos

Na sociedade da internet moderna, a tecnologia de criptografia de chave pública é infraestrutura indispensável para proteger a confidencialidade das comunicações e a integridade dos dados. A criptografia RSA e a criptografia de curva elíptica (ECC), amplamente utilizadas hoje, dependem de barreiras matemáticas, respectivamente a “dificuldade de fatoração de números compostos gigantescos” e a “dificuldade do problema do logaritmo discreto em curvas elípticas”, para garantir a segurança. Em computadores clássicos (os computadores que usamos hoje, incluindo supercomputadores), está provado que resolver esses problemas matemáticos levaria mais tempo do que a idade do universo, o que tem sido a base de sua segurança.

No entanto, essa premissa robusta está prestes a ser fundamentalmente derrubada pelo progresso na teoria e aplicação prática dos computadores quânticos. O “Algoritmo de Shor”, publicado em 1994 pelo criptógrafo Peter Shor, provou teoricamente que problemas de fatoração de primos e logaritmos discretos podem ser resolvidos em “tempo polinomial” executando-os em um computador quântico universal tolerante a falhas (CRQC: Cryptographically Relevant Quantum Computer) com desempenho suficiente. Isso significa que toda a criptografia de chave pública atualmente em uso será neutralizada.

graph TD A["Computador quântico de grande escala (CRQC)"] -->|Execução| B["Algoritmo de Shor"] B -->|Decodificação em tempo polinomial| C["Problema de fatoração (RSA)"] B -->|Decodificação em tempo polinomial| D["Problema de logaritmo discreto (ECC / ECDSA)"] C --> E["Interceptação, alteração de dados e falsificação de comunicação criptografada"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

É muito perigoso pensar que “não há problema porque a conclusão em grande escala dos computadores quânticos ainda está a décadas de distância”. Isso ocorre porque o método de ataque chamado Store Now, Decrypt Later (SNDL: Armazene agora, descriptografe depois) já se tornou uma ameaça real. Trata-se de um ataque em que nações maliciosas ou organizações de hackers armazenam grandes quantidades de dados de comunicação atualmente criptografados (como o tráfego TLS) e os descriptografam todos no momento em que computadores quânticos poderosos se tornarem disponíveis no futuro. Segredos de estado, informações de infraestrutura e dados médicos que devem ser protegidos a longo prazo já estão expostos a essa ameaça.

Além disso, para criptografia de chave simétrica (como AES) e funções de hash (como SHA-256), existe o Algoritmo de Grover, descoberto em 1996. Isso reduz a complexidade computacional dos ataques de força bruta (brute force) à sua raiz quadrada. Em outras palavras, o nível de segurança do AES-128 é efetivamente reduzido pela metade, para 2 à potência de 64, portanto, na era quântica, recomenda-se usar chaves mais longas e comprimentos de hash como AES-256 e SHA-384.

A Criptografia Pós-Quântica (PQC), baseada em novos problemas matemáticos difíceis de decifrar, mesmo usando computadores quânticos, nasceu para combater essa crise criptográfica sem precedentes. Neste artigo, com base nos resultados do processo de padronização PQC liderado pelo Instituto Nacional de Padrões e Tecnologia dos EUA (NIST), explicaremos os principais algoritmos PQC em detalhes extremos, desde sua base matemática até seus mecanismos e comparação de arquitetura.

2. Todo o escopo e história do projeto de padronização PQC do NIST

A transição da tecnologia de criptografia leva anos ou até décadas, incluindo o redesenho de protocolos, atualizações de sistema, substituição de hardware, etc. Por esse motivo, criptógrafos de todo o mundo vêm avançando na pesquisa PQC desde cedo. O NIST dos EUA desempenhou um papel central nisso. O NIST abriu o processo de padronização PQC ao público em 2016 e aceitou propostas de algoritmos de criptografia completamente novos da comunidade criptográfica global.

As duas categorias principais para padronização foram as seguintes:

Criptografia de chave pública / Mecanismo de encapsulamento de chaves (KEM: Key Encapsulation Mechanism): Um mecanismo para compartilhar de forma segura uma chave simétrica para criptografar o caminho de comunicação, como em conexões TLS.
Assinaturas digitais (Digital Signatures): Um mecanismo para provar que os dados não foram alterados e que não há falsificação pelo remetente (autenticidade) em atualizações de software e certificados digitais.

Após quase 6 anos de feroz avaliação, análise e competição criptoanalítica (Rodada 1 à Rodada 3), alguns algoritmos também foram submetidos a uma avaliação adicional na Rodada 4. Como resultado, em 2024, os seguintes algoritmos foram oficialmente emitidos como Padrões Federais de Processamento de Informação (FIPS) e foram estabelecidos como padrões globais futuros.

FIPS 203 (ML-KEM): KEM baseado em CRYSTALS-Kyber
FIPS 204 (ML-DSA): Assinatura digital baseada em CRYSTALS-Dilithium
FIPS 205 (SLH-DSA): Assinatura baseada em hash sem estado baseada em SPHINCS+
(Planejado para formulação futura) FN-DSA: Assinatura digital baseada em FALCON

Cada um desses algoritmos selecionados se baseia em diferentes “problemas de dificuldade” matemáticos, garantindo diversidade (Crypto Agility) de modo que, mesmo se uma vulnerabilidade fatal for descoberta em um algoritmo no futuro, o sistema inteiro não entrará em colapso. No processo de padronização, a criptografia baseada em reticulados (Lattice-based cryptography) assumiu o papel principal principalmente do ponto de vista do desempenho, mas a criptografia baseada em hash e a criptografia baseada em código foram adotadas como backups fortes.

3. Classificação das principais abordagens matemáticas para PQC

Os algoritmos PQC são categorizados principalmente nas 5 áreas a seguir com base nos problemas matemáticos em que baseiam sua segurança. Neste artigo, nos aprofundaremos principalmente nas três primeiras.

Criptografia baseada em reticulados (Lattice-based Cryptography): Baseia-se no Problema do Vetor Mais Curto (SVP) e no Problema do Vetor Mais Próximo (CVP) em espaços de reticulados multidimensionais, e no problema LWE derivado deles. É o centro da padronização do NIST, incluindo Kyber, Dilithium e FALCON. Possui o melhor equilíbrio entre velocidade de processamento, tamanho da chave pública e tamanho do texto cifrado, sendo adequado para uso geral.
Criptografia baseada em hash (Hash-based Cryptography): Baseia sua segurança unicamente na “resistência à colisão” e “unidirecionalidade” das funções de hash criptográficas (como SHA-2 e SHAKE). É aplicável apenas a assinaturas digitais (SPHINCS+, etc.), mas tem a prova matemática mais forte de segurança e é caracterizada por uma resistência extremamente alta a ataques matemáticos desconhecidos.
Criptografia baseada em código (Code-based Cryptography): Baseado na teoria de códigos de correção de erros, depende da dificuldade do Problema de Decodificação de Síndrome (Syndrome Decoding Problem). O Classic McEliece, proposto na década de 1970, é representativo e, embora tenha uma longa história e segurança comprovada, o tamanho da chave pública é extremamente grande, chegando a megabytes.
Criptografia polinomial multivariada (Multivariate Polynomial Cryptography): Baseia-se na dificuldade de encontrar soluções para um sistema de equações quadráticas simultâneas multivariadas sobre um corpo finito (problema MQ). Foi proposto principalmente para assinaturas digitais (como Rainbow), mas durante a rodada final do NIST, descobriu-se um método de ataque poderoso que o decifrou em alguns dias em um único PC, levando muitos algoritmos a serem retirados da padronização.
Criptografia baseada em isogenia (Isogeny-based Cryptography): Baseado no problema de encontrar caminhos em grafos de isogenia (Isogeny) de curvas elípticas. Com um tamanho de chave muito pequeno, era esperado que fosse o sucessor legítimo da ECC, mas seu candidato final, “SIKE”, foi completamente decifrado em poucas horas num PC normal usando matemática clássica (como o ataque de Castryck-Decru) em 2022, resultando num final dramático que simboliza a dificuldade e o terror do design de PQC.

4. O abismo da criptografia baseada em reticulados: A base matemática do problema LWE e do Module-LWE

Atualmente considerada a mais promissora e o centro da padronização, a criptografia baseada em reticulados. Na raiz de sua segurança está o Problema LWE (Learning with Errors: Aprendizado com Erros). Proposto por Oded Regev em 2005, essa conquista inovadora lhe rendeu o Prêmio Gödel. A compreensão moderna da PQC é impossível sem entender o problema LWE.

4.1. O que é o problema LWE (Learning with Errors)?

Primeiro, vamos considerar um sistema simples de equações lineares. Suponha que, sob um certo módulo $q$ (módulo $q$), temos uma matriz aleatória conhecida $A$, um vetor secreto desconhecido $\vec{s}$, e seu produto $\vec{b}$ é dado.

$$ \vec{b} = A\vec{s} \pmod q $$

Neste caso, é fácil encontrar o desconhecido $\vec{s}$ a partir das informações públicas $A$ e $\vec{b}$. Usando o clássico “método de eliminação de Gauss”, $\vec{s}$ pode ser facilmente calculado em tempo polinomial.

No entanto, adicionar um “pequeno erro (ruído) intencional” a esta equação aumenta drasticamente a dificuldade do problema. Este é o problema LWE.

Preparamos um vetor secreto desconhecido $\vec{s} \in \mathbb{Z}_q^n$ e uma matriz escolhida aleatoriamente $A \in \mathbb{Z}_q^{m \times n}$. Além disso, preparamos um vetor de erro $\vec{e} \in \mathbb{Z}_q^m$, escolhido de acordo com uma distribuição normal ou binomial, cujos “valores dos elementos são suficientemente pequenos”, e calculamos $\vec{b}$ da seguinte forma:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

O Problema LWE de Busca (Search LWE) é o problema de “encontrar a informação secreta $\vec{s}$ a partir da informação pública $(A, \vec{b})$”. Devido à existência deste erro $\vec{e}$, se você tentar métodos algébricos como a eliminação de Gauss, o erro $\vec{e}$ será amplificado como uma bola de neve durante a adição e subtração das equações, tornando-se indistinguível de valores aleatórios e, em última análise, colapsando.

A maravilha do problema LWE é que existe uma prova teórica forte (redução) de que, a menos que haja um algoritmo quântico que possa resolver os problemas de complexidade do pior caso (Worst-case hardness) no reticulado, como o GapSVP (Problema de Decisão do Vetor Mais Curto) ou SIVP (Problema de Vetores Independentes Mais Curtos), o problema LWE também não pode ser resolvido no caso médio (Average-case). Em outras palavras, mesmo chaves criptográficas geradas aleatoriamente têm garantia de forte segurança apoiada por limites teóricos.

4.2. Aumento drástico na eficiência através do Ring-LWE e Module-LWE

O problema LWE normal (Standard LWE) tem uma base de segurança muito clara, mas o tamanho da matriz $A$ se torna muito grande, resultando em chaves na ordem de megabytes, tornando-o impraticável. A abordagem proposta para resolver isso foi usar anéis polinomiais (Polynomial Rings) para introduzir estrutura algébrica.

No problema Ring-LWE, em vez de simples vetores e matrizes, usamos os elementos (polinômios) de um anel polinomial $R_q$. O anel polinomial ciclotômico a seguir é comumente usado nos padrões do NIST:

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Aqui, $n$ é uma potência de 2 (por exemplo: 256) e $q$ é um número primo apropriado. Neste anel, calculamos $b = a \cdot s + e \pmod q$ usando elementos $a, s, e \in R_q$. Como um único polinômio $a$ tem $n$ coeficientes, os dados podem ser consideravelmente compactados, e usando a NTT (Transformada Teórica dos Números: Number Theoretic Transform), que é uma versão de corpo finito da Transformada Rápida de Fourier (FFT), a multiplicação de polinômios torna-se ultrarrápida com complexidade $O(n \log n)$.

No entanto, o Ring-LWE tinha a preocupação de que “vulnerabilidades desconhecidas poderiam existir devido à estrutura algébrica especial do anel”. Além disso, para alterar o nível de segurança (por exemplo, equivalente a AES-128, 192, 256), o próprio grau do polinômio $n$ precisava ser alterado, e com isso, toda a implementação, como o algoritmo NTT, tinha que ser reescrita, apresentando um desafio de engenharia.

Portanto, o problema Module-LWE (M-LWE) foi adotado pelos algoritmos padronizados Kyber e Dilithium. Module-LWE é um compromisso, situando-se exatamente entre o Standard LWE, sem estrutura, e o Ring-LWE, excessivamente estruturado. Ele usa uma matriz $k \times k$ (módulo) cujos elementos são componentes do anel polinomial $R_q$.

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

A maior vantagem do Module-LWE é que, mantendo o grau do polinômio $n$ constante ($n=256$ no padrão NIST), o nível de segurança pode ser facilmente escalado simplesmente mudando a dimensão da matriz $k$. Por exemplo, no caso do Kyber, a dimensão $k$ é ajustada da seguinte forma:

Kyber512 (Nível 1): $k = 2$ (equivalente a AES-128)
Kyber768 (Nível 3): $k = 3$ (equivalente a AES-192)
Kyber1024 (Nível 5): $k = 4$ (equivalente a AES-256)

Isso tornou possível reutilizar 100% do código NTT subjacente e circuitos de hardware de operações polinomiais em todos os níveis de segurança, melhorando drasticamente a segurança e a eficiência da implementação.

5. CRYSTALS-Kyber (ML-KEM): O Mecanismo de Encapsulamento de Chaves de Próxima Geração

O CRYSTALS-Kyber, oficialmente padronizado como FIPS 203 (ML-KEM), é um mecanismo de encapsulamento de chaves (KEM) baseado no problema Module-LWE descrito acima. No futuro, se tornará o padrão global de fato para compartilhar chaves de sessão com segurança em TLS 1.3, SSH, etc.

5.1. Arquitetura do KEM (Key Encapsulation Mechanism)

Na era da PQC, a abordagem de encapsulamento de KEM torna-se padrão, em vez da abordagem direta como no RSA, onde “o cliente cria uma chave simétrica e a criptografa com a chave pública do servidor e a envia”.

sequenceDiagram participant Client as "Cliente (Alice)" participant Server as "Servidor (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Gera a chave secreta (sk) e a chave pública (pk)" Client->>Server: "Envia a chave pública (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Gera uma chave simétrica aleatória (K)" Server->>Server: "Encapsula K com pk para criar o texto cifrado (c)" Server->>Client: "Envia o texto cifrado (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Descriptografa o texto cifrado (c) usando a chave secreta (sk)" Client->>Client: "Desencapsula para extrair a chave simétrica (K)" Note over Client, Server: "Inicia a comunicação criptografada usando a chave simétrica compartilhada (K) via AES, etc."

5.2. O mecanismo algorítmico interno do Kyber e a Transformada de Fujisaki-Okamoto

O design do Kyber é extremamente refinado. Primeiro, constrói-se um esquema de criptografia de chave pública (Kyber.CPAPKE) seguro apenas contra CPA (Ataque de Texto Simples Escolhido). Em seguida, aplicando um método criptográfico muito poderoso chamado Transformada de Fujisaki-Okamoto (Fujisaki-Okamoto Transform), ele é atualizado para um KEM completo, seguro até mesmo contra CCA (Ataque de Texto Cifrado Escolhido Adaptativo).

Os mecanismos principais de criptografia e descriptografia do CPAPKE são os seguintes:

Geração de Chave (Key Generation):
- A partir de um valor semente aleatório, gera uma matriz $A \in R_q^{k \times k}$ no domínio NTT. O módulo $q$ usado é $3329$.
- Um vetor secreto $\vec{s}$ e um vetor de erro $\vec{e}$ com coeficientes pequenos são amostrados de uma distribuição binomial centralizada (CBD).
- Calcula $\vec{t} = A\vec{s} + \vec{e}$. A chave pública é $(A, \vec{t})$ e a chave secreta é $\vec{s}$. (Na prática, $A$ é revelado como um valor de semente para economizar largura de banda).
Criptografia (Encryption):
- Uma mensagem de 32 bytes a ser compartilhada (o material para a chave simétrica) $m$ é codificada em um polinômio.
- Um novo vetor aleatório $\vec{r}$ e pequenos erros $\vec{e_1}, e_2$ são gerados.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- O texto cifrado é $(\vec{u}, v)$.
Descriptografia (Decryption):
- O receptor calcula $v - \vec{s}^T\vec{u}$.
- Expandindo esta fórmula, obtemos o seguinte: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- Substituindo $\vec{t} = A\vec{s} + \vec{e}$ aqui, o termo principal $\vec{s}^TA^T\vec{r}$ se cancela.
- O que resta é $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- O termo entre parênteses é “o produto ou soma de pequenos erros”, então permanece um valor pequeno (ruído) como um todo. Portanto, julgando pelos limites se cada coeficiente está perto de $0$ ou de $q/2$, os bits (0 ou 1) da mensagem original $m$ podem ser perfeitamente restaurados sem erros.

A maior força do Kyber é sua impressionante velocidade de processamento e tamanho de chave moderado. Para o Kyber768, o tamanho da chave pública é de 1.184 bytes e o tamanho do texto cifrado é de 1.088 bytes. Embora sejam maiores em comparação com o RSA-3072 (tamanho da chave em torno de 384 bytes), eles podem caber dentro do MTU (Maximum Transmission Unit) das comunicações modernas da internet sem fragmentação de pacotes, tendo um efeito adverso quase nulo na latência da rede.

6. CRYSTALS-Dilithium (ML-DSA): Assinatura digital de uso geral baseada em reticulado

Na padronização de assinaturas digitais, algoritmos com diferentes filosofias de design competiram mesmo na mesma abordagem de criptografia baseada em reticulado. Dentre eles, CRYSTALS-Dilithium foi selecionado como FIPS 204 (ML-DSA) para ser a assinatura digital de uso geral.

6.1. Paradigma Fiat-Shamir com Abortos

Como o Kyber, Dilithium é um esquema de assinatura digital baseado no problema Module-LWE (e no problema Module-SIS). O design é baseado no paradigma extremamente importante chamado “Fiat-Shamir with Aborts (Transformada de Fiat-Shamir com Interrupções)”.

A transformada Fiat-Shamir em si é um método padrão para converter um protocolo de prova de conhecimento zero interativo em uma assinatura digital não interativa. O provador (assinante) gera um compromisso $y$, calcula $w = Ay$, passa-o por uma função de hash para obter um desafio aleatório $c$ e calcula a resposta $z = y + cs$.

No entanto, quando isso é aplicado de forma simples à criptografia baseada em reticulado, a distribuição da resposta $z$ torna-se enviesada dependendo do valor da chave secreta $s$, levando a um problema fatal (vazamento matemático do tipo canal lateral) em que as informações da chave secreta $s$ vazam gradualmente para um invasor que observa um grande número de assinaturas.

A equipe de design do Dilithium (Lyubashevsky et al.) introduziu um método chamado “Rejection Sampling (Amostragem de Rejeição)”: se os coeficientes do resultado do cálculo da assinatura $z$ não se enquadrarem em um intervalo de limite de segurança predefinido, todo o processo de assinatura é abortado, e os cálculos são reiniciados desde o início usando um novo número aleatório $y$.

Como resultado, a assinatura final $z$ tem uma distribuição perfeitamente uniforme, completamente independente da chave secreta, evitando totalmente qualquer vazamento matemático de informações.

6.2. Vantagens e facilidade de implementação do Dilithium

Uma grande vantagem de design do Dilithium é que ele não usa de forma alguma “amostragem de distribuição gaussiana” ou “operações de ponto flutuante” complexas no processo de geração de assinatura. Como pode ser implementado apenas com amostragem de distribuição uniforme, aritmética modular de inteiros simples, NTT e funções de hash (SHAKE), é fácil de implementar de forma segura e com tempo constante (Constant-time) em uma ampla variedade de ambientes, de microcontroladores embarcados a servidores em nuvem. Isso lhe dá uma forte resistência contra ataques físicos de canal lateral, como ataques de tempo.

7. FALCON (FN-DSA): Assinatura de reticulado extremamente compacta

O NIST selecionou FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU), outra assinatura baseada em reticulado com características diferentes do Dilithium, como um candidato de padronização (atualmente em elaboração como FN-DSA).

7.1. Reticulado NTRU e Amostragem Gaussiana

A maior característica do FALCON é que ele usa reticulados NTRU (N-th degree Truncated polynomial Ring Units), com uma longa história que remonta a 1996, em vez do problema LWE. Além disso, adota o paradigma “Hash-and-Sign (Fazer hash e assinar)” baseado na estrutura GPV (Gentry-Peikert-Vaikuntanathan).

No Hash-and-Sign, o valor do hash da mensagem é o ponto alvo no espaço, e o ponto no reticulado mais próximo desse ponto (a solução aproximada para o Problema do Vetor Mais Próximo) torna-se a assinatura. Isso requer a amostragem de pontos de acordo com uma distribuição gaussiana discreta, usando uma “base curta e de boa qualidade” que é a chave secreta.

O FALCON acelerou drasticamente esse cálculo pesado usando uma técnica chamada “Ortogonalização Rápida de Fourier (Fast Fourier Orthogonalization: FFO)”.

7.2. Vantagens e Desvantagens do FALCON

A vantagem esmagadora do FALCON é que o tamanho da assinatura e da chave pública são extremamente pequenos (compactos). Enquanto o tamanho da assinatura do Dilithium3 é de cerca de 3.309 bytes, o tamanho da assinatura do FALCON-512 é de apenas cerca de 666 bytes. A chave pública também é bem pequena, 897 bytes, tornando-se uma salvação em ambientes com limitações severas de largura de banda, dispositivos IoT e determinados protocolos de rede.

No entanto, há uma desvantagem significativa. Como a amostragem gaussiana discreta, que requer cálculos complexos de ponto flutuante (64 bits IEEE 754), é obrigatória na geração de assinaturas, é extremamente difícil conseguir uma implementação em tempo constante para evitar o vazamento de tempo, e o código se torna massivo. Devido a isso, o FALCON é posicionado como um algoritmo altamente especializado para aplicações específicas, ao invés de uso geral (como o Dilithium).

graph LR A["Requisitos de assinatura digital"] --> B{"Qual é a restrição prioritária?"} B -->|"Simplicidade de implementação, uso geral, facilidade de tempo constante"| C["Dilithium (ML-DSA)"] B -->|"Minimizar largura de banda, compactação do tamanho de dados"| D["FALCON (FN-DSA)"] C --> E["Certificados TLS de uso geral, assinatura digital de software"] D --> F["Protocolos com limitações rigorosas de tamanho de pacote, ambientes especiais"]

8. SPHINCS+ (SLH-DSA): Assinatura baseada em hash que ostenta a maior segurança

Em preparação para o pior cenário, onde a segurança da criptografia baseada em reticulados seja no futuro quebrada por avanços de matemáticos geniais, o NIST estabeleceu o FIPS 205 (SLH-DSA), ou seja, SPHINCS+, como padrão, possuindo uma abordagem completamente diferente da criptografia de reticulado.

O SPHINCS+ é classificado como uma assinatura baseada em hash. O fundamento para sua segurança depende de um único ponto: “a função hash criptográfica usada (como SHA-2 ou SHAKE256) tem resistência a colisões e unidirecionalidade”. Como não depende de problemas matemáticos com uma estrutura algébrica específica, como LWE ou fatoração, ele possui uma segurança extremamente robusta (a segurança mais conservadora): não importa quão poderosos os algoritmos quânticos se tornem no futuro, isso pode ser contra-atacado simplesmente estendendo o comprimento da saída da função hash.

8.1. Arquitetura Stateless com WOTS+ e FORS

O histórico das assinaturas baseadas em hash é antigo, remontando à Assinatura Lamport e à Assinatura de Uso Único de Winternitz (WOTS) da década de 1970. Eram chaves descartáveis que “podiam ser usadas para assinar com segurança apenas uma vez”. Para permitir o uso múltiplo, algoritmos como XMSS (eXtended Merkle Signature Scheme) e LMS foram desenvolvidos, combinando a Árvore de Merkle para gerenciar um número infinito de chaves descartáveis com um único hash raiz.

No entanto, XMSS e LMS tinham uma falha grave: eram “Stateful (com retenção de estado)”. Exigia-se gravar o estado do índice de “qual chave descartável foi usada” na memória não-volátil rigorosamente a cada assinatura. Se, por exemplo, ao restaurar um snapshot de uma máquina virtual, o estado retrocedesse e a mesma chave fosse usada duas vezes, a chave secreta vazaria instantaneamente e o sistema entraria em colapso.

O SPHINCS+ é uma assinatura baseada em hash “Stateless (sem retenção de estado)” que resolve essa complexidade do gerenciamento de estado. A tecnologia principal é a seguinte combinação:

WOTS+ (Winternitz One-Time Signature Plus): Uma assinatura básica de uso único.
FORS (Forest of Random Subsets): Tecnologia de Assinatura de Poucas Vezes (Few-Time Signature). A segurança é mantida mesmo se a mesma chave for reutilizada algumas vezes.
Hyper-Tree (Estrutura de árvore gigante): Uma estrutura massiva com Árvores de Merkle sobrepostas em múltiplas camadas.

Na execução da assinatura, em vez de gerenciar o estado, o SPHINCS+ seleciona aleatoriamente usando números pseudoaleatórios uma das enormes quantidades de chaves FORS na base da Hyper-Tree e assina com ela. Como o número de folhas da árvore é astronomicamente grande, a probabilidade de escolher a mesma chave duas vezes por acaso (colisão) é baixa o suficiente para ser ignorada, realizando assim a propriedade stateless.

A única e maior fraqueza do SPHINCS+ é o tamanho gigantesco de suas assinaturas. Dependendo dos parâmetros, o tamanho pode variar de 17 kilobytes a 49 kilobytes, e a velocidade de geração de assinatura é esmagadoramente mais lenta em comparação com a criptografia de reticulado. Assim, o SPHINCS+ se destina a usos onde as assinaturas não são muito frequentes e a segurança absoluta de longo prazo é fortemente exigida, como assinatura para atualizações de software ou certificados de Autoridade de Certificação (CA) Raiz, ao invés da navegação web do dia-a-dia.

9. Criptografia baseada em código: O bom e velho gigante Classic McEliece

Uma abordagem importante que ainda está sendo avaliada como candidato final da Rodada 4 no processo de padronização do NIST é o Classic McEliece, uma criptografia baseada em código.

Proposto em 1978 por Robert McEliece, este algoritmo, juntamente com o RSA, é um dos mais antigos na história da criptografia de chave pública. Utiliza “Códigos de Goppa”, um código geométrico algébrico. Baseia-se no “Problema de Decodificação de Síndrome (Syndrome Decoding Problem)”, em que a mensagem é criptografada adicionando um erro intencional (vetor de ruído), e apenas aquele com a matriz de verificação de paridade do código de Goppa como chave secreta pode usar recursos poderosos de correção de erros para remover o ruído e recuperar a mensagem original.

$$ \vec{c} = \vec{m} G + \vec{e} $$

(Onde $G$ é a matriz geradora codificada (scrambled) atuando como chave pública, e $\vec{e}$ é o vetor de erro com peso $t$)

O que é mais incrível no Classic McEliece é o seu retrospecto avassalador: apesar de mais de 40 anos desde a sua proposta, e sujeito a intensas pesquisas de criptoanálise em todo o mundo, nenhuma vulnerabilidade fundamental foi descoberta. Ele tem a “segurança robusta mais bem comprovada pelo tempo” na PQC.

Além disso, tem a vantagem de um tamanho de texto cifrado extremamente pequeno (apenas cerca de 100 a 200 bytes). No entanto, há a desvantagem fatal de que o tamanho da chave pública chega à ordem de megabytes (MB). Mesmo no nível de segurança mais baixo (equivalente ao AES-128), a chave pública é de cerca de 250 KB e excede 1 MB nos níveis mais altos.

Portanto, não é aplicável em cenários onde a chave pública é transmitida pela rede em toda comunicação, como no handshake TLS. No entanto, em casos de uso especiais onde a chave pública pode ser pré-implantada no sistema (hardcoded), como na troca de chaves pré-compartilhadas em VPNs, chaves públicas no firmware ou comunicações por satélite, continua a ser investigada como uma escolha extremamente promissora devido à sua sólida segurança.

10. Comparação de desempenho de cada algoritmo PQC e trade-offs

Aqui está um resumo das características de desempenho nos níveis comuns de segurança (níveis 2 a 3 do NIST, equivalentes ao AES-128 a 192) para os principais algoritmos explicados até agora.

Algoritmo (Nome padrão)	Categoria	Base Matemática	Tamanho da chave pública	Tamanho da chave secreta	Tamanho texto cifrado/assin.	Tendência da vel. de processamento	Principais características e usos
Kyber768 (ML-KEM)	KEM	Module-LWE	1.184 Bytes	2.400 Bytes	1.088 Bytes	Muito rápida	Melhor equilíbrio de tamanho e velocidade. Padrão genérico de KEM para TLS 1.3, etc.
Dilithium3 (ML-DSA)	Assinatura	Module-LWE	1.952 Bytes	4.032 Bytes	3.309 Bytes	Geração e verificação rápidas	Implementação simples. Padrão genérico de assinatura digital.
FALCON-512 (FN-DSA)	Assinatura	Reticulado NTRU	897 Bytes	1.281 Bytes	666 Bytes	Geração de assin. um pouco lenta, verificação ultrarrápida	Tamanho de assinatura mínimo. Porém, exige ponto flutuante. Focado em sistemas embarcados/IoT.
SPHINCS+ (SLH-DSA)	Assinatura	Função Hash	32 Bytes	64 Bytes	Aprox. 17.000 Bytes	Geração muito lenta	Risco quase nulo de colapso matemático. Uso para alta segurança como certificados raiz.
Classic McEliece	KEM	Código Goppa	Aprox. 1,04 MB	13.568 Bytes	188 Bytes	Encapsulamento rápido	40 anos de histórico de segurança. Chave pública imensa. Para ambientes com hardcode.

Compreendendo os trade-offs

No mundo PQC, não existe um único algoritmo mágico que seja “pequeno em tamanho, rápido em velocidade e com garantia matemática perfeita”.

Padrões da Internet (Kyber / Dilithium): Possuem o melhor equilíbrio de desempenho, e são os mais adequados para um substituto direto (drop-in replacement) dos atuais RSA/ECC.
Conservadorismo Final (SPHINCS+): Selecionado quando você deseja uma garantia absoluta (seguro) contra avanços matemáticos futuros, mesmo com o sacrifício do tamanho dos dados e da velocidade de processamento.
Para ambientes especiais (FALCON / Classic McEliece): Armas de especialização escolhidas com base nas restrições do ambiente, como quando a largura de banda de comunicação é extremamente restrita ou quando a pré-distribuição é possível.

11. Desafios de implementação prática e a solução realística da “Criptografia Híbrida”

Com a conclusão da padronização pelo NIST e a emissão oficial do FIPS, a transição PQC das infraestruturas de TI mundiais (migração PQC) começou a sério. O navegador Chrome do Google, o iMessage da Apple (Protocolo PQ3), provedores de rede como Cloudflare, entre outros, já integraram o suporte PQC em seus protocolos e iniciaram operações reais.

Porém, existe um risco muito elevado em realizar uma transição completa e imediata para novos algoritmos de criptografia. Se, por exemplo, um matemático genial descobrir uma falha fatal de ataque (uma vulnerabilidade matemática decifrável até mesmo em um computador clássico) na criptografia de reticulado como o Kyber nos próximos anos, todo o sistema que depende dele será exposto instantaneamente.

Uma abordagem realística e recomendada para mitigar este risco de incerteza é a “Criptografia Híbrida (Hybrid Cryptography)”.

Na criptografia híbrida, você usa simultaneamente a criptografia clássica com longo histórico de confiabilidade (por exemplo: criptografia de curva elíptica como X25519) e o novo PQC (por exemplo: Kyber768) para realizar a troca de chaves. Os componentes de chaves comuns são gerados de forma independente por cada algoritmo e, finalmente, as duas partes são combinadas por meio de uma Função de Derivação de Chave (KDF) segura para gerar o segredo mestre final.

graph TD A["Cliente"] -->|① Envia chave pública X25519 + chave pública Kyber| B["Servidor"] B -->|② Retorna chave compartilhada X25519 + texto cifrado encapsulado Kyber| A A --> C{"Derivação do Segredo Mestre (KDF)"} B --> C C -->|Entrada: (chave comum X25519) || (chave comum Kyber)| D["Chave de comunicação segura (AES-256 / ChaCha20)"] D -->|"Resistente às ameaças quânticas e às vulnerabilidades clássicas"| E["Comunicação segura por criptografia híbrida (TLS 1.3)"]

Isso realiza uma postura de segurança robusta de dois níveis: “Mesmo que um computador quântico seja construído e a ECC seja quebrada, o Kyber protegerá a comunicação”, e inversamente, “Mesmo que uma falha matemática desconhecida seja descoberta no Kyber, a ECC protegerá a comunicação”. Como exemplo representativo, existe o rascunho X25519MLKEM768 (antigo X25519Kyber768) sendo padronizado na IETF, e a comunicação entre os navegadores Web atuais e servidores de ponta já é realizada usando exatamente esse método híbrido.

Além disso, na concepção do sistema, o conceito de “Crypto Agility (Agilidade Criptográfica)” – a arquitetura que permite não depender excessivamente de um algoritmo de criptografia específico e de poder mudar rapidamente para outro algoritmo (por exemplo, de Kyber para McEliece, de Dilithium para SPHINCS+) se um algoritmo for quebrado – se tornará um requisito indispensável para o desenvolvimento de sistemas no futuro.

12. Conclusão: Uma Nova Fronteira Tecnológica Criptográfica

Ironia do destino, o computador quântico, uma tecnologia dos sonhos da humanidade, tornou-se a maior ameaça a romper as paredes defensivas matemáticas, a “fatoração” e o “problema do logaritmo discreto”, nas quais confiamos por muitos anos. No entanto, criptógrafos de todo o mundo, sem se renderem, abriram domínios matemáticos multidimensionais muito mais profundos e complexos baseados em teorias de reticulados, árvores de funções hash e códigos de correção de erros, construindo novas muralhas defensivas conhecidas como Criptografia Pós-Quântica (PQC).

O término da padronização de FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) e FIPS 205 (SLH-DSA) pelo NIST não é a linha de chegada. É apenas o primeiro passo na épica jornada de migração para PQC que durará décadas. Para engenheiros de software e arquitetos de sistemas, o grande desafio tecnológico será como adaptar de forma otimizada os protocolos de rede e os sistemas para o “aumento no tamanho da chave” e “mudanças nos custos de computação” que esses novos algoritmos trazem.

O conflito entre os computadores quânticos e a criptografia é a área emocionante onde a exploração matemática e a evolução da tecnologia da humanidade se cruzam da forma mais intensa. Esperamos que através deste artigo, você tenha conseguido compreender profundamente as belas teorias matemáticas por trás da PQC e os mecanismos surpreendentes de cada algoritmo que moldará o futuro da cibersegurança.

Referências:

Programa de Padronização de Criptografia Pós-Quântica do NIST
FIPS 203: Padrão para Mecanismo de Encapsulamento de Chaves Baseado em Módulo de Reticulado
FIPS 204: Padrão para Assinaturas Digitais Baseado em Módulo de Reticulado
FIPS 205: Padrão para Assinaturas Digitais Stateless Baseadas em Hash