Reducing Entropy Through Quantum Teleportation On IBM's 127-Qubit Quantum Computer Osaka

Code:

from qiskit import QuantumCircuit, transpile, IBMQ, execute
from qiskit. tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
import json
import csv
from datetime import datetime

# Encoder for handling complex numbers and datetime in JSON serialization
def custom_encoder(obj):
    if isinstance(obj, complex):
        return {"real": obj.real, "imag": obj.imag}
    elif isinstance(obj, datetime):
        return obj.isoformat()
    elif callable(obj):
        return "Callable method or function"
    raise TypeError("Object of type '%s' is not JSON serializable" % type(obj).__name__)

# Load IBMQ Account
IBMQ. save_account('Your_IBM_Key_O-`', overwrite=True)
IBMQ.load_account()

# Select a backend
provider = IBMQ.get_provider(hub='ibm-q')
device = provider.get_backend('ibm_osaka')  # Example backend, replace with your choice

# Function to create Bell pair
def create_bell_pair(qc, q1, q2):
    qc.h(q1)
    qc. cx(q1, q2)

# Function to teleport qubit
def teleport_qubit(qc, src, inter, trg):
    qc. cx(src, inter)
    qc.h(src)
    qc.barrier()
    qc.measure(src, 0)
    qc.measure(inter, 1)
    qc.barrier()
    qc. cx(inter, trg)
    qc. cz(src, trg)

# Prepare the results dictionary
results = {
    "backend_name": device. name(),
    "backend_configuration": device.configuration().to_dict(),
    "backend_properties": device. properties().to_dict(),
}

# Selected distances for teleportation
distances = [1, 2, 3]

for distance in distances:
    print(f"Running teleportation over distance: {distance}")

    # Create the circuit
    qc = QuantumCircuit(4, 2)
    create_bell_pair(qc, 0, 1)
    teleport_qubit(qc, 0, 1, 2)

    # Transpile for the real backend
    transpiled_circuit = transpile(qc, device, optimization_level=3)

    # Execute the job on the real device
    job = execute(transpiled_circuit, backend=device, shots=1024)
    job_monitor(job)

    # Get the result
    result = job.result()
    counts = result.get_counts(qc)

    # Record detailed results for this distance
    results[f"Distance_{distance}"] = {
        "measurement_distribution": counts,
        "job_id": job.job_id(),
        "execution_time": result.time_taken,
    }

# Record Calibration Data
calibration_data = {}
try:
    with open("/Users/Your/Documents/ibm_osaka_calibrations_2024-02-07T23_00_45Z.csv", 'r') as cal_file:
        csv_reader = csv.DictReader(cal_file)
        for row in csv_reader:
            if 'qubit' in row:
                calibration_data[row['qubit']] = row
except Exception as e:
    print(f"Error reading calibration data: {e}")

results["calibration_data"] = calibration_data

# Save the results to a JSON file using the encoder for complex numbers and datetime
results_file = "/Users/Your/Documents/Fidelity_Results_HW.json"
with open(results_file, 'w') as f:
    json.dump(results, f, indent=4, default=custom_encoder)

print(f"Results saved to {results_file}")

# Plotting the histogram of the runs
plot_histogram([results[f"Distance_{distance}"]["measurement_distribution"] for distance in distances])
plt. show()