Qiskit

Visão Geral

Qiskit é o framework de computação quântica de código aberto mais popular do mundo com 13M+ downloads. Construa circuitos quânticos, otimize para hardware, execute em simuladores ou em computadores quânticos reais, e analise resultados. Suporta IBM Quantum (sistemas com 100+ qubits), IonQ, Amazon Braket e outros provedores.

Principais Características:

• Transpilar 83x mais rápido que concorrentes
• 29% menos portas de dois qubits em circuitos otimizados
• Execução agnóstica de backend (simuladores locais ou hardware em nuvem)
• Bibliotecas abrangentes de algoritmos para otimização, química e ML

Início Rápido

Instalação

uv pip install qiskit
uv pip install "qiskit[visualization]" matplotlib

Primeiro Circuito

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

# Cria estado Bell (qubits emaranhados)
qc = QuantumCircuit(2)
qc.h(0)           # Hadamard no qubit 0
qc.cx(0, 1)       # CNOT do qubit 0 para 1
qc.measure_all()  # Mede ambos os qubits

# Executa localmente
sampler = StatevectorSampler()
result = sampler.run([qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
print(counts)  # {'00': ~512, '11': ~512}

Visualização

from qiskit.visualization import plot_histogram

qc.draw('mpl')           # Diagrama do circuito
plot_histogram(counts)   # Histograma de resultados

Capacidades Principais

1. Configuração e Instalação

Para instalação detalhada, autenticação e configuração da conta IBM Quantum:

• Veja references/setup.md

Tópicos cobertos:

• Instalação com uv
• Configuração de ambiente Python
• Configuração de conta IBM Quantum e token de API
• Execução local vs. em nuvem

2. Construção de Circuitos Quânticos

Para construir circuitos quânticos com portas, medições e composição:

• Veja references/circuits.md

Tópicos cobertos:

• Criação de circuitos com QuantumCircuit
• Portas de um qubit (H, X, Y, Z, rotações, portas de fase)
• Portas de múltiplos qubits (CNOT, SWAP, Toffoli)
• Medições e barreiras
• Composição de circuitos e propriedades
• Circuitos parametrizados para algoritmos variacionais

3. Primitives (Sampler e Estimator)

Para executar circuitos quânticos e computar resultados:

• Veja references/primitives.md

Tópicos cobertos:

• Sampler: Obtenha medições de bitstring e distribuições de probabilidade
• Estimator: Calcule valores esperados de observáveis
• Interface V2 (StatevectorSampler, StatevectorEstimator)
• Primitives do IBM Quantum Runtime para hardware
• Modos de Sessions e Batch
• Binding de parâmetros

4. Transpiração e Otimização

Para otimizar circuitos e preparar para execução em hardware:

• Veja references/transpilation.md

Tópicos cobertos:

• Por que a transpiração é necessária
• Níveis de otimização (0-3)
• Seis estágios de transpiração (init, layout, routing, translation, optimization, scheduling)
• Recursos avançados (virtual permutation elision, cancelamento de portas)
• Parâmetros comuns (initial_layout, approximation_degree, seed)
• Melhores práticas para circuitos eficientes

5. Visualização

Para exibir circuitos, resultados e estados quânticos:

• Veja references/visualization.md

Tópicos cobertos:

• Desenhos de circuitos (texto, matplotlib, LaTeX)
• Histogramas de resultados
• Visualização de estado quântico (esfera de Bloch, state city, QSphere)
• Topologia de backend e mapas de erro
• Customização e estilo
• Salvando figuras em qualidade de publicação

6. Backends de Hardware

Para executar em simuladores e computadores quânticos reais:

• Veja references/backends.md

Tópicos cobertos:

• Backends IBM Quantum e autenticação
• Propriedades e status de backends
• Execução em hardware real com primitives de Runtime
• Gerenciamento de trabalhos e fila
• Modo Session (algoritmos iterativos)
• Modo Batch (trabalhos paralelos)
• Simuladores locais (StatevectorSampler, Aer)
• Provedores de terceiros (IonQ, Amazon Braket)
• Estratégias de mitigação de erro

7. Workflow Qiskit Patterns

Para implementar o workflow de computação quântica em quatro etapas:

• Veja references/patterns.md

Tópicos cobertos:

• Map: Traduza problemas para circuitos quânticos
• Optimize: Transpilar para hardware
• Execute: Execute com primitives
• Post-process: Extraia e analise resultados
• Exemplo VQE completo
• Execução Session vs. Batch
• Padrões de workflow comuns

8. Algoritmos e Aplicações Quânticas

Para implementar algoritmos quânticos específicos:

• Veja references/algorithms.md

Tópicos cobertos:

• Otimização: VQE, QAOA, algoritmo de Grover
• Química: Estados fundamentais moleculares, estados excitados, Hamiltonianos
• Aprendizado de Máquina: Kernels quânticos, VQC, QNN
• Bibliotecas de algoritmos: Qiskit Nature, Qiskit ML, Qiskit Optimization
• Simulações de física e benchmarking

Guia de Decisão de Workflow

Se você precisa:

• Instalar Qiskit ou configurar conta IBM Quantum → references/setup.md
• Construir um novo circuito quântico → references/circuits.md
• Entender portas e operações de circuitos → references/circuits.md
• Executar circuitos e obter medições → references/primitives.md
• Calcular valores esperados → references/primitives.md
• Otimizar circuitos para hardware → references/transpilation.md
• Visualizar circuitos ou resultados → references/visualization.md
• Executar em hardware IBM Quantum → references/backends.md
• Conectar a provedores de terceiros → references/backends.md
• Implementar workflow quântico ponta a ponta → references/patterns.md
• Construir algoritmo específico (VQE, QAOA, etc.) → references/algorithms.md
• Resolver problemas de química ou otimização → references/algorithms.md

Melhores Práticas

Workflow de Desenvolvimento

1. Comece com simuladores: Teste localmente antes de usar hardware

   from qiskit.primitives import StatevectorSampler
   sampler = StatevectorSampler()
   

2. Sempre transpilar: Otimize circuitos antes da execução

   from qiskit import transpile
   qc_optimized = transpile(qc, backend=backend, optimization_level=3)
   

3. Use primitives apropriados:

   • Sampler para bitstrings (algoritmos de otimização)
   • Estimator para valores esperados (química, física)

4. Escolha modo de execução:

   • Session: Algoritmos iterativos (VQE, QAOA)
   • Batch: Trabalhos paralelos independentes
   • Trabalho único: Experimentos isolados

Otimização de Desempenho

• Use optimization_level=3 para produção
• Minimize portas de dois qubits (fonte principal de erro)
• Teste com simuladores com ruído antes do hardware
• Salve e reutilize circuitos transpilados
• Monitore convergência em algoritmos variacionais

Execução em Hardware

• Verifique status do backend antes de enviar
• Use least_busy() para testes
• Salve IDs de trabalhos para recuperação posterior
• Aplique mitigação de erro (resilience_level)
• Comece com menos shots, aumente para execuções finais

Padrões Comuns

Padrão 1: Execução Simples de Circuito

from qiskit import QuantumCircuit, transpile
from qiskit.primitives import StatevectorSampler

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

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

Padrão 2: Execução em Hardware com Transpiração

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit import transpile

service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")

qc_optimized = transpile(qc, backend=backend, optimization_level=3)

sampler = Sampler(backend)
job = sampler.run([qc_optimized], shots=1024)
result = job.result()

Padrão 3: Algoritmo Variacional (VQE)

from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator
from scipy.optimize import minimize

with Session(backend=backend) as session:
    estimator = Estimator(session=session)

    def cost_function(params):
        bound_qc = ansatz.assign_parameters(params)
        qc_isa = transpile(bound_qc, backend=backend)
        result = estimator.run([(qc_isa, hamiltonian)]).result()
        return result[0].data.evs

    result = minimize(cost_function, initial_params, method='COBYLA')

Recursos Adicionais

• Documentação Oficial: https://quantum.ibm.com/docs
• Qiskit Textbook: https://qiskit.org/learn
• Referência de API: https://docs.quantum.ibm.com/api/qiskit
• Guia de Patterns: https://quantum.cloud.ibm.com/docs/en/guides/intro-to-patterns