AitherShield

from qiskit import QuantumCircuit from qiskit_ibm_runtime import QiskitRuntimeService from qiskit.providers.models import BackendProperties import numpy as np def test_backend_viability(backend_name: str, provider_token: str): """ Testet, ob ein Backend die minimalen Anforderungen für AitherShield erfüllt. Gibt einen Booleschen Status und einen detaillierten Report zurück. """ # Konfiguriere minimale Anforderungen (Diese Werte können angepasst werden) MIN_T1 = 100.0 # μs MIN_T2 = 50.0 # μs MAX_READOUT_ERROR = 0.05 # 5% service = QiskitRuntimeService(channel="ibm_quantum", token=provider_token) backend = service.backend(backend_name) try: props = backend.properties() n_qubits = backend.configuration().n_qubits report = { 'backend': backend_name, 'n_qubits': n_qubits, 't1_ok': [], 't2_ok': [], 'readout_ok': [], 'passed': True } # Check each qubit's properties for qubit in range(n_qubits): t1 = props.t1(qubit) * 1e6 # Convert to μs t2 = props.t2(qubit) * 1e6 # Convert to μs ro_error = props.readout_error(qubit) t1_ok = t1 >= MIN_T1 t2_ok = t2 >= MIN_T2 ro_ok = ro_error <= MAX_READOUT_ERROR report['t1_ok'].append(t1_ok) report['t2_ok'].append(t2_ok) report['readout_ok'].append(ro_ok) if not all([t1_ok, t2_ok, ro_ok]): report['passed'] = False return report['passed'], report except Exception as e: return False, {'error': str(e)} # Beispiel für die Nutzung im Labor: if __name__ == "__main__": token = "YOUR_IBM_TOKEN_HERE" backend = "ibm_brisbane" is_viable, report = test_backend_viability(backend, token) print(f"Backend {backend} viable: {is_viable}") print("Detailed report:", report)

from qiskit import QuantumCircuit, execute from qiskit_ibm_runtime import QiskitRuntimeService def measure_bell_fidelity(backend_name: str, provider_token: str, qubit_pair: tuple, shots: int = 1024): """ Erzeugt einen Bell-Zustand |Φ⁺⟩ = (|00⟩ + |11⟩)/√2 auf zwei Qubits, misst ihn und berechnet die Korrelationsfidelity. """ qc = QuantumCircuit(2, 2) qc.h(qubit_pair[0]) # Hadamard-Gatter erzeugt Überlagerung qc.cx(qubit_pair[0], qubit_pair[1]) # CNOT erzeugt Verschränkung qc.measure([0, 1], [0, 1]) # Misst beide Qubits service = QiskitRuntimeService(channel="ibm_quantum", token=provider_token) backend = service.backend(backend_name) job = execute(qc, backend, shots=shots) counts = job.result().get_counts() # Berechnung der Bell-Fidelity: (Anzahl korrelierter Ergebnisse) / (Gesamt-Shots) correlated_counts = counts.get('00', 0) + counts.get('11', 0) fidelity = correlated_counts / shots return fidelity, counts # Beispiel für die Nutzung im Labor: if __name__ == "__main__": token = "YOUR_IBM_TOKEN_HERE" backend = "ibm_brisbane" pair = (0, 1) # Wähle zwei physisch verbundene Qubits aus der Backend-Topologie fidelity, results = measure_bell_fidelity(backend, token, pair) print(f"Bell-State Fidelity for qubits {pair}: {fidelity:.3f}") print("Raw counts:", results)

from qiskit import QuantumCircuit, execute from qiskit_ibm_runtime import QiskitRuntimeService import numpy as np def test_basic_mask_recovery(backend_name: str, provider_token: str, qubit: int, shots: int = 1024): """ Testet das Grundprinzip: Anwenden und Entfernen von Rauschen auf einem Qubit. """ # 1. Erzeuge den ursprünglichen Zustand |1⟩ qc_original = QuantumCircuit(1, 1) qc_original.x(qubit) # Qubit in |1⟩ Zustand versetzen qc_original.measure(qubit, 0) # 2. Simuliere "Maskieren": Füge willkürliches Rauschen hinzu (hier: eine starke Rotation) qc_masked = QuantumCircuit(1, 1) qc_masked.x(qubit) qc_masked.rx(np.pi/2, qubit) # Simuliert eine Rauschschicht qc_masked.measure(qubit, 0) # 3. Simuliere "Entmaskieren": Füge die inverse Operation hinzu qc_unmasked = QuantumCircuit(1, 1) qc_unmasked.x(qubit) qc_unmasked.rx(np.pi/2, qubit) # Rauschen qc_unmasked.rx(-np.pi/2, qubit) # Inverses Rauschen (Entmaskieren) qc_unmasked.measure(qubit, 0) service = QiskitRuntimeService(channel="ibm_quantum", token=provider_token) backend = service.backend(backend_name) # Führe alle drei Schaltkreise aus job_orig = execute(qc_original, backend, shots=shots) job_mask = execute(qc_masked, backend, shots=shots) job_unmask = execute(qc_unmasked, backend, shots=shots) counts_orig = job_orig.result().get_counts() counts_mask = job_mask.result().get_counts() counts_unmask = job_unmask.result().get_counts() # Berechne die Trefferquote für den erwarteten Zustand |1> fidelity_original = counts_orig.get('1', 0) / shots fidelity_masked = counts_mask.get('1', 0) / shots fidelity_unmasked = counts_unmask.get('1', 0) / shots return { 'fidelity_original': fidelity_original, 'fidelity_masked': fidelity_masked, 'fidelity_unmasked': fidelity_unmasked, 'counts_original': counts_orig, 'counts_masked': counts_mask, 'counts_unmasked': counts_unmask } # Beispiel für die Nutzung im Labor: if __name__ == "__main__": token = "YOUR_IBM_TOKEN_HERE" backend = "ibm_brisbane" qubit_idx = 0 results = test_basic_mask_recovery(backend, token, qubit_idx) print("Original Fidelity:", results['fidelity_original']) print("Masked Fidelity (should be low):", results['fidelity_masked']) print("Unmasked Fidelity (should be recovered):", results['fidelity_unmasked'])