autoq-qec 0.2.1__py3-none-any.whl

autoq_qec/__init__.py

@@ -0,0 +1,24 @@
+"""
+AutoQ QEC Estimator
+Multi-code fault-tolerant quantum error correction estimator.
+"""
+from .qec_estimator import (
+    CircuitProfile,
+    HardwareProfile,
+    CodeResult,
+    extract_circuit_profile,
+    estimate,
+    compare,
+)
+from .real_hardware import CalibratedHardware, HARDWARE_PROFILES
+from .recommender import rank, Recommendation
+from .algorithm_estimator import AlgorithmEstimator, AlgorithmEstimate
+
+__version__ = "0.2.1"
+__all__ = [
+    "CircuitProfile", "HardwareProfile", "CodeResult",
+    "CalibratedHardware", "HARDWARE_PROFILES",
+    "Recommendation",
+    "AlgorithmEstimator", "AlgorithmEstimate",
+    "extract_circuit_profile", "estimate", "compare", "rank",
+]

autoq_qec/algorithm_estimator.py

@@ -0,0 +1,101 @@
+"""
+AutoQ QEC — Algorithm Estimator
+Estimativas analíticas de T-count para algoritmos quânticos conhecidos.
+ATENÇÃO: estimativas de ordem de grandeza. Usar circuito real quando possível.
+"""
+import math
+from dataclasses import dataclass
+
+
+@dataclass
+class AlgorithmEstimate:
+    algorithm: str
+    n_logical_qubits: int
+    t_count_estimate: int
+    t_count_uncertainty: str   # "±5×" ou "±2×"
+    source: str
+    notes: str
+
+
+class AlgorithmEstimator:
+
+    @staticmethod
+    def shor(N: int) -> AlgorithmEstimate:
+        """
+        Shor factoring de N.
+        T-count ≈ 20n³ onde n = ⌈log₂N⌉.
+        Fonte: Beauregard (2003) + síntese de portas fault-tolerant.
+        Incerteza: ±5× dependendo da implementação de aritmética modular
+        (verificado contra Shor N=15 real: fórmula subestima ~4,7×).
+        """
+        if N <= 2:
+            raise ValueError(
+                f"Shor requer N > 2 (N={N} não tem fatoração não-trivial a estimar)"
+            )
+        n = math.ceil(math.log2(N))
+        t_count = 20 * n**3
+        return AlgorithmEstimate(
+            algorithm=f"Shor N={N}",
+            n_logical_qubits=2*n + 3,
+            t_count_estimate=t_count,
+            t_count_uncertainty="±5×",
+            source="Beauregard, QIC 3:175 (2003); Fowler gate synthesis",
+            notes=f"n={n} bits. Implementações simples podem ter até 5× mais T-gates.",
+        )
+
+    @staticmethod
+    def grover(N: int) -> AlgorithmEstimate:
+        """
+        Grover search em N itens.
+        T-count ≈ 7n por iteração × ⌈π/4·√N⌉ iterações, com n=⌈log₂N⌉.
+        Nota: como n cresce com log₂N, o T-count total escala com √N·log₂N,
+        não apenas √N — o fator log₂N vem do custo do oracle genérico por
+        iteração, não só do número de iterações.
+        Fonte: estimativa com oracle genérico.
+        """
+        if N <= 1:
+            raise ValueError(f"Grover requer N > 1 itens de busca (N={N})")
+        n = math.ceil(math.log2(N))
+        iterations = math.ceil(math.pi/4 * math.sqrt(N))
+        t_per_iter = 7 * n
+        t_count = t_per_iter * iterations
+        return AlgorithmEstimate(
+            algorithm=f"Grover N={N}",
+            n_logical_qubits=n + 1,
+            t_count_estimate=t_count,
+            t_count_uncertainty="±10×",
+            source="Estimativa com oracle genérico de n T-gates",
+            notes="Depende fortemente do oracle. Incerteza alta sem oracle específico.",
+        )
+
+    @staticmethod
+    def qft(n: int) -> AlgorithmEstimate:
+        """
+        QFT em n qubits.
+        T-count ≈ n²/2 (rotações CP com síntese Solovay-Kitaev).
+        """
+        t_count = n*n // 2
+        return AlgorithmEstimate(
+            algorithm=f"QFT n={n}",
+            n_logical_qubits=n,
+            t_count_estimate=t_count,
+            t_count_uncertainty="±2×",
+            source="Rotações CP decompostas em Clifford+T",
+            notes="CP(π/2^k) para k>2 requer síntese com T-gates.",
+        )
+
+    @staticmethod
+    def vqe(n_qubits: int, depth: int) -> AlgorithmEstimate:
+        """
+        VQE com n_qubits e profundidade depth.
+        T-count ≈ 4 · n · depth (Trotterizado).
+        """
+        t_count = 4 * n_qubits * depth
+        return AlgorithmEstimate(
+            algorithm=f"VQE n={n_qubits} d={depth}",
+            n_logical_qubits=n_qubits,
+            t_count_estimate=t_count,
+            t_count_uncertainty="±3×",
+            source="Hamiltoniano Trotterizado com RZZ gates",
+            notes="Depende do Hamiltoniano. Incerteza moderada.",
+        )

autoq_qec/qec_estimator.py

@@ -0,0 +1,338 @@
+"""
+AutoQ QEC Estimator — módulo de estimativa multi-código fault-tolerant
+Referências:
+  Surface Code:  Fowler et al., PRA 86, 032324 (2012)
+  Bacon-Shor:    Bacon, PRA 73, 012340 (2006); Aliferis & Cross (2007)
+  Steane [[7,1,3]]: Steane, PRL 77, 793 (1996)
+"""
+import math
+from dataclasses import dataclass
+from typing import Optional
+
+# ── Tipos ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class CircuitProfile:
+    """Métricas extraídas de um circuito Qiskit."""
+    n_logical_qubits: int
+    n_logical_gates: int       # portas lógicas (nível Qiskit)
+    n_physical_gates: int      # portas físicas após transpile CX+U
+    depth_physical: int        # profundidade na base física
+    t_count: int               # número de portas T (dominam custo FT)
+    cx_count: int
+
+@dataclass
+class HardwareProfile:
+    name: str
+    t_gate_ns: float           # tempo de porta em nanossegundos
+    p_phys: float              # taxa de erro físico por porta
+    topology: str              # "heavy-hex", "all-to-all", "linear", "grid"
+
+@dataclass
+class CodeResult:
+    code_name: str
+    distance: Optional[int]
+    qubits_per_logical: Optional[int]
+    total_physical_qubits: Optional[int]
+    gate_overhead_per_logical: Optional[float]
+    total_physical_gates: Optional[float]
+    execution_time_us: Optional[float]
+    p_logical_achieved: Optional[float]
+    fidelity_circuit: Optional[float]
+    feasible: bool
+    reason: str                # motivo de inviabilidade ou sumário
+
+# ── Modelos QEC ──────────────────────────────────────────────────────────────
+
+def _surface_code_model(p_phys: float, p_L_target: float,
+                        p_th: float = 0.01, A: float = 0.1):
+    """
+    Fowler et al. 2012: p_L ≈ A*(p/p_th)^((d+1)/2)
+    Retorna (d, qubits_per_logical, cycles_per_gate, p_L_achieved) ou raises
+    """
+    if p_phys >= p_th:
+        raise ValueError(f"p_phys={p_phys:.4f} ≥ threshold={p_th}: não converge")
+    # Resolver d mínimo
+    ratio = math.log(p_L_target / A) / math.log(p_phys / p_th)
+    d = max(3, math.ceil(2 * ratio - 1 + 1e-9))
+    # Safeguard contra erro de ponto flutuante na fronteira
+    p_L_check = A * (p_phys / p_th) ** ((d + 1) / 2)
+    if p_L_check > p_L_target * (1 + 1e-12):
+        d += 2  # próximo ímpar
+    if d % 2 == 0:
+        d += 1  # d deve ser ímpar no Surface Code rotacionado
+    p_L = A * (p_phys / p_th) ** ((d + 1) / 2)
+    q_per_logical = 2 * d**2 - 1
+    # Ciclos de síndrome por porta lógica fault-tolerant: d (conservative)
+    cycles_per_gate = d
+    return d, q_per_logical, cycles_per_gate, p_L
+
+
+def _bacon_shor_model(p_phys: float, p_L_target: float,
+                      p_th: float = 0.008):
+    """
+    Aliferis & Cross 2007: p_L ≈ (p/p_th)^d para [[d²,1,d]]
+    threshold ~0.7-1.1% dependendo do modelo; usamos 0.8% (conservador)
+    """
+    if p_phys >= p_th:
+        raise ValueError(f"p_phys={p_phys:.4f} ≥ threshold_BS={p_th}: não converge")
+    d = max(2, math.ceil(math.log(p_L_target) / math.log(p_phys / p_th)))
+    p_L = (p_phys / p_th) ** d
+    q_per_logical = d**2
+    cycles_per_gate = 2 * (d - 1)  # medições de gauge por ciclo
+    return d, q_per_logical, cycles_per_gate, p_L
+
+
+def _steane_model(p_phys: float, p_L_target: float,
+                  p_th: float = 0.007):
+    """
+    Steane [[7,1,3]]: código CSS fixo, d=3, p_L ≈ 21*p²
+    Só é viável se p < p_th E p_L_target > 21*p²
+    """
+    if p_phys >= p_th:
+        raise ValueError(f"p_phys={p_phys:.4f} ≥ threshold_Steane={p_th}")
+    p_L = 21 * p_phys**2
+    if p_L > p_L_target:
+        raise ValueError(
+            f"Steane d=3 insuficiente: p_L={p_L:.2e} > alvo={p_L_target:.2e}. "
+            f"Necessário concatenação ou código de distância maior."
+        )
+    return 3, 13, 6, p_L  # 7 data + 6 ancilla, 6 síndrome por ciclo
+
+
+def _floquet_code_model(p_phys: float, p_L_target: float,
+                        p_th: float = 0.01, A: float = 0.07):
+    """
+    Floquet Code planar (4.8.8) — Gidney & Fowler, arXiv:2202.11829
+    Vantagem vs Surface Code: overhead de tempo menor (d//2 vs d³ rodadas).
+    Custo: ~2× mais qubits por lógico (4d²+8(d-1) vs 2d²-1).
+    """
+    if p_phys >= p_th:
+        raise ValueError(f"p_phys={p_phys:.4f} ≥ threshold_Floquet={p_th}: não converge")
+    ratio = math.log(p_L_target / A) / math.log(p_phys / p_th)
+    d = max(3, math.ceil(2 * ratio - 1 + 1e-9))
+    if d % 2 == 0:
+        d += 1
+    p_L = A * (p_phys / p_th) ** ((d + 1) / 2)
+    if p_L > p_L_target * (1 + 1e-9):
+        d += 2
+        p_L = A * (p_phys / p_th) ** ((d + 1) / 2)
+    q_per_logical = 4 * d**2 + 8 * (d - 1)
+    gate_overhead = d // 2
+    return d, q_per_logical, gate_overhead, p_L
+
+# ── Extrator de perfil de circuito ───────────────────────────────────────────
+
+def _count_t_gates(circuit) -> int:
+    """
+    Conta T e T† gates após decomposição na base Clifford+T.
+    Portas Clifford (H, S, CX) têm custo zero em QEC fault-tolerant.
+    optimization_level=2 simplifica ângulos redundantes antes da contagem
+    (ex.: T·T·T otimiza para S·T — 1 T-gate real, não 3).
+    """
+    from qiskit import transpile
+    t_basis = transpile(
+        circuit,
+        basis_gates=['t', 'tdg', 's', 'sdg', 'h', 'x', 'y', 'z', 'cx'],
+        optimization_level=2,
+        seed_transpiler=42
+    )
+    ops = t_basis.count_ops()
+    return ops.get('t', 0) + ops.get('tdg', 0)
+
+
+def extract_circuit_profile(circuit) -> CircuitProfile:
+    """
+    Extrai métricas reais de um QuantumCircuit Qiskit.
+    Transpila para base {CX, U} para obter contagem física real.
+    """
+    from qiskit import transpile
+
+    # Perfil lógico
+    n_q = circuit.num_qubits
+    ops_logical = {k: v for k, v in circuit.count_ops().items()
+                   if k not in ('measure', 'barrier', 'reset')}
+    n_logical = sum(ops_logical.values())
+
+    # Perfil físico — transpile para base universal sem backend específico
+    phys = transpile(circuit, basis_gates=['cx', 'u'],
+                     optimization_level=3, seed_transpiler=42)
+    ops_phys = {k: v for k, v in phys.count_ops().items()
+                if k not in ('measure', 'barrier', 'reset')}
+    n_physical = sum(ops_phys.values())
+    depth_phys = phys.depth()
+
+    # T-gates: contagem exata via decomposição Clifford+T (ver _count_t_gates).
+    # Portas Clifford (H, S, CX) têm custo zero em QEC fault-tolerant.
+    t_count = _count_t_gates(circuit)
+    cx_count = ops_phys.get('cx', 0)
+
+    return CircuitProfile(
+        n_logical_qubits=n_q,
+        n_logical_gates=n_logical,
+        n_physical_gates=n_physical,
+        depth_physical=depth_phys,
+        t_count=t_count,
+        cx_count=cx_count,
+    )
+
+# ── Estimador principal ───────────────────────────────────────────────────────
+
+def estimate(circuit_profile: CircuitProfile,
+             hardware: HardwareProfile,
+             fidelity_target: float = 0.99) -> list[CodeResult]:
+    """
+    Para um dado CircuitProfile + HardwareProfile + alvo de fidelidade,
+    retorna lista de CodeResult para cada código QEC analisado.
+
+    p_L_per_gate = (1 - fidelity_target) / n_physical_gates
+    """
+    if not (0 < fidelity_target < 1):
+        raise ValueError("fidelity_target deve estar em (0, 1)")
+
+    N = circuit_profile.n_physical_gates
+    if N == 0:
+        raise ValueError("Circuito tem 0 portas físicas — foi destruído pelo transpile?")
+
+    p_L_target = (1 - fidelity_target) / N
+    t_ns = hardware.t_gate_ns
+    n_L = circuit_profile.n_logical_qubits
+    p = hardware.p_phys
+
+    results = []
+
+    # ── Surface Code ──────────────────────────────────────────────────────────
+    try:
+        d, q_per_L, cycles, p_L = _surface_code_model(p, p_L_target)
+        total_q = q_per_L * n_L
+        # cycles = d rodadas de síndrome por porta lógica (Fowler et al. PRA 86,
+        # 032324, Sec. IV). Cada rodada tem d² medições de estabilizador (CX por
+        # ciclo). Overhead total por porta lógica: d rodadas × d² medições = d³.
+        gate_overhead = cycles * d**2  # = d³
+        total_phys_gates = N * gate_overhead
+        time_us = total_phys_gates * t_ns / 1000
+        fid = (1 - p_L) ** N
+        results.append(CodeResult(
+            code_name="Surface Code",
+            distance=d,
+            qubits_per_logical=q_per_L,
+            total_physical_qubits=total_q,
+            gate_overhead_per_logical=gate_overhead,
+            total_physical_gates=total_phys_gates,
+            execution_time_us=time_us,
+            p_logical_achieved=p_L,
+            fidelity_circuit=fid,
+            feasible=True,
+            reason=f"d={d}, p_L={p_L:.2e}",
+        ))
+    except ValueError as e:
+        results.append(CodeResult(
+            code_name="Surface Code", distance=None, qubits_per_logical=None,
+            total_physical_qubits=None, gate_overhead_per_logical=None,
+            total_physical_gates=None, execution_time_us=None,
+            p_logical_achieved=None, fidelity_circuit=None,
+            feasible=False, reason=str(e),
+        ))
+
+    # ── Bacon-Shor ────────────────────────────────────────────────────────────
+    try:
+        d, q_per_L, cycles, p_L = _bacon_shor_model(p, p_L_target)
+        total_q = q_per_L * n_L
+        total_phys_gates = N * cycles
+        time_us = total_phys_gates * t_ns / 1000
+        fid = (1 - p_L) ** N
+        results.append(CodeResult(
+            code_name="Bacon-Shor",
+            distance=d,
+            qubits_per_logical=q_per_L,
+            total_physical_qubits=total_q,
+            gate_overhead_per_logical=cycles,
+            total_physical_gates=total_phys_gates,
+            execution_time_us=time_us,
+            p_logical_achieved=p_L,
+            fidelity_circuit=fid,
+            feasible=True,
+            reason=f"d={d}, [[{d**2},1,{d}]], p_L={p_L:.2e}",
+        ))
+    except ValueError as e:
+        results.append(CodeResult(
+            code_name="Bacon-Shor", distance=None, qubits_per_logical=None,
+            total_physical_qubits=None, gate_overhead_per_logical=None,
+            total_physical_gates=None, execution_time_us=None,
+            p_logical_achieved=None, fidelity_circuit=None,
+            feasible=False, reason=str(e),
+        ))
+
+    # ── Steane [[7,1,3]] ──────────────────────────────────────────────────────
+    try:
+        d, q_per_L, cycles, p_L = _steane_model(p, p_L_target)
+        total_q = q_per_L * n_L
+        total_phys_gates = N * cycles
+        time_us = total_phys_gates * t_ns / 1000
+        fid = (1 - p_L) ** N
+        results.append(CodeResult(
+            code_name="Steane [[7,1,3]]",
+            distance=3,
+            qubits_per_logical=q_per_L,
+            total_physical_qubits=total_q,
+            gate_overhead_per_logical=cycles,
+            total_physical_gates=total_phys_gates,
+            execution_time_us=time_us,
+            p_logical_achieved=p_L,
+            fidelity_circuit=fid,
+            feasible=True,
+            reason=f"d=3 fixo, p_L={p_L:.2e}",
+        ))
+    except ValueError as e:
+        results.append(CodeResult(
+            code_name="Steane [[7,1,3]]", distance=None, qubits_per_logical=None,
+            total_physical_qubits=None, gate_overhead_per_logical=None,
+            total_physical_gates=None, execution_time_us=None,
+            p_logical_achieved=None, fidelity_circuit=None,
+            feasible=False, reason=str(e),
+        ))
+
+    # ── Floquet Code ──────────────────────────────────────────────────────────
+    try:
+        d, q_per_L, cycles, p_L = _floquet_code_model(p, p_L_target)
+        total_q = q_per_L * n_L
+        total_phys_gates = N * cycles
+        time_us = total_phys_gates * t_ns / 1000
+        fid = (1 - p_L) ** N
+        results.append(CodeResult(
+            code_name="Floquet Code",
+            distance=d,
+            qubits_per_logical=q_per_L,
+            total_physical_qubits=total_q,
+            gate_overhead_per_logical=cycles,
+            total_physical_gates=total_phys_gates,
+            execution_time_us=time_us,
+            p_logical_achieved=p_L,
+            fidelity_circuit=fid,
+            feasible=True,
+            reason=f"d={d} (4.8.8 planar), p_L={p_L:.2e}",
+        ))
+    except ValueError as e:
+        results.append(CodeResult(
+            code_name="Floquet Code", distance=None, qubits_per_logical=None,
+            total_physical_qubits=None, gate_overhead_per_logical=None,
+            total_physical_gates=None, execution_time_us=None,
+            p_logical_achieved=None, fidelity_circuit=None,
+            feasible=False, reason=str(e),
+        ))
+
+    return results
+
+
+def compare(circuit, hardware_list: list[HardwareProfile],
+            fidelity_target: float = 0.99):
+    """
+    API principal: recebe circuito Qiskit + lista de hardwares,
+    devolve dicionário hardware_name → [CodeResult].
+    """
+    profile = extract_circuit_profile(circuit)
+    output = {"circuit_profile": profile, "results": {}, "hardware_profiles": {}}
+    for hw in hardware_list:
+        output["results"][hw.name] = estimate(profile, hw, fidelity_target)
+        output["hardware_profiles"][hw.name] = hw
+    return output

autoq_qec/real_hardware.py

@@ -0,0 +1,212 @@
+"""
+AutoQ Real Hardware Integration
+Três modos de operação:
+  1. IBM real   — puxa backend.properties() com token
+  2. IBM noise  — AerSimulator com noise model do backend real
+  3. Publicado  — dados de papers/specs para fabricantes sem API aberta
+"""
+import math
+from dataclasses import dataclass, field
+from typing import Optional
+
+@dataclass
+class CalibratedHardware:
+    """Perfil de hardware com dados reais de calibração."""
+    name: str
+    n_qubits: int
+    p_1q_mean: float        # erro médio porta 1q
+    p_2q_mean: float        # erro médio porta 2q (CX/CZ/ZZ)
+    p_2q_worst: float       # erro máximo — par de qubits mais ruidoso
+    t_1q_ns: float          # duração porta 1q em ns
+    t_2q_ns: float          # duração porta 2q em ns
+    T1_us: float            # tempo de relaxação médio
+    T2_us: float            # tempo de decoerência médio
+    readout_error: float    # erro de leitura médio
+    topology: str
+    source: str             # referência dos dados
+    # p_phys efetivo para QEC: geralmente dominado por 2q gates
+    @property
+    def p_phys(self) -> float:
+        return self.p_2q_mean
+
+    def t1_constraint(self, n_physical_gates: int, gate_overhead: float) -> dict:
+        """Verifica se o circuito QEC cabe dentro do T1."""
+        t_circuit_us = n_physical_gates * gate_overhead * self.t_2q_ns / 1000
+        t1_us = self.T1_us
+        ratio = t_circuit_us / t1_us
+        return {
+            "t_circuit_us": t_circuit_us,
+            "T1_us": t1_us,
+            "ratio": ratio,
+            "feasible": ratio < 0.5,  # conservador: <50% de T1
+            "warning": ratio > 0.1,
+        }
+
+
+# ── Dados publicados por fabricante ───────────────────────────────────────────
+
+HARDWARE_PROFILES = {
+
+    "IBM_Eagle_r3": CalibratedHardware(
+        name="IBM Eagle r3 (ibm_brisbane)",
+        n_qubits=127,
+        p_1q_mean=2.8e-4,
+        p_2q_mean=6.2e-3,
+        p_2q_worst=2.1e-2,
+        t_1q_ns=56.0,
+        t_2q_ns=391.0,
+        T1_us=198.4,
+        T2_us=143.2,
+        readout_error=0.0142,
+        topology="heavy-hex",
+        source="IBM Quantum Network calibration data, Eagle r3, 2024",
+    ),
+
+    "IBM_Heron_r2": CalibratedHardware(
+        name="IBM Heron r2 (ibm_torino)",
+        n_qubits=133,
+        p_1q_mean=1.9e-4,
+        p_2q_mean=3.0e-3,   # CZ gate no Heron
+        p_2q_worst=8.5e-3,
+        t_1q_ns=56.0,
+        t_2q_ns=100.0,       # CZ mais rápido que CNOT no Eagle
+        T1_us=242.0,
+        T2_us=186.0,
+        readout_error=0.0089,
+        topology="heavy-hex",
+        source="IBM Quantum: Heron r2 specs 2024; arXiv:2404.07471",
+    ),
+
+    "Quantinuum_H2": CalibratedHardware(
+        name="Quantinuum H2-1",
+        n_qubits=56,
+        p_1q_mean=3.8e-5,
+        p_2q_mean=2.9e-4,    # ZZ gate
+        p_2q_worst=5.0e-4,
+        t_1q_ns=10e3,        # 10 µs
+        t_2q_ns=100e3,       # 100 µs (íon aprisionado)
+        T1_us=1e7,           # horas — sem limite prático de T1
+        T2_us=1e5,           # ~0.1 s
+        readout_error=0.0015,
+        topology="all-to-all",
+        source="Quantinuum H-Series specs; PRX Quantum 4, 020312 (2023)",
+    ),
+
+    "IonQ_Aria": CalibratedHardware(
+        name="IonQ Aria-1",
+        n_qubits=25,
+        p_1q_mean=4.0e-4,
+        p_2q_mean=5.5e-3,    # MS gate (Mølmer-Sørensen)
+        p_2q_worst=8.0e-3,
+        t_1q_ns=135e3,       # 135 µs
+        t_2q_ns=600e3,       # 600 µs
+        T1_us=1e7,           # >10 s
+        T2_us=1e5,           # ~0.1 s
+        readout_error=0.005,
+        topology="all-to-all",
+        source="IonQ Aria specs; arXiv:2307.01765 (2023)",
+    ),
+
+    "Google_Sycamore": CalibratedHardware(
+        name="Google Sycamore (53q)",
+        n_qubits=53,
+        p_1q_mean=1.6e-3,
+        p_2q_mean=6.2e-3,    # fSim gate
+        p_2q_worst=1.1e-2,
+        t_1q_ns=25.0,
+        t_2q_ns=12.0,        # fSim muito rápido
+        T1_us=15.0,
+        T2_us=20.0,
+        readout_error=0.037,
+        topology="grid-2d",
+        source="Arute et al., Nature 574, 505 (2019)",
+    ),
+}
+
+# ── Integração IBM real (requer token) ────────────────────────────────────────
+
+def from_ibm_backend(backend_name: str, token: str) -> CalibratedHardware:
+    """
+    Puxa calibração real do IBM Quantum via qiskit-ibm-runtime.
+    Requer: pip install qiskit-ibm-runtime
+    Token gratuito em: https://quantum.ibm.com
+    """
+    try:
+        from qiskit_ibm_runtime import QiskitRuntimeService
+    except ImportError:
+        raise ImportError("pip install qiskit-ibm-runtime")
+
+    service = QiskitRuntimeService(channel='ibm_quantum', token=token)
+    backend = service.backend(backend_name)
+    props = backend.properties()
+    config = backend.configuration()
+
+    # Agregar erros por tipo de porta
+    cx_errors, cx_durations = [], []
+    sx_errors, sx_durations = [], []
+
+    for gate in props.gates:
+        if gate.gate == 'cx':
+            for param in gate.parameters:
+                if param.name == 'gate_error': cx_errors.append(param.value)
+                if param.name == 'gate_length': cx_durations.append(param.value * 1e9)
+        if gate.gate in ('sx', 'x'):
+            for param in gate.parameters:
+                if param.name == 'gate_error': sx_errors.append(param.value)
+                if param.name == 'gate_length': sx_durations.append(param.value * 1e9)
+
+    T1_vals = [props.t1(q) * 1e6 for q in range(config.n_qubits) if props.t1(q)]
+    T2_vals = [props.t2(q) * 1e6 for q in range(config.n_qubits) if props.t2(q)]
+    ro_errs = [props.readout_error(q) for q in range(config.n_qubits)]
+
+    return CalibratedHardware(
+        name=f"IBM {backend_name} (calibração ao vivo)",
+        n_qubits=config.n_qubits,
+        p_1q_mean=sum(sx_errors)/len(sx_errors) if sx_errors else 3e-4,
+        p_2q_mean=sum(cx_errors)/len(cx_errors) if cx_errors else 6e-3,
+        p_2q_worst=max(cx_errors) if cx_errors else 2e-2,
+        t_1q_ns=sum(sx_durations)/len(sx_durations) if sx_durations else 56,
+        t_2q_ns=sum(cx_durations)/len(cx_durations) if cx_durations else 400,
+        T1_us=sum(T1_vals)/len(T1_vals) if T1_vals else 200,
+        T2_us=sum(T2_vals)/len(T2_vals) if T2_vals else 150,
+        readout_error=sum(ro_errs)/len(ro_errs) if ro_errs else 0.015,
+        topology="heavy-hex",
+        source=f"IBM Quantum live calibration — {backend_name}",
+    )
+
+
+def noise_model_from_ibm(backend_name: str, token: str):
+    """
+    Constrói AerSimulator com noise model real do backend IBM.
+    Permite simular localmente com ruído realista sem usar shots pagos.
+    Requer: pip install qiskit-ibm-runtime qiskit-aer
+    """
+    try:
+        from qiskit_ibm_runtime import QiskitRuntimeService
+        from qiskit_aer.noise import NoiseModel
+        from qiskit_aer import AerSimulator
+    except ImportError:
+        raise ImportError("pip install qiskit-ibm-runtime qiskit-aer")
+
+    service = QiskitRuntimeService(channel='ibm_quantum', token=token)
+    backend = service.backend(backend_name)
+    noise_model = NoiseModel.from_backend(backend)
+    sim = AerSimulator(noise_model=noise_model,
+                       coupling_map=backend.configuration().coupling_map,
+                       basis_gates=noise_model.basis_gates)
+    return sim
+
+
+# ── Análise de viabilidade T1 ────────────────────────────────────────────────
+
+def t1_feasibility_report(hw: CalibratedHardware,
+                           n_physical_gates: int,
+                           gate_overhead: float) -> None:
+    """Imprime relatório de viabilidade baseado em T1/T2."""
+    check = hw.t1_constraint(n_physical_gates, gate_overhead)
+    status = "✓ VIÁVEL" if check["feasible"] else "✗ INVIÁVEL (excede T1)"
+    warn   = "⚠ ATENÇÃO" if check["warning"] and check["feasible"] else ""
+    print(f"  T1 check [{hw.name}]: {status} {warn}")
+    print(f"    t_circuit = {check['t_circuit_us']:.1f} µs")
+    print(f"    T1 médio  = {check['T1_us']:.1f} µs")
+    print(f"    ratio     = {check['ratio']:.3f} ({check['ratio']*100:.1f}% de T1)")

autoq_qec/recommender.py

@@ -0,0 +1,169 @@
+"""
+AutoQ Recommender — rankeamento automático de código+hardware
+para um dado circuito e alvo de fidelidade.
+"""
+import math
+from dataclasses import dataclass
+from typing import Optional
+from .qec_estimator import CodeResult, CircuitProfile
+
+@dataclass
+class Recommendation:
+    rank: int
+    hardware: str
+    code: str
+    total_physical_qubits: int
+    execution_time_us: float
+    fidelity_circuit: float
+    score: float          # menor = melhor (normalizado)
+    bottleneck: str       # o que domina o custo
+
+def _find_calibration(hw_name: str, hw_t_gate_ns: float, hw_p_phys: float,
+                       calibrations: dict):
+    """
+    Localiza a CalibratedHardware correspondente a um HardwareProfile.
+    HardwareProfile.name é escolhido livremente pelo usuário e não tem
+    relação garantida com as chaves de `calibrations` (ex.: HARDWARE_PROFILES
+    usa "IBM_Eagle_r3", mas um usuário pode nomear seu HardwareProfile
+    "IBM_Eagle"). Por isso, primeiro tenta casar por nome; se falhar, casa
+    pelas características numéricas (t_gate_ns e p_phys), que é como
+    HardwareProfile costuma ser derivado de uma CalibratedHardware na prática.
+    """
+    if hw_name in calibrations:
+        return calibrations[hw_name]
+    for cal in calibrations.values():
+        if (math.isclose(cal.t_2q_ns, hw_t_gate_ns, rel_tol=1e-6)
+                and math.isclose(cal.p_phys, hw_p_phys, rel_tol=1e-6)):
+            return cal
+    return None
+
+
+def rank(compare_result: dict,
+         hardware_calibrations: dict = None,
+         weight_qubits: float = 0.5,
+         weight_time: float = 0.3,
+         weight_fidelity: float = 0.2) -> list[Recommendation]:
+    """
+    Rankeia combinações hardware+código por score ponderado.
+    Apenas combinações viáveis entram no ranking.
+    Weights: soma deve ser 1.0 (normaliza internamente se não for).
+
+    Se `hardware_calibrations` for fornecido (dict nome→CalibratedHardware,
+    ex. HARDWARE_PROFILES), combinações que violem o limite de T1
+    (t_circuit >= 0.5×T1) são excluídas do ranking.
+    """
+    if abs(weight_qubits + weight_time + weight_fidelity - 1.0) > 1e-9:
+        total = weight_qubits + weight_time + weight_fidelity
+        weight_qubits  /= total
+        weight_time    /= total
+        weight_fidelity /= total
+
+    prof: CircuitProfile = compare_result["circuit_profile"]
+    hardware_profiles: dict = compare_result.get("hardware_profiles", {})
+    candidatos = []
+
+    for hw_name, code_results in compare_result["results"].items():
+        cal = None
+        if hardware_calibrations:
+            hw = hardware_profiles.get(hw_name)
+            if hw is not None:
+                cal = _find_calibration(
+                    hw_name, hw.t_gate_ns, hw.p_phys, hardware_calibrations
+                )
+
+        for r in code_results:
+            if not r.feasible:
+                continue
+
+            if cal is not None and r.gate_overhead_per_logical:
+                check = cal.t1_constraint(
+                    n_physical_gates=prof.n_physical_gates,
+                    gate_overhead=r.gate_overhead_per_logical,
+                )
+                if not check["feasible"]:
+                    continue
+
+            candidatos.append((hw_name, r))
+
+    if not candidatos:
+        return []
+
+    # Normalizar métricas para [0,1]
+    qubits_vals = [r.total_physical_qubits for _, r in candidatos]
+    time_vals   = [r.execution_time_us      for _, r in candidatos]
+    fid_vals    = [r.fidelity_circuit        for _, r in candidatos]
+
+    q_min, q_max = min(qubits_vals), max(qubits_vals)
+    t_min, t_max = min(time_vals),   max(time_vals)
+    f_min, f_max = min(fid_vals),    max(fid_vals)
+
+    def norm(v, lo, hi):
+        return 0.0 if hi == lo else (v - lo) / (hi - lo)
+
+    recommendations = []
+    for hw_name, r in candidatos:
+        q_norm = norm(r.total_physical_qubits, q_min, q_max)
+        t_norm = norm(r.execution_time_us, t_min, t_max)
+        f_norm = 1 - norm(r.fidelity_circuit, f_min, f_max)  # inverso: maior fid = menor custo
+
+        score = (weight_qubits * q_norm
+                 + weight_time * t_norm
+                 + weight_fidelity * f_norm)
+
+        # Bottleneck: qual fator domina?
+        contributions = {
+            "qubits":    weight_qubits * q_norm,
+            "tempo":     weight_time * t_norm,
+            "fidelidade":weight_fidelity * f_norm,
+        }
+        bottleneck = max(contributions, key=contributions.get)
+        bottleneck_pct = contributions[bottleneck] / score * 100 if score > 0 else 0
+
+        recommendations.append(Recommendation(
+            rank=0,  # preenchido abaixo
+            hardware=hw_name,
+            code=r.code_name,
+            total_physical_qubits=r.total_physical_qubits,
+            execution_time_us=r.execution_time_us,
+            fidelity_circuit=r.fidelity_circuit,
+            score=score,
+            bottleneck=f"{bottleneck} ({bottleneck_pct:.0f}% do score)",
+        ))
+
+    recommendations.sort(key=lambda x: x.score)
+    for i, rec in enumerate(recommendations):
+        rec.rank = i + 1
+
+    return recommendations
+
+
+def print_report(compare_result: dict, recommendations: list[Recommendation]):
+    """Imprime relatório completo."""
+    prof = compare_result["circuit_profile"]
+    print(f"\n{'═'*72}")
+    print(f"  RELATÓRIO AutoQ QEC Estimator")
+    print(f"{'═'*72}")
+    print(f"  Circuito: {prof.n_logical_qubits} qubits lógicos | "
+          f"{prof.n_physical_gates} portas físicas (CX+U) | "
+          f"profundidade {prof.depth_physical}")
+    print(f"  CX: {prof.cx_count}  U: {prof.t_count}")
+
+    print(f"\n  {'#':>3} {'Hardware':<20} {'Código':<22} "
+          f"{'Qubits':>8} {'Tempo(µs)':>12} {'Fidelidade':>11} "
+          f"{'Score':>7}  Gargalo")
+    print(f"  {'─'*100}")
+
+    for r in recommendations:
+        marker = " ◀ MELHOR" if r.rank == 1 else ""
+        print(f"  {r.rank:>3} {r.hardware:<20} {r.code:<22} "
+              f"{r.total_physical_qubits:>8} {r.execution_time_us:>12.2f} "
+              f"{r.fidelity_circuit:>11.4f} {r.score:>7.4f}  "
+              f"{r.bottleneck}{marker}")
+
+    if recommendations:
+        best = recommendations[0]
+        print(f"\n  RECOMENDAÇÃO: {best.hardware} + {best.code}")
+        print(f"  → {best.total_physical_qubits} qubits físicos | "
+              f"{best.execution_time_us:.2f} µs | "
+              f"fidelidade {best.fidelity_circuit:.4f}")
+        print(f"  → Gargalo principal: {best.bottleneck}")

autoq_qec-0.2.1.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: autoq-qec
+Version: 0.2.1
+Summary: Multi-code QEC resource estimator for arbitrary Qiskit circuits
+Author-email: Ronaldo Rodrigues <Ronaldoengenhariadacomputacao@hotmail.com>
+License: MIT
+Project-URL: Repository, https://github.com/Ronaldoengenhariadacomputacao/autoq-qec
+Project-URL: Issues, https://github.com/Ronaldoengenhariadacomputacao/autoq-qec/issues
+Project-URL: ORCID, https://orcid.org/0009-0006-7449-1190
+Keywords: quantum,qec,surface-code,fault-tolerant,qiskit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: qiskit>=1.0.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: ibm
+Requires-Dist: qiskit-ibm-runtime>=0.20; extra == "ibm"
+Provides-Extra: sim
+Requires-Dist: qiskit-aer>=0.14; extra == "sim"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# AutoQ QEC Estimator
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21327566.svg)](https://doi.org/10.5281/zenodo.21327566)
+
+**Multi-code fault-tolerant quantum error correction estimator for arbitrary Qiskit circuits.**
+
+Given any Qiskit circuit and a set of hardware profiles, AutoQ QEC returns a ranked comparison of QEC codes (Surface Code, Floquet Code, Bacon-Shor, Steane [[7,1,3]]) with physically grounded resource estimates: physical qubit count, execution time, and circuit fidelity.
+
+## What this does that nothing else does
+
+| Tool | Multi-code | Arbitrary circuit | Analytic model | Hardware-agnostic |
+|---|---|---|---|---|
+| Azure Resource Estimator | ❌ Surface Code only | ✅ | ✅ | ❌ Azure only |
+| stim | ✅ | ❌ needs rewrite | ❌ simulation | ❌ |
+| qiskit-qec | ✅ | ❌ no estimator | ❌ | ✅ |
+| **AutoQ QEC** | ✅ | ✅ | ✅ | ✅ |
+
+## Install
+
+```bash
+pip install autoq-qec
+# With IBM Quantum integration:
+pip install "autoq-qec[ibm,sim]"
+```
+
+## Quickstart
+
+```python
+from qiskit import QuantumCircuit
+from autoq_qec import compare, rank
+from autoq_qec import HARDWARE_PROFILES, CalibratedHardware, HardwareProfile
+
+# Any Qiskit circuit
+circuit = QuantumCircuit(4)
+circuit.h(0); circuit.cx(0,1); circuit.cx(1,2); circuit.cx(2,3)
+
+# Hardware profiles (built-in or custom)
+hardwares = [
+    HardwareProfile("IBM_Eagle",     t_gate_ns=391,   p_phys=0.0062, topology="heavy-hex"),
+    HardwareProfile("IBM_Heron",     t_gate_ns=100,   p_phys=0.003,  topology="heavy-hex"),
+    HardwareProfile("Quantinuum_H2", t_gate_ns=100e3, p_phys=0.00029,topology="all-to-all"),
+]
+
+# One call — returns all codes × all hardwares
+result = compare(circuit, hardwares, fidelity_target=0.99)
+
+# Pass hardware_calibrations to exclude combinations that violate T1
+# (t_circuit >= 0.5×T1) — matches by name or by (t_gate_ns, p_phys)
+recommendations = rank(result, hardware_calibrations=HARDWARE_PROFILES)
+
+for r in recommendations[:3]:
+    print(f"#{r.rank} {r.hardware} + {r.code}: "
+          f"{r.total_physical_qubits}q, {r.execution_time_us:.1f}µs, "
+          f"fidelity={r.fidelity_circuit:.4f}")
+```
+
+## With real IBM calibration data
+
+```python
+from autoq_qec.real_hardware import from_ibm_backend, noise_model_from_ibm
+
+# Pulls today's calibration — T1, T2, CX error per qubit pair
+hw = from_ibm_backend("ibm_brisbane", token="YOUR_IBM_TOKEN")
+
+# Simulate locally with real noise model (no queue, no cost)
+sim = noise_model_from_ibm("ibm_brisbane", token="YOUR_IBM_TOKEN")
+```
+
+## Physical models
+
+| Code | Model | Reference |
+|---|---|---|
+| Surface Code | $p_L \approx A(p/p_{th})^{(d+1)/2}$, $q=2d^2-1$, overhead $=d^3$ | Fowler et al., PRA 86, 032324 (2012) |
+| Floquet Code | $p_L \approx 0.07(p/p_{th})^{(d+1)/2}$, $q=4d^2+8(d-1)$, overhead $=\lfloor d/2\rfloor$ | Gidney & Fowler, arXiv:2202.11829 |
+| Bacon-Shor | $p_L \approx (p/p_{th})^d$, $q=d^2$ | Aliferis & Cross (2007) |
+| Steane [[7,1,3]] | $p_L \approx 21p^2$, $q=13$ | Steane, PRL 77, 793 (1996) |
+
+Thresholds are enforced: `p ≥ p_th` raises `ValueError` — no silent wrong results.
+
+## Algorithm Estimator
+
+Order-of-magnitude T-count estimates for known algorithms, without building the full circuit:
+
+```python
+from autoq_qec import AlgorithmEstimator
+
+est = AlgorithmEstimator.shor(2048)
+print(est.t_count_estimate, est.t_count_uncertainty)  # ±5x — build the real circuit for precise numbers
+```
+
+Covers `shor`, `grover`, `qft`, `vqe`. These are rough estimates (±2×–±10× depending on the algorithm) — use `extract_circuit_profile()` on a real circuit whenever possible.
+
+## Test
+
+```bash
+pytest tests/ -v   # 49 tests, all verify physics not arithmetic
+```
+
+## What the tests check (unlike most QEC tools)
+
+- `p ≥ threshold` raises `ValueError`, not wrong overhead
+- `d` is always odd for Surface Code (rotated lattice requirement)
+- `p_L ≤ p_L_target` guaranteed after distance selection
+- Noisier hardware requires larger `d` (monotonicity)
+- Circuit with 0 gates raises `ValueError` (destroyed by transpiler)
+- Fidelity scales correctly with `t_gate`
+
+## Author
+
+Ronaldo Rodrigues — ORCID: [0009-0006-7449-1190](https://orcid.org/0009-0006-7449-1190)

autoq_qec-0.2.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+autoq_qec/__init__.py,sha256=hTvcez1cI0hSakkhGFh0knh0EZ0F0ZuwOrXVSBNgn5Y,686
+autoq_qec/algorithm_estimator.py,sha256=0wwZLhzkwKotL_iQ9fuzlI5fuB4ND5MMhA8Mt-elS8w,3640
+autoq_qec/qec_estimator.py,sha256=YhH_FqKWQt124N0vD7-Ng5wi5XLVW_GciFDTZkVbX30,14120
+autoq_qec/real_hardware.py,sha256=Erim0NKVB3YCIcoMiu5cQUPDaMoHvrlOMtUctUb5iwU,8334
+autoq_qec/recommender.py,sha256=iX_2mzfPDF82hng_EzXkrsvbliwDKK_Q-FeGNjK5ac4,6508
+autoq_qec-0.2.1.dist-info/licenses/LICENSE,sha256=07NCoHQyczcX_ddSsm3KlW3F-iH9z0w8PK3MlGQOGPc,1074
+autoq_qec-0.2.1.dist-info/METADATA,sha256=lZrYf7rmsVIlIQzN6Sktic6Sq1qAKhY7Xi9R7CXaprM,5595
+autoq_qec-0.2.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+autoq_qec-0.2.1.dist-info/top_level.txt,sha256=ccgvJNSGIXy4sas82h-YqoqnIZyZxb7R1F78_zVXF6k,10
+autoq_qec-0.2.1.dist-info/RECORD,,

autoq_qec-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

autoq_qec-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ronaldo Rodrigues
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

autoq_qec-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+autoq_qec