from fakenovera.qiskit import FakeNovera
from qiskit import QuantumCircuit

# Create backend with realistic Novera noise
backend = FakeNovera(seed=42)

# Build and run a circuit
qc = QuantumCircuit(9)
qc.h(4)                    # Hadamard on center qubit
qc.cz(4, 1); qc.cz(4, 3)  # CZ on lattice edges
qc.cz(4, 5); qc.cz(4, 7)
qc.measure_all()

job = backend.run(qc, shots=2000)
counts = job.result().get_counts()

from fakecepheus.qiskit import FakeCepheus

backend = FakeCepheus(seed=42)

# Intra-chip gates: F_2Q = 99.5%
# Inter-chip gates: F_2Q = 99.0%  (automatic per-edge assignment)
print(backend)  # FakeCepheus[Qiskit](noisy, 36q, cepheus-1-36q)

from fakenovera.pyquil import get_qc
from pyquil import Program
from pyquil.gates import H, CZ, MEASURE

qc = get_qc()  # Noisy 9Q-square-lattice QuantumComputer
p = Program(H(4), CZ(4, 1), MEASURE(4, 0))
result = qc.run(qc.compile(p))

from fakenovera import optimal_depth, cumulative_fidelity, print_specs

# Optimal QRC depth at 70% fidelity threshold
d_opt = optimal_depth(0.70)
print(f"Novera d_opt = {d_opt:.2f} -> {round(d_opt)} layers")
# Novera d_opt = 4.94 -> 5 layers

# Cumulative fidelity at depth 5
f_cum = cumulative_fidelity(5)
print(f"F_cum(d=5) = {f_cum:.1%}")
# F_cum(d=5) = 69.7%

# Full analysis table
print_specs()

from fakecepheus import optimal_depth, cumulative_fidelity

# Cepheus: 60 edges per layer -> fidelity drops fast
d_opt = optimal_depth(0.70)
print(f"Cepheus d_opt = {d_opt:.2f} -> {round(d_opt)} layer")
# Cepheus d_opt = 0.99 -> 1 layer  (curse of connectivity!)

# FakeNovera
from fakenovera import NOVERA_SPECS            # Official Rigetti (default)
from fakenovera import NOVERA_SPECS_ZURICH      # Zurich benchmarks

# FakeCepheus
from fakecepheus import CEPHEUS_SPECS           # Default (F_2Q_intra=99.5%)
from fakecepheus import CEPHEUS_SPECS_CONSERVATIVE  # Pessimistic (F_2Q_intra=99.4%)

from fakenovera import get_backend

# Auto-detect: tries PyQuil first, falls back to Qiskit
backend = get_backend("auto")

# Explicit framework selection
backend = get_backend("qiskit", seed=42, specs=NOVERA_SPECS_ZURICH)
backend = get_backend("pyquil", noisy=True)

from fakenovera import NOVERA_EDGES, NOVERA_COUPLING_MAP, get_topology
from fakecepheus import (
    CEPHEUS_EDGES,
    CEPHEUS_INTRA_CHIP_EDGES,
    CEPHEUS_INTER_CHIP_EDGES,
    is_inter_chip_edge,
    get_chip_id,
    get_topology,
)

# NetworkX graph with node/edge attributes
G = get_topology()  # nodes have 'chip' attr, edges have 'type' attr

from fakenovera.qiskit.noise import create_novera_noise_model, create_novera_target
from fakecepheus.qiskit.noise import create_cepheus_noise_model, create_cepheus_target

# Standalone noise model (for use with your own AerSimulator)
noise = create_novera_noise_model(include_readout=True, include_thermal=True)
target = create_novera_target()

# Cepheus: heterogeneous noise (per-edge fidelity)
noise = create_cepheus_noise_model()  # Automatically assigns F_2Q per edge type

from fakenovera import cumulative_fidelity, optimal_depth

# Cumulative fidelity: F_cum = F_2Q^(n_edges * depth)
f = cumulative_fidelity(depth=5)  # 0.697

# Optimal depth: d_opt = ln(F_threshold) / (n_edges * ln(F_2Q))
d = optimal_depth(fidelity_threshold=0.70)  # 4.94

# Cepheus supports heterogeneous mode
from fakecepheus import cumulative_fidelity, optimal_depth
f = cumulative_fidelity(depth=1, heterogeneous=True)   # Per-edge fidelities
f = cumulative_fidelity(depth=1, heterogeneous=False)  # Weighted average