Alternative to IBM Heron hardware ( grover algorithm high altitude scale noise adaptive decrypt SHA256)

from qiskit.providers.aer.noise import NoiseModel, thermal_relaxation_error, depolarizing_error

def noise_sycamore(scale):

    noise = NoiseModel()

    T1 = 25e-6 / scale

    T2 = 35e-6 / scale

    gate_time = 20e-9

    dep1 = depolarizing_error(0.0001 * scale, 1)

    dep2 = depolarizing_error(0.006 * scale, 2)

    thermal = thermal_relaxation_error(T1, T2, gate_time)

    noise.add_all_qubit_quantum_error(thermal, ['x','h'])

    noise.add_all_qubit_quantum_error(dep1, ['x','h'])

    noise.add_all_qubit_quantum_error(dep2, ['cx'])

    return noise

def noise_aspen(scale):

    noise = NoiseModel()

    T1 = 40e-6 / scale

    T2 = 50e-6 / scale

    gate_time = 100e-9

    dep1 = depolarizing_error(0.0002 * scale, 1)

    dep2 = depolarizing_error(0.01 * scale, 2)

    thermal = thermal_relaxation_error(T1, T2, gate_time)

    noise.add_all_qubit_quantum_error(thermal, ['x','h'])

    noise.add_all_qubit_quantum_error(dep1, ['x','h'])

    noise.add_all_qubit_quantum_error(dep2, ['cx'])

    return noise

def noise_ionq(scale):

    noise = NoiseModel()

    T1 = 1e9  # praticamente infinito

    T2 = 1.0  # 1 segundo

    gate_time = 200e-6

    dep1 = depolarizing_error(0.000001 * scale, 1)

    dep2 = depolarizing_error(0.001 * scale, 2)

    thermal = thermal_relaxation_error(T1, T2, gate_time)

    noise.add_all_qubit_quantum_error(thermal, ['x','h'])

    noise.add_all_qubit_quantum_error(dep1, ['x','h'])

    noise.add_all_qubit_quantum_error(dep2, ['cx'])

    return noise

Noise high altitude decrypt ( also ideal decode )Grover algorithm Sha256 part 2

 import numpy as np

from qiskit import QuantumCircuit, Aer, execute

from qiskit.providers.aer.noise import NoiseModel, depolarizing_error, thermal_relaxation_error

# ============================================================

# 1. Difusão (Grover)

# ============================================================

def diffusion(qc, qubits):

    qc.h(qubits)

    qc.x(qubits)

    qc.h(qubits[-1])

    qc.mcx(qubits[:-1], qubits[-1])

    qc.h(qubits[-1])

    qc.x(qubits)

    qc.h(qubits)

# ============================================================

# 2. Oracle simples (pode ser substituído por SHA-256)

# ============================================================

def oracle_mark(qc, target):

    n = qc.num_qubits

    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)

# ============================================================

# 3. Grover automático

# ============================================================

def grover_circuit(n, target, iterations):

    qc = QuantumCircuit(n, n)

    qc.h(range(n))

    for _ in range(iterations):

        oracle_mark(qc, target)

        diffusion(qc, range(n))

    qc.measure(range(n), range(n))

    return qc

# ============================================================

# 4. Modelo de ruído escalável

# ============================================================

def scalable_noise(scale):

    noise = NoiseModel()

    # Parâmetros base (podem ser substituídos por IBM Heron)

    T1 = 100e-6 / scale

    T2 = 80e-6 / scale

    gate_time = 50e-9

    thermal = thermal_relaxation_error(T1, T2, gate_time)

    dep1 = depolarizing_error(0.001 * scale, 1)

    dep2 = depolarizing_error(0.01 * scale, 2)

    noise.add_all_qubit_quantum_error(thermal, ['x','h'])

    noise.add_all_qubit_quantum_error(dep1, ['x','h'])

    noise.add_all_qubit_quantum_error(dep2, ['cx'])

    return noise

# ============================================================

# 5. Execução automática com ruído escalado

# ============================================================

def run_scaled_noise(qc, scales=[0.5, 1, 2, 3]):

    backend = Aer.get_backend("qasm_simulator")

    results = []

    for s in scales:

        noise = scalable_noise(s)

        job = execute(qc, backend, noise_model=noise, shots=4096)

        counts = job.result().get_counts()

        results.append((s, counts))

    return results

# ============================================================

# 6. Decode automático

# ============================================================

def decode(counts):

    return max(counts, key=counts.get)

# ============================================================

# 7. ZNE automático (extrapolação linear)

# ============================================================

def ZNE(results):

    probs = []

    for scale, counts in results:

        total = sum(counts.values())

        marked = max(counts, key=counts.get)

        probs.append((scale, counts[marked] / total))

    # extrapolação linear simples

    (s1, p1), (s2, p2) = probs[0], probs[1]

    zne_estimate = p1 + (p1 - p2)

    return zne_estimate

# ============================================================

# 8. Pipeline completo

# ============================================================

def grover_noise_decode(n=5, target="10101", iterations=2):

    qc = grover_circuit(n, target, iterations)

    results = run_scaled_noise(qc)

    

    print("\n--- Resultados por escala de ruído ---")

    for scale, counts in results:

        print(f"Ruído x{scale}: {counts}")

    print("\n--- Decode automático por escala ---")

    for scale, counts in results:

        print(f"Ruído x{scale}: estado marcado = {decode(counts)}")

    print("\n--- Estimativa ZNE (ruído zero) ---")

    print(ZNE(results))

    return results

# ============================================================

# 9. Execução

# ============================================================

grover_noise_decode()

import numpy as np

from qiskit import QuantumCircuit, Aer, execute

from qiskit.providers.aer.noise import NoiseModel, thermal_relaxation_error, depolarizing_error

# ============================================================

# 1. Ruído de altitude

# ============================================================

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

# ============================================================

# 2. SHA-256 reversível ideal (placeholder)

# ============================================================

def SHA256_reversible(qc, x_qubits, h_qubits):

    qc.cx(x_qubits, h_qubits)

# ============================================================

# 3. Oracle SHA-256

# ============================================================

def oracle_SHA256(qc, x_qubits, h_qubits, target_hash):

    for i, bit in enumerate(target_hash):

        if bit == "0":

            qc.x(h_qubits[i])

    qc.mcx(h_qubits[:-1], h_qubits[-1])

    for i, bit in enumerate(target_hash):

        if bit == "0":

            qc.x(h_qubits[i])

# ============================================================

# 4. Difusão

# ============================================================

def diffusion(qc, qubits):

    qc.h(qubits)

    qc.x(qubits)

    qc.h(qubits[-1])

    qc.mcx(qubits[:-1], qubits[-1])

    qc.h(qubits[-1])

    qc.x(qubits)

    qc.h(qubits)

# ============================================================

# 5. Grover + ruído de altitude

# ============================================================

def grover_SHA256_altitude(n=8, target_hash="10110011", iterations=2, temp=-60):

    qc = QuantumCircuit(2*n, n)

    x = list(range(n))

    h = list(range(n, 2*n))

    qc.h(x)

    SHA256_reversible(qc, x, h)

    for _ in range(iterations):

        oracle_SHA256(qc, x, h, target_hash)

        diffusion(qc, x)

    qc.measure(x, range(n))

    backend = Aer.get_backend("qasm_simulator")

    noise = noise_altitude(temp)

    result = execute(qc, backend, noise_model=noise, shots=4096).result()

    return result.get_counts()

# ============================================================

# 6. Decode sob ruído

# ============================================================

def decode_noisy(counts):

    return max(counts, key=counts.get)

# ============================================================

# 7. Execução

# ============================================================

counts = grover_SHA256_altitude()

print("Counts:", counts)

print("Pré-imagem encontrada:", decode_noisy(counts))

from qiskit.providers.aer.noise import NoiseModel, thermal_relaxation_error, depolarizing_error

def noise_ibm_heron():

    noise = NoiseModel()

    # Coerência realista

    T1 = 120e-6

    T2 = 90e-6

    gate_time = 80e-9

    # Erros realistas

    err_1q = 0.0005

    err_2q = 0.005

    thermal = thermal_relaxation_error(T1, T2, gate_time)

    dep1 = depolarizing_error(err_1q, 1)

    dep2 = depolarizing_error(err_2q, 2)

    noise.add_all_qubit_quantum_error(thermal, ['x','h'])

    noise.add_all_qubit_quantum_error(dep1, ['x','h'])

    noise.add_all_qubit_quantum_error(dep2, ['cx'])

    return noise

def ZNE(qc, noise_fn):

    backend = Aer.get_backend("qasm_simulator")

    scales = [0.5, 1, 2, 3]

    results = []

    for s in scales:

        noise = noise_fn(s)

        job = execute(qc, backend, noise_model=noise, shots=4096)

        results.append(job.result().get_counts())

    # Extrapolação linear simples

    probs = [res.get(max(res, key=res.get), 0)/4096 for res in results]

    zne_estimate = probs[0] + (probs[0] - probs[1])  # extrapolação linear

    return zne_estimate

def PEC_correct(counts, error_rate=0.005):

    corrected = {}

    for state, c in counts.items():

        corrected[state] = c * (1 + error_rate)

    return corrected

def CDR_predict(counts):

    # Regressão linear conceptual

    total = sum(counts.values())

    probs = {k: v/total for k, v in counts.items()}

    return max(probs, key=probs.get)

def grover_SHA256_ibm(n=8, target_hash="10110011", iterations=2):

    qc = QuantumCircuit(2*n, n)

    x = list(range(n))

    h = list(range(n, 2*n))

    qc.h(x)

    SHA256_reversible(qc, x, h)

    for _ in range(iterations):

        oracle_SHA256(qc, x, h, target_hash)

        diffusion(qc, x)

    qc.measure(x, range(n))

    return qc

# Execução

qc = grover_SHA256_ibm()

backend = Aer.get_backend("qasm_simulator")

noise = noise_ibm_heron()

result = execute(qc, backend, noise_model=noise, shots=4096).result()

counts = result.get_counts()

# Mitigação

zne = ZNE(qc, lambda s: noise_ibm_heron())

pec = PEC_correct(counts)

cdr = CDR_predict(counts)

print("Counts brutos:", counts)

print("ZNE:", zne)

print("PEC:", pec)

print("CDR:", cdr)

from qiskit import QuantumCircuit, Aer, execute

# ============================================================

# 1. SHA-256 reversível ideal (abstração)

# ============================================================

def SHA256_reversible(qc, x_qubits, h_qubits):

    # Representação ideal: copia x → h

    # Em hardware real isto seria o circuito completo SHA-256 reversível

    qc.cx(x_qubits, h_qubits)

# ============================================================

# 2. Oracle ideal para SHA-256

# ============================================================

def oracle_SHA256(qc, x_qubits, h_qubits, target_hash):

    for i, bit in enumerate(target_hash):

        if bit == "0":

            qc.x(h_qubits[i])

    qc.mcx(h_qubits[:-1], h_qubits[-1])

    for i, bit in enumerate(target_hash):

        if bit == "0":

            qc.x(h_qubits[i])

# ============================================================

# 3. Difusão ideal

# ============================================================

def diffusion(qc, qubits):

    qc.h(qubits)

    qc.x(qubits)

    qc.h(qubits[-1])

    qc.mcx(qubits[:-1], qubits[-1])

    qc.h(qubits[-1])

    qc.x(qubits)

    qc.h(qubits)

# ============================================================

# 4. Grover ideal para SHA-256

# ============================================================

def grover_SHA256(n=256, target_hash="0"*256, iterations=2):

    qc = QuantumCircuit(2*n, n)

    x = list(range(n))

    h = list(range(n, 2*n))

    qc.h(x)

    SHA256_reversible(qc, x, h)

    for _ in range(iterations):

        oracle_SHA256(qc, x, h, target_hash)

        diffusion(qc, x)

    qc.measure(x, range(n))

    return qc

# ============================================================

# 5. Decode ideal

# ============================================================

def decode(counts):

    return max(counts, key=counts.get)

# ============================================================

# 6. Execução ideal

# ============================================================

backend = Aer.get_backend("qasm_simulator")

qc = grover_SHA256(n=8, target_hash="10110011")  # versão reduzida para teste

result = execute(qc, backend, shots=4096).result()

counts = result.get_counts()

print("Counts:", counts)

print("Pré-imagem encontrada:", decode(counts))

Decode SHA256 Grover's algorithm high altitude script code

 import numpy as np

from qiskit import QuantumCircuit, Aer, execute

# ============================================================

# 1. SHA-4 (versão reduzida para demonstração)

# ============================================================

def sha4(x):

    # Função hash simples de 4 bits (exemplo didático)

    return format((3*x + 1) % 16, "04b")

# ============================================================

# 2. Oracle SHA-4

# ============================================================

def oracle_sha4(n, target_hash):

    qc = QuantumCircuit(n)

    for x in range(2**n):

        if sha4(x) == target_hash:

            bits = format(x, "0{}b".format(n))

            for i, b in enumerate(bits):

                if b == "0":

                    qc.x(i)

            qc.h(n-1)

            qc.mcx(list(range(n-1)), n-1)

            qc.h(n-1)

            for i, b in enumerate(bits):

                if b == "0":

                    qc.x(i)

    return

Decrypt SHA256 GROVER_ITERATIONS algorithm ( altitude voos aviões comerciais) hardware IBM

 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