Construa e execute seu primeiro programa quântico

Introdução

No vídeo a seguir, Olivia Lanes guia você pelo conteúdo desta lição. Alternativamente, você pode abrir o vídeo do YouTube desta lição em uma janela separada.

Bem-vindo ao Use um computador quântico hoje! O objetivo deste curso é que você execute código em um computador quântico real no menor tempo possível, sem necessidade de conhecimento prévio. Vamos começar.

Esta primeira lição é uma introdução suave e prática à computação quântica que funciona tanto para iniciantes curiosos quanto para líderes ocupados. Você aprenderá sobre circuitos quânticos e escreverá um pequeno programa quântico que cria emaranhamento, e o executará em um computador quântico real da IBM®. Você também tem a opção de executar o mesmo programa em um simulador, caso prefira não executar em um computador quântico real.

Você pode executar este notebook do início ao fim em um runtime novo do Google Colab, ou executá-lo localmente.

Configuração

Para executar este notebook no Google Colab, você precisará de uma conta Google para poder abrir notebooks e executar células no navegador.

Para executar em um computador quântico real da IBM, você também precisará de uma (gratuita) conta na IBM Quantum® Platform. Você pode abrir uma instância usando o Open Plan para obter 10 minutos de tempo de unidade de processamento quântico (QPU) por janela móvel de 28 dias, o que na verdade é bastante! Se tiver problemas com sua conta, consulte a página de suporte.

Você também pode executar este notebook localmente após instalar o Qiskit seguindo as instruções na IBM Quantum Platform.

Instalação e importações

No Colab, instalamos as dependências dentro do notebook para que todos executem as mesmas ferramentas. A próxima célula instala o Qiskit com o módulo de visualização mais dois complementos: Aer (simuladores rápidos) e o cliente IBM Runtime (para execuções em computadores quânticos).

Em seguida, temos uma série de importações. A classe QuantumCircuit é onde definimos nossos bits quânticos, ou qubits, e definimos operações sobre esses qubits. Este é nosso primeiro termo quântico: um qubit é o bloco básico de construção da computação quântica, assim como um bit é o bloco de construção da computação clássica. Aprenderemos mais sobre as propriedades especiais dos qubits à medida que criamos nosso circuito. Em seguida, plot_histogram será usado para visualizar os resultados do nosso circuito quântico. AerSimulator permite simular o circuito quântico em um computador clássico. Mas os simuladores não conseguem executar circuitos quânticos na mesma escala que os computadores quânticos reais; é por isso que precisamos de computadores quânticos reais. Isso pode ser útil para testes, depuração ou fins educacionais; ou se você esgotou seus 10 minutos gratuitos de tempo de QPU. O preset_passmanagers ajuda a otimizar os circuitos para que sejam executados de forma eficiente no hardware, o que se torna realmente importante à medida que nossos circuitos se tornam mais complexos. Sampler e QiskitRuntimeService são necessários para realmente executar o circuito no computador quântico. Mais sobre isso adiante.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit

!pip install 'qiskit[visualization]' qiskit-ibm-runtime qiskit-aer
# Core Qiskit imports
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# IBM Runtime specific imports
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

A seguir, faremos uma rápida verificação do ambiente. Confirmamos as versões e as importações.

Se algo falhar aqui, geralmente é um problema de instalação de dependências; corrigi-lo agora evita erros confusos mais adiante.

import sys

import qiskit
import qiskit_aer
import qiskit_ibm_runtime

print("Python:", sys.version.split()[0])
print("qiskit:", qiskit.__version__)
print("qiskit-aer:", qiskit_aer.__version__)
print("qiskit-ibm-runtime:", qiskit_ibm_runtime.__version__)

Python: 3.12.2
qiskit: 2.2.3
qiskit-aer: 0.17.2
qiskit-ibm-runtime: 0.41.1

Uma breve missão paralela: use o Composer

Antes de escrever código, é útil ver os circuitos visualmente. O Composer da IBM Quantum permite que você construa circuitos arrastando portas para os fios. É uma ótima maneira de aprender o que um circuito está fazendo sem se distrair com a sintaxe.

Abra o Composer aqui.

Depois que ele carregar, inicie o tutorial guiado pelo menu: Help | Build your first circuit. Trabalhe nele no seu próprio ritmo. À medida que avança, preste atenção em como cada porta altera o que você espera medir.

O tutorial percorre a construção do circuito "Hello World". Ele é visualizado no que é chamado de diagrama de circuito, onde os qubits são representados por linhas horizontais e as portas atuando sobre esses qubits são representadas por caixas ou outros símbolos nas linhas. Este circuito nos apresenta alguns recursos-chave dos qubits e dos computadores quânticos:

Primeiro, a caixa vermelha rotulada "H" é uma porta Hadamard, que cria um estado de superposição do qubit 0. Diferentemente de um bit, que só pode estar no estado 1 ou 0, o estado de um qubit pode incluir ambas as possibilidades ao mesmo tempo, com certos pesos (chamados amplitudes) atribuídos a cada um. Superposição não significa que você verá os dois resultados em uma única medição; significa que o estado é configurado de modo que qualquer um dos resultados possa ocorrer quando você medir.

Segundo, os círculos e a linha vertical conectando os dois qubits são uma porta CNOT, que gera emaranhamento entre os dois qubits. Emaranhamento é um tipo especial de ligação entre qubits. Quando os qubits estão emaranhados, os resultados das medições podem estar fortemente correlacionados de uma maneira que não corresponde ao que esperaríamos de lançamentos independentes de moedas comuns, ou de qualquer correlação clássica. Quando dois qubits estão emaranhados, medir um lhe dirá instantaneamente o resultado da medição do outro.

Outra ideia chave que você verá no tutorial são os shots. Como a medição é o momento em que um qubit deixa de se comportar como um estado quântico e fornece uma leitura clássica, um estado de superposição colapsará probabilisticamente para 0 ou 1 quando for medido. Portanto, para aprender sobre essa superposição, você precisa medi-la muitas vezes executando o mesmo circuito para acumular estatísticas. Estes são chamados de shots.

Verifique seu entendimento

Pense em cada pergunta abaixo e, em seguida, clique para revelar a resposta.

Você pode ver uma superposição diretamente a partir de uma única medição?

Resposta

Não. Uma única medição sempre retorna um valor clássico: 0 ou 1. A ideia de "mistura" só aparece nas estatísticas que você vê após muitas execuções, também chamadas de shots.

Em linguagem simples, o que o emaranhamento lhe oferece?

Resposta

Ele lhe dá resultados ligados. Medir um qubit lhe diz algo sobre o outro. Esse vínculo é mais forte do que a aleatoriedade independente e mais forte do que qualquer correlação puramente clássica ou aleatoriedade compartilhada pode explicar.

Se um qubit está em uma superposição, o que você vê em uma única medição e por que precisa de muitos shots?

Resposta

Em uma única medição, você vê apenas um resultado clássico: 0 ou 1. Você precisa de muitos shots porque a "superposição" se manifesta como uma distribuição de probabilidade, que só pode ser estimada coletando estatísticas em execuções repetidas.

Olhe para o histograma de medição do seu circuito Hello World no Composer. O que você vê? Por que esta é uma assinatura do emaranhamento?

Resposta

Ele mostra uma chance de 50% de estar no estado $|00\rangle$ e uma chance de 50% de estar no estado $|11\rangle$. Isso significa que se você medir um e obtiver 0, o outro também será 0, e se medir um e obter 1, o outro também será 1. Esta é uma correlação entre os dois qubits que pode ser explicada pelo emaranhamento.

Crie e execute um programa quântico usando o Qiskit

Ok, de volta à programação. Vamos gerar o mesmo estado emaranhado que fizemos no Composer (chamado estado de Bell $\Phi^+$ (phi-plus)), mas desta vez escreveremos o código manualmente. Precisamos desenvolver essa habilidade porque, à medida que escalamos para mais qubits e circuitos mais complexos, o Composer não conseguirá nos ajudar.

Para construir o circuito do estado de Bell, usamos uma porta $H$ (Hadamard) para colocar o primeiro qubit em uma superposição igual. Em seguida, aplicamos uma porta $CX$ (controlled-NOT), que emaranha os dois estados. Os dois qubits estão agora correlacionados de uma maneira que não tem equivalente clássico.

# --- Build the Bell circuit (phi-plus) ---
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()  # creates a classical register named "meas"

bell.draw("mpl")

Função auxiliar para executar circuitos

Agora vamos definir uma função auxiliar que cuida do processo de executar um circuito quântico e recuperar os resultados de medição. Esta função cuida de transpilar o circuito para corresponder ao conjunto de instruções do backend, executá-lo através de uma primitiva Sampler e extrair as contagens dos resultados.

def run_circuit_and_get_counts(circuit, backend, shots=1000):
    """
    Runs a quantum circuit on a specified backend and returns the measurement counts.

    Args:
        circuit (QuantumCircuit): The quantum circuit to run.
        backend: The Qiskit backend (real device or simulator).
        shots (int): The number of shots to run the circuit.

    Returns:
        dict: A dictionary of measurement counts.
    """
    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
    isa_circuit = pm.run(circuit)

    sampler = Sampler(mode=backend)

    job = sampler.run([isa_circuit], shots=shots)
    result = job.result()

    return result[0].data.meas.get_counts()

Execute em uma QPU e visualize os resultados

Por fim, executamos o circuito em uma unidade de processamento quântico (QPU) da IBM na nuvem por 1000 shots e plotamos os resultados. As QPUs da IBM são sistemas físicos que podem captar ruído, então as portas são ligeiramente imperfeitas, as medições podem estar erradas às vezes, e a calibração do dispositivo se desvia ao longo do tempo.

Executar em computadores quânticos reais também introduz considerações práticas. Os trabalhos podem ficar em uma fila, porque muitas pessoas podem estar usando o mesmo dispositivo. Você também precisa escolher uma contagem de shots que equilibre considerações estatísticas (mais shots equivale a uma maior relação sinal-ruído) com restrições de tempo/custo.

Siga as instruções nos comentários do código da próxima célula. Após executar a célula, você deverá ver um histograma com contagens aproximadamente iguais para as bitstrings $00$ e $11$, com algumas ocorrências de $01$ ou $10$ devido ao ruído. A célula seguinte neste notebook executa o mesmo circuito em um simulador, caso você prefira não executar em uma QPU.

# Syntax for first saving your token.  Delete these lines after saving your credentials.
QiskitRuntimeService.save_account(
    channel="ibm_quantum_platform",
    token="YOUR_TOKEN_HERE",
    overwrite=True,
    set_as_default=True,
)
service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_fez".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_fez")
print(backend.name)

ibm_pittsburgh

counts = run_circuit_and_get_counts(bell, backend, shots=1000)
plot_histogram(counts)

Execute em um simulador e visualize os resultados

Um simulador é uma versão de "mundo perfeito" da computação quântica. Aqui executamos o circuito em um simulador por 1000 shots e plotamos os resultados. Você deverá ver contagens aproximadamente iguais para os estados $00$ e $11$, sem ocorrências de $01$ ou $10$, o que é a assinatura da correlação perfeita do estado de Bell.

backend = AerSimulator()
counts = run_circuit_and_get_counts(bell, backend, shots=1000)

plot_histogram(counts)

Verifique seu entendimento

Quais são as duas portas que criam o estado de Bell aqui?

Resposta

Uma porta H no qubit 0, seguida de uma porta CX com o qubit 0 como controle e o qubit 1 como alvo.

Em um simulador ideal, quais duas bitstrings devem dominar o histograma?

Resposta

00 e 11 devem dominar.

Por que um simulador perfeito nem sempre teria exatamente o mesmo número de contagens 00 que de contagens 11?

Resposta

Mesmo que um simulador seja "perfeito" e leve a um estado de Bell perfeito, ele ainda está simulando um processo inerentemente aleatório, então flutuações estatísticas ainda ocorrerão. É como lançar uma moeda 1000 vezes: mesmo que haja exatamente 50-50 de chance da moeda cair em cara ou coroa, isso não significa que você sempre obterá exatamente 500 ocorrências de cara e 500 de coroa.

Por que um computador quântico real pode mostrar alguns resultados 01 ou 10, mesmo que o simulador não tenha mostrado?

Resposta

Porque dispositivos reais têm ruído. Portas e medições não são perfeitas, e isso pode introduzir erros ocasionais.

Qual é uma diferença prática entre simuladores e computadores quânticos reais além do ruído?

Resposta

Computadores quânticos podem envolver tempo de fila, disponibilidade limitada e restrições específicas do dispositivo que afetam como os circuitos são executados.

Conclusão

Começamos configurando o Qiskit em um ambiente Colab novo, que é exatamente como muitos fluxos de trabalho de notebook do mundo real começam. Em seguida, fizemos uma jornada pela computação quântica usando o Composer. Depois, construímos um circuito simples de dois qubits que produz o estado de Bell $\Phi^+$ e usamos amostragem repetida e visualizamos o emaranhamento como uma correlação no histograma de medição dos qubits. Também vimos como os computadores quânticos reais introduzem ruído e erros.

Objetivo de aprendizagem

Agora que percorremos como criar o estado de Bell $\Phi^+$, veja se você consegue editar o código para criar um dos outros três estados de Bell. Em particular, o estado $\Psi^-$ será usado em uma lição futura, então, se você descobrir como criá-lo, estará à frente do jogo.