import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.providers.aer.noise import NoiseModel, thermal_relaxation_error, depolarizing_error
import matplotlib.pyplot as plt
# --- Conversão temperatura -> ruído térmico ---
def temp_to_T1_T2(temp_celsius):
# Inferência física simplificada:
# Temperaturas mais baixas -> maior coerência
base_T1 = 80e-6 # 80 microseg (hardware típico)
base_T2 = 60e-6
factor = max(0.2, min(2.0, (25 - temp_celsius) / 25))
return base_T1 * factor, base_T2 * factor
# --- Ruído eletromagnético de aviões ---
def avionics_noise(level=0.02):
# 2% depolarização típica de ambiente ruidoso
return depolarizing_error(level, 1)
# --- Ruído de vibração (fase aleatória) ---
def vibration_phase_error(level=0.01):
return depolarizing_error(level, 1)
# --- Construção do modelo de ruído ---
def build_noise_model(temp_celsius):
T1, T2 = temp_to_T1_T2(temp_celsius)
noise = NoiseModel()
thermal = thermal_relaxation_error(T1, T2, 50e-9) # 50 ns gate time
em = avionics_noise(0.02)
vib = vibration_phase_error(0.01)
noise.add_all_qubit_quantum_error(thermal, ['x','h'])
noise.add_all_qubit_quantum_error(em, ['cx'])
noise.add_all_qubit_quantum_error(vib, ['h'])
return noise
# --- Grover Oracle ---
def oracle(n, target):
qc = QuantumCircuit(n)
for i, bit in enumerate(target):
if bit == '0':
qc.x(i)
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
for i, bit in enumerate(target):
if bit == '0':
qc.x(i)
return qc
# --- Diffusion ---
def diffusion(n):
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
# --- Grover completo ---
def grover(n, target, iterations):
qc = QuantumCircuit(n, n)
qc.h(range(n))
for _ in range(iterations):
qc.compose(oracle(n, target), inplace=True)
qc.compose(diffusion(n), inplace=True)
qc.measure(range(n), range(n))
return qc
# --- Experimento ---
def run(temp):
backend = Aer.get_backend('qasm_simulator')
noise = build_noise_model(temp)
qc = grover(3, "101", 2)
job = execute(qc, backend, noise_model=noise, shots=2000)
counts = job.result().get_counts()
return counts.get("101", 0) / 2000
temps = np.linspace(-60, 30, 40)
results = [run(t) for t in temps]
plt.plot(temps, results)
plt.xlabel("Temperatura (°C)")
plt.ylabel("Probabilidade de sucesso")
plt.title("Grover sob ruído de altitude de avião comercial")
plt.grid(True)
plt.show()
from qiskit import QuantumCircuit, Aer, execute
from qiskit.providers.aer.noise import NoiseModel
from noise_models import combined_model # modelo IBM realista
def grover_3qubits():
qc = QuantumCircuit(3,3)
qc.h([0,1,2])
qc.x(0); qc.x(2)
qc.h(2); qc.mcx([0,1],2); qc.h(2)
qc.x(0); qc.x(2)
qc.h([0,1,2]); qc.x([0,1,2])
qc.h(2); qc.mcx([0,1],2); qc.h(2)
qc.x([0,1,2]); qc.h([0,1,2])
qc.measure([0,1,2],[0,1,2])
return qc
backend = Aer.get_backend("qasm_simulator")
for scale in [0.5,1,2,3]:
noise = combined_model(scale=scale)
job = execute(grover_3qubits(), backend, noise_model=noise, shots=2000)
print(scale, job.result().get_counts())
def grover_adapt(n, target, phi):
qc = QuantumCircuit(n,n)
qc.h(range(n))
for _ in range(2):
qc.compose(oracle_phase(n, target, phi), inplace=True)
qc.compose(diffusion_phase(n, phi), inplace=True)
qc.measure(range(n), range(n))
return qc
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.providers.aer.noise import NoiseModel, thermal_relaxation_error, depolarizing_error
from qiskit.providers.aer.noise.errors import amplitude_damping_error, phase_error
import matplotlib.pyplot as plt
# ============================================================
# 1. MODELOS DE RUÍDO
# ============================================================
# --- A) Modelo de altitude de avião comercial ---
def noise_altitude(temp_celsius):
base_T1 = 80e-6
base_T2 = 60e-6
factor = max(0.2, min(2.0, (25 - temp_celsius) / 25))
T1 = base_T1 * factor
T2 = base_T2 * factor
noise = NoiseModel()
thermal = thermal_relaxation_error(T1, T2, 50e-9)
em = depolarizing_error(0.02, 1)
vib = depolarizing_error(0.01, 1)
noise.add_all_qubit_quantum_error(thermal, ['x','h'])
noise.add_all_qubit_quantum_error(em, ['cx'])
noise.add_all_qubit_quantum_error(vib, ['h'])
return noise
# --- B) Modelo IBM realista ---
def noise_ibm(scale=1.0):
noise = NoiseModel()
T1 = 100e-6 / scale
T2 = 70e-6 / scale
thermal = thermal_relaxation_error(T1, T2, 60e-9)
dep = depolarizing_error(0.01 * scale, 1)
noise.add_all_qubit_quantum_error(thermal, ['x','h'])
noise.add_all_qubit_quantum_error(dep, ['cx'])
return noise
# --- C) Modelo académico ---
def noise_academic():
noise = NoiseModel()
amp = amplitude_damping_error(0.05)
phaseflip = phase_error(0.03)
noise.add_all_qubit_quantum_error(amp, ['x','h'])
noise.add_all_qubit_quantum_error(phaseflip, ['cx'])
return noise
# ============================================================
# 2. ORÁCULO E DIFUSÃO
# ============================================================
def oracle(n, target):
qc = QuantumCircuit(n)
for i, bit in enumerate(target):
if bit == '0':
qc.x(i)
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
for i, bit in enumerate(target):
if bit == '0':
qc.x(i)
return qc
def diffusion(n):
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc
# ============================================================
# 3. GROVER PADRÃO E ADAPTATIVO
# ============================================================
def grover(n, target, iterations):
qc = QuantumCircuit(n, n)
qc.h(range(n))
for _ in range(iterations):
qc.compose(oracle(n, target), inplace=True)
qc.compose(diffusion(n), inplace=True)
qc.measure(range(n), range(n))
return qc
def grover_adapt(n, target, iterations, phi):
qc = QuantumCircuit(n, n)
qc.h(range(n))
for _ in range(iterations):
qc.compose(oracle(n, target), inplace=True)
qc.rz(phi, range(n))
qc.compose(diffusion(n), inplace=True)
qc.rz(phi, range(n))
qc.measure(range(n), range(n))
return qc
# ============================================================
# 4. EXECUÇÃO + ZNE (Zero‑Noise Extrapolation)
# ============================================================
def run_with_noise(qc, noise):
backend = Aer.get_backend("qasm_simulator")
job = execute(qc, backend, noise_model=noise, shots=2000)
return job.result().get_counts()
def ZNE(qc, noise_fn):
scales = [0.5, 1, 2, 3]
results = []
for s in scales:
noise = noise_fn(s) if noise_fn == noise_ibm else noise_fn
counts = run_with_noise(qc, noise)
results.append(counts)
return results
# ============================================================
# 5. SISTEMA DE SELEÇÃO AUTOMÁTICA
# ============================================================
def select_noise(model, temp=None):
if model == "altitude":
return noise_altitude(temp)
elif model == "ibm":
return noise_ibm()
elif model == "academic":
return noise_academic()
else:
raise ValueError("Modelo inválido.")
# ============================================================
# 6. EXPERIMENTO ÚNICO
# ============================================================
def experiment(model="altitude", temp=-50, adaptive=False, phi=np.pi/4):
n = 3
target = "101"
iterations = 2
qc = grover_adapt(n, target, iterations, phi) if adaptive else grover(n, target, iterations)
noise = select_noise(model, temp)
counts = run_with_noise(qc, noise)
print("Modelo:", model)
print("Adaptive:", adaptive)
print("Resultado:", counts)
return counts
# ============================================================
# 7. EXEMPLO DE EXECUÇÃO
# ============================================================
if __name__ == "__main__":
experiment(model="altitude", temp=-60, adaptive=False)
experiment(model="ibm", adaptive=True, phi=np.pi/3)
experiment(model="academic", adaptive=False)
IBM
No comments:
Post a Comment