from nqpu import QuantumCircuit, NQPUBackend

# Create a circuit
circuit = QuantumCircuit(4)
circuit.h(0)
circuit.cnot(0, 1)
circuit.cnot(1, 2)
circuit.measure_all()

# Run with GPU acceleration
backend = NQPUBackend(gpu=True)
result = backend.run(circuit, shots=1000)
print(result.counts)

import numpy as np
from nqpu import (
    ModelQPU,
    TransverseFieldIsing1D,
    load_entanglement_spectrum_result,
    load_loschmidt_echo_result,
    load_response_spectrum_result,
    load_ground_state_result,
    load_sweep_result,
    load_tensor_network_state,
    load_two_time_correlator_result,
    save_entanglement_spectrum_result,
    save_loschmidt_echo_result,
    save_response_spectrum_result,
    save_ground_state_result,
    save_sweep_result,
    save_tensor_network_state,
    save_two_time_correlator_result,
)

qpu = ModelQPU()
model = TransverseFieldIsing1D(
    num_sites=8,
    coupling=1.0,
    transverse_field=0.8,
    boundary="open",
)

# Ground state with observables and entanglement entropy
ground_state = qpu.ground_state(
    model,
    observables=["magnetization_z", "Z0Z1"],
    subsystem=[0, 1, 2, 3],
)
print(ground_state.ground_state_energy)
print(ground_state.observables)

# Warm-start a nearby ground-state solve from a prior tensor-network state
retuned_state = qpu.ground_state(
    TransverseFieldIsing1D(num_sites=8, coupling=1.0, transverse_field=0.9),
    initial_state=ground_state,
    observables=["magnetization_z"],
)

# Parameter sweep across a phase transition
sweep = qpu.sweep_parameter(
    model,
    "transverse_field",
    np.linspace(0.2, 1.8, 17),
    observables=["magnetization_z"],
    subsystem=[0, 1, 2, 3],
)
print(sweep.energies)
print(sweep.spectral_gaps)
print(sweep.entanglement_entropy)

# Adaptive phase-transition zoom on top of the coarse grid
adaptive = qpu.adaptive_sweep_parameter(
    model,
    "transverse_field",
    [0.2, 0.6, 1.0, 1.4, 1.8],
    observables=["magnetization_z"],
    subsystem=[0, 1, 2, 3],
    metric="spectral_gap",
    max_refinement_rounds=2,
    refinements_per_round=1,
    checkpoint_path="checkpoints/tfim_adaptive.json",
)
print(adaptive.values)
print(adaptive.refinement_history)

# Reuse a prepared state as the initial condition for a quench
quench = qpu.quench(
    TransverseFieldIsing1D(num_sites=8, coupling=1.0, transverse_field=1.1),
    times=[0.0, 0.05, 0.10],
    initial_state=ground_state,
    observables=["magnetization_z", "Z0Z1"],
    subsystem=[0, 1, 2, 3],
)
print(quench.observables["Z0Z1"])
print(quench.entanglement_entropy)

# Build correlation functions and structure factors from the same solver surface
correlations = qpu.correlation_matrix(model, pauli="Z", connected=True)
static_sf = qpu.structure_factor(model, [0.0, np.pi / 2.0, np.pi], connected=True)
dynamic_sf = qpu.dynamic_structure_factor(
    model,
    times=[0.0, 0.05, 0.10],
    momenta=[0.0, np.pi],
    pauli="Z",
    connected=True,
    initial_state="neel",
)
frequency_sf = qpu.frequency_structure_factor(
    dynamic_sf,
    frequencies=[-20.0, 0.0, 20.0],
    window="hann",
)
two_time = qpu.two_time_correlator(
    model,
    times=[0.0, 0.05, 0.10],
    pauli="Z",
    connected=True,
)
local_response = qpu.linear_response_spectrum(
    model,
    times=[0.0, 0.05, 0.10],
    pauli="Z",
    source_sites=[0, 2, 4],
    frequencies=[-20.0, 0.0, 20.0],
    window="hann",
)
spectrum = qpu.entanglement_spectrum(
    model,
    subsystem=[0, 1, 2, 3],
    num_levels=4,
)
echo = qpu.loschmidt_echo(
    model,
    times=[0.0, 0.05, 0.10],
    initial_state="neel",
)
response = qpu.linear_response_spectrum(
    two_time,
    momenta=[0.0, np.pi],
    frequencies=[-20.0, 0.0, 20.0],
    window="hann",
)
print(correlations.matrix)
print(static_sf.values)
print(dynamic_sf.values.shape)
print(frequency_sf.intensity)
print(two_time.values.shape)
print(local_response.measure_sites)
print(spectrum.eigenvalues, spectrum.entanglement_energies)
print(echo.echo, echo.return_rate)
print(response.intensity)

# Checkpoint and restore a Rust-backed tensor-network state
save_tensor_network_state(ground_state, "checkpoints/tfim_ground.json")
restored_state = load_tensor_network_state("checkpoints/tfim_ground.json")

# Save the full ground-state result manifest plus sidecar backend state
save_ground_state_result(ground_state, "checkpoints/tfim_ground_result.json")
restored_ground = load_ground_state_result("checkpoints/tfim_ground_result.json")
save_entanglement_spectrum_result(spectrum, "checkpoints/tfim_entanglement_spectrum.json")
restored_spectrum = load_entanglement_spectrum_result(
    "checkpoints/tfim_entanglement_spectrum.json"
)
save_two_time_correlator_result(two_time, "checkpoints/tfim_two_time.json")
restored_two_time = load_two_time_correlator_result("checkpoints/tfim_two_time.json")
save_response_spectrum_result(response, "checkpoints/tfim_response.json")
restored_response = load_response_spectrum_result("checkpoints/tfim_response.json")
save_loschmidt_echo_result(echo, "checkpoints/tfim_echo.json")
restored_echo = load_loschmidt_echo_result("checkpoints/tfim_echo.json")

# Save a sweep manifest with phase-diagram data and per-point metadata
save_sweep_result(sweep, "checkpoints/tfim_sweep.json")
restored_sweep = load_sweep_result("checkpoints/tfim_sweep.json")

# Long sweeps can checkpoint progress and resume later
resumable = qpu.sweep_parameter(
    model,
    "transverse_field",
    np.linspace(0.2, 1.8, 17),
    observables=["magnetization_z"],
    subsystem=[0, 1, 2, 3],
    checkpoint_path="checkpoints/tfim_resume.json",
)
resumed = qpu.sweep_parameter(
    model,
    "transverse_field",
    np.linspace(0.2, 1.8, 17),
    observables=["magnetization_z"],
    subsystem=[0, 1, 2, 3],
    checkpoint_path="checkpoints/tfim_resume.json",
    resume=True,
)
print(resumed.completed_points, resumed.is_complete)

from nqpu.chem import DrugDesigner, Molecule

# Design drug candidates
designer = DrugDesigner()
molecules = designer.generate_candidates(
    target="BACE1",  # Alzheimer's target
    constraints={"mw": (200, 500), "logp": (-1, 5)}
)

# Get ADMET predictions
for mol in molecules:
    print(f"{mol.smiles}: QED={mol.qed:.3f}, Lipinski={mol.lipinski}")

from nqpu.trading import (
    QuantumVolatilitySurface,
    QuantumRegimeDetector,
    QuantumSignalGenerator,
    KellyCriterion,
)
import numpy as np

# Detect market regime
prices = np.array([...])  # your price data
detector = QuantumRegimeDetector(n_qubits=4)
regime = detector.detect(prices)
print(f"Current regime: {regime.label} (confidence: {regime.confidence:.2f})")

# Generate quantum-enhanced trading signals
signal_gen = QuantumSignalGenerator(n_qubits=4)
signals = signal_gen.generate(prices, volume=volume)
print(f"Signal: {signals.direction}, Confidence: {signals.confidence:.2f}")

# Quantum-aware position sizing
kelly = KellyCriterion(n_qubits=3)
position_size = kelly.optimal_fraction(win_rate=0.65, avg_win=0.02, avg_loss=0.01)

from nqpu.finance import (
    QuantumOptionPricer, black_scholes_call,
    PortfolioOptimizer, compute_efficient_frontier,
    RiskAnalyzer, RiskConfig, quantum_var,
)

# QAE-based European call pricing vs Black-Scholes
pricer = QuantumOptionPricer(spot=100, strike=100, rate=0.05,
                             volatility=0.2, maturity=1.0)
result = pricer.price()
bs = black_scholes_call(100, 100, 0.05, 0.2, 1.0)
print(f"QAE: {result.price:.2f}  BS: {bs:.2f}")

# QAOA portfolio optimization
optimizer = PortfolioOptimizer(expected_returns, covariance,
                               risk_aversion=1.0, budget=3)
portfolio = optimizer.optimize()
frontier = compute_efficient_frontier(expected_returns, covariance, n_points=20)

# Or use programmatically
import requests

# Create a network and add nodes
net = requests.post("http://localhost:8000/networks").json()
nid = net["network_id"]
requests.post(f"http://localhost:8000/networks/{nid}/nodes",
              json={"node_id": "alice", "x": 0, "y": 0})
requests.post(f"http://localhost:8000/networks/{nid}/nodes",
              json={"node_id": "bob", "x": 50, "y": 0})
requests.post(f"http://localhost:8000/networks/{nid}/links",
              json={"node_a": "alice", "node_b": "bob"})

# Establish a quantum key
key = requests.post(f"http://localhost:8000/networks/{nid}/establish-key",
                    json={"node_a": "alice", "node_b": "bob",
                          "protocol": "BB84", "n_bits": 10000}).json()
print(f"Secure: {key['secure']}, QBER: {key['qber']:.4f}")

from nqpu.emulator import QPU, HardwareProfile
from nqpu.transpiler import QuantumCircuit

# Build a GHZ circuit
qc = QuantumCircuit(3)
qc.h(0).cx(0, 1).cx(1, 2)

# Emulate on real hardware profiles
for profile in [HardwareProfile.IONQ_ARIA, HardwareProfile.IBM_HERON,
                HardwareProfile.QUERA_AQUILA]:
    qpu = QPU(profile, noise=True, seed=42, max_qubits=8)
    job = qpu.run(qc, shots=1000)
    r = job.result
    print(f"{qpu.name}: fidelity={r.fidelity_estimate:.4f}, "
          f"depth={r.circuit_depth}, runtime={r.estimated_runtime_us:.0f}us")

# Cross-backend comparison in one call
results = QPU.compare(qc, shots=1000, seed=42)

from nqpu.bridges import IsingCorrelationModel, HamiltonianVolatility
import numpy as np

# Map asset correlations to a quantum spin model
cov = np.array([[0.04, 0.02], [0.02, 0.09]])
model = IsingCorrelationModel.from_covariance(cov, names=["AAPL", "GOOG"])
print(f"Critical temperature: {model.critical_temperature:.3f}")
print(f"Systemic risk (entanglement): {model.entanglement_risk():.4f}")

# Evolve an implied volatility surface via Hamiltonian dynamics
hv = HamiltonianVolatility(n_strikes=4, coupling=0.5)
result = hv.evolve_surface(np.array([0.2, 0.3, 0.25, 0.35]), t_final=1.0)
print(f"Final vol profile: {result['final_vols']}")

from nqpu.emulator import HardwareAdvisor

advisor = HardwareAdvisor()
rec = advisor.recommend([("h", 0), ("cx", 0, 1), ("ccx", 0, 1, 2)])
print(rec.best_profile.name)   # Recommended QPU
print(rec.reasoning)           # Why this hardware is optimal