Hello World: seu primeiro circuito quântico

Construa um estado de Bell (dois qubits emaranhados) e execute-o de três maneiras:

1. Simulação ideal — resultados perfeitos, não precisa de conta

2. Simulação com ruído — simula um dispositivo real, não precisa de conta

3. Hardware quântico real — requer uma conta IBM Quantum gratuita (passos de configuração abaixo)

Construa o circuito

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

qc.draw(output="mpl")

Opção 1: Simulação ideal (não precisa de conta)

Usa StatevectorSampler — um simulador local com resultados perfeitos, sem ruído.

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

from qiskit.visualization import plot_histogram
plot_histogram(counts)

Opção 2: Simulação com ruído (não precisa de conta)

Usa FakeManilaV2 — um simulador local que imita um dispositivo quântico IBM real, incluindo suas características de ruído. O circuito deve primeiro ser transpilado (adaptado) para o conjunto de portas e conectividade de qubits do dispositivo.

from qiskit.primitives import BackendSamplerV2
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

backend = FakeManilaV2()
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = BackendSamplerV2(backend=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

Opção 3: Hardware quântico real

Requer uma conta IBM Quantum gratuita. Para criar uma:

1. Registre-se em quantum.cloud.ibm.com/registration — não é necessário cartão de crédito nos primeiros 30 dias

2. Faça login em quantum.cloud.ibm.com e selecione a região us-east (obrigatório para o plano Open gratuito)

3. Crie uma instância (plano Open gratuito) em Instances se ainda não tiver uma

4. Crie uma chave de API em quantum.cloud.ibm.com (ou em cloud.ibm.com/iam/apikeys)

5. Copie seu CRN (Cloud Resource Name) da sua página de Instances

Em seguida, se você ainda não salvou suas credenciais aqui, execute a célula abaixo. Substitua <your-api-key> pela chave de API do passo 4 e <your-crn> pelo CRN do passo 5. Até que você faça isso, a célula não salva nada, então executar todas as células nunca poderá sobrescrever uma conta que você salvou antes.

from qiskit_ibm_runtime import QiskitRuntimeService

token = "<your-api-key>"
instance = "<your-crn>"

if token.startswith("<") or instance.startswith("<"):
    print("Paste your API key and CRN above first; nothing was saved.")
else:
    QiskitRuntimeService.save_account(
        channel="ibm_quantum_platform",
        token=token,
        instance=instance,
        set_as_default=True,
        overwrite=True,
    )
    print("Account saved.")

Observação: Jobs em hardware real podem levar algum tempo dependendo do tempo de fila. Se a célula ainda estiver em execução, você pode verificar o status do seu job e ver os resultados em quantum.cloud.ibm.com/workloads.

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(f"Running on {backend.name}")

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = SamplerV2(mode=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

O que vem a seguir?

• Tutorials — guias passo a passo sobre algoritmos, mitigação de erros, transpilação e muito mais

• Guides — material de referência sobre execução de circuitos, primitivas e o Qiskit Runtime

• Courses — trilhas de aprendizado estruturadas, dos fundamentos da computação quântica à computação em escala de utilidade

• Modules — módulos conceituais aprofundados em ciência da computação e mecânica quântica