Exploring abstract Electron-Positron Annihilation on IBM's 127-Qubit Quantum Computer Osaka

Code:

# imports
from qiskit import QuantumCircuit, Aer, transpile, IBMQ, execute
from qiskit.visualization import plot_histogram
import json
from datetime import datetime
import matplotlib.pyplot as plt

# IBM Quantum api and backend
IBMQ. save_account('Your_IBM_Key_O-', overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibm_kyoto')  # Adjust to your specific backend
print("Using backend: ", backend. name())

# Gate for annihilation process
def annihilation_gate(qc, electron_qubit, positron_qubit):
    qc. cx(electron_qubit, positron_qubit)
    qc.h(electron_qubit)
    qc.x(electron_qubit)
    qc. cx(positron_qubit, electron_qubit)

# Initialize a Quantum Circuit with 2 qubits (representing electron and positron)
qc = QuantumCircuit(2)

# Apply gates to represent the initial states of the electron and positron
qc.h(0)
qc.h(1)

# Apply custom annihilation gate
annihilation_gate(qc, 0, 1)

# Measure the qubits to observe the outcome
qc.measure_all()

# Transpile the circuit for the ibm_kyoto 
transpiled_qc = transpile(qc, backend)

# Execute the circuit on the ibm_kyoto 
job = execute(transpiled_qc, backend)
result = job.result()
counts = result.get_counts(transpiled_qc)
print(counts)

# Save relevant data to a JSON file
data = {
    'measurement_counts': counts,
    'circuit_transpiled': transpiled_qc.qasm(),
    'backend': backend. name(),
    'backend_properties': backend. properties().to_dict(),
    'job_id': job.job_id(),
    'status': job.status(),
    'result_data': result. to_dict(),
    'execution_date': datetime. now().strftime("%Y-%m-%d %H:%M:%S")
}
output_file = '/Users/Documents/ElectronPositronAnnihilation.json'
with open(output_file, 'w') as f:
    json.dump(data, f, indent=4, default=str)

# Display histogram of measurement results with counts
plot_histogram(counts, title='Measurement Results', bar_labels=True)
plt. show() 

# Feynman-like Diagram from Run Result Code
# imports
import json
import matplotlib.pyplot as plt
import numpy as np

# Load measurement counts from JSON 
with open('/Users/Documents/ElectronPositronAnnihilation.json', 'r') as file:
    measurement_counts = json.load(file)

# Define the figure for the Feynman-like diagram
fig, ax = plt.subplots(figsize=(8, 6))
ax.axis('off')  # Remove the axis as they are not needed
ax.set_xlim([0, 4])
ax.set_ylim([0, 4])

# Define positions for the particles and vertices in the diagram
electron_position = (1, 3)
positron_position = (1, 1)
interaction_vertex = (2, 2)
outcomes_positions = {
    '00': (3, 3),
    '01': (3, 2.5),
    '10': (3, 1.5),
    '11': (3, 1)
}

# Draw electron and positron lines to the interaction vertex
ax.annotate('', xy=interaction_vertex, xytext=electron_position,
            arrowprops=dict(facecolor='blue', shrink=0, width=2, headwidth=8))
ax.annotate('', xy=interaction_vertex, xytext=positron_position,
            arrowprops=dict(facecolor='red', shrink=0, width=2, headwidth=8))

# Label the electron and positron
ax.text(*electron_position, 'Electron (e-)', ha='right', va='center', fontsize=12, color='white')
ax.text(*positron_position, 'Positron (e+)', ha='right', va='center', fontsize=12, color='white')

# Draw outcome lines and label them, using the counts as probability amplitudes
for state, position in outcomes_positions.items():
    opacity = measurement_counts[state] / max(measurement_counts.values())  # Opacity based on relative count
    ax.annotate('', xy=position, xytext=interaction_vertex,
                arrowprops=dict(facecolor='green', alpha=opacity, shrink=0, width=2, headwidth=8))
    ax.text(*position, f'{state}: {measurement_counts[state]}', ha='left', va='center', fontsize=10, color='white')

# bg color
fig.patch.set_facecolor('black')
ax.set_facecolor('black')

# Display the Feynman-like diagram
plt. show()