Exploring Entanglement Dynamics in Curved Spacetime Under the Influence of the Superforce '(c^4)/G' as proposed by Salvatore Pais on IBM's 127-Qubit Quantum Computer

The Heatmap of State Probabilities Across Distortions above (code below) shows the gradual loss of entanglement as distortions increase. The brighter colors for ∣10⟩ and ∣01⟩ at low distortions show the robustness of entanglement, while the dimming at higher distortions reveals coherence loss. At f = 0.1, ∣10⟩ and ∣01⟩ dominate at lower distortion strengths. At f = 0.5, probabilities become more evenly distributed, with noticeable contributions from ∣00⟩ and ∣11⟩. At f = 1.0, probabilities drop significantly, showing a transition to a mixed state.
The 3D Surface Plot of State Probabilities above (code below) adds depth to the heatmap analysis, showing how distortions create valleys and plateaus in the state probabilities. The flattening surface at higher distortions shows the system’s transition to a mixed state. Peaks are visible for ∣10⟩ and ∣01⟩ at lower distortions, signifying their dominance. As distortions increase, the surface flattens, indicating a more uniform distribution of probabilities across all states.
The Heatmap of Asymmetry Across Distortions above (code below) shows the asymmetry dynamics, with brighter colors indicating higher asymmetry. The peak at moderate distortions suggests that this is the critical point where directional effects are strongest. Asymmetry between ∣10⟩ and ∣01⟩ probabilities is low at f = 0.1. The asymmetry peaks at f = 0.5, indicating a strong directional bias introduced by the distortions. At f = 1.0, asymmetry decreases again, signaling a transition to a mixed state.
The 3D Surface Plot of Entanglement Entropy above (code below) shows the dynamic evolution of entropy, and the critical points of entanglement breakdown. Peaks in the plot correspond to the maximum randomness introduced by distortions. Entropy is low at f = 0.1, consistent with strong entanglement and low randomness. Entropy increases sharply at f = 0.5, showing significant coherence loss and state mixing. At f = 1.0, entropy stabilizes at a high value, marking the transition to a fully mixed state.
In the end, this experiment investigated the dynamics of quantum entanglement under spacetime inspired distortions modeled by fractions of the theoretical Superforce (c^4)/G, as proposed by Salvatore Pais. By creating Bell states and introducing distortions through controlled quantum gate manipulations, this circuit analyzed the effects of weak, moderate, and strong distortions (f = 0.1, 0.5, 1.0) on entanglement entropy, state probabilities, and asymmetry. Results showed that weak distortions preserved entanglement, as shown by high entangled state probabilities and low entropy. Moderate distortions (f = 0.5) marked a critical transition, with significant coherence loss and asymmetry, while strong distortions (f = 1.0) led to a mixed state characterized by uniform probabilities and high entropy. For (c^4)/G, this means that it can act as a natural scaling framework to explore the fragility of quantum systems in extreme conditions. The experiment shows that spacetime curvature, or analogous forces on the scale of (c^4)/G, can significantly disrupt entanglement and coherence.

Code:

# Imports
import numpy as np
import json
import pandas as pd
import logging
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerV2
from qiskit.visualization import plot_histogram
from scipy.linalg import expm
import matplotlib.pyplot as plt

# Logging
logging.basicConfig(level=logging. INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Load calibration data
def load_calibration_data(file_path):
    logger. info("Loading calibration data from %s", file_path)
    calibration_data = pd. read_csv(file_path)
    calibration_data.columns = calibration_data.columns.str.strip()
    logger. info("Calibration data loaded successfully")
    return calibration_data

# Select best qubits
def select_best_qubits(calibration_data, n_qubits):
    logger. info("Selecting the best qubits based on T1, T2, and error rates")
    qubits_sorted = calibration_data.sort_values(by=['\u221ax (sx) error', 'T1 (us)', 'T2 (us)'], ascending=[True, False, False])
    best_qubits = qubits_sorted['Qubit'].head(n_qubits).tolist()
    logger. info("Selected qubits: %s", best_qubits)
    return best_qubits

# Load most recent calibration data
calibration_file = '/Users/Downloads/ibm_sherbrooke_calibrations_2025-01-06T17_46_19Z.csv'
calibration_data = load_calibration_data(calibration_file)

# Select best qubits for the experiment
n_qubits = 2
best_qubits = select_best_qubits(calibration_data, n_qubits)

# IBMQ 
logger. info("Setting up IBM Q service")
service = QiskitRuntimeService(
    channel='ibm_quantum',
    instance='ibm-q/open/main',
    token='YOUR_IBMQ_API_KEY_O-`'  
)

backend_name = 'ibm_sherbrooke'
backend = service.backend(backend_name)
logger. info("Backend selected: %s", backend_name)

# Quantum and classical registers
qr = QuantumRegister(n_qubits, 'q')
cr = ClassicalRegister(n_qubits, 'c')

# Superforce constant
c = 3e8  # Speed of light (m/s)
G = 6.67430e-11  # Gravitational constant (m^3 kg^-1 s^-2)
superforce = c**4 / G  # Maximum theoretical force (N)
logger. info("Superforce value: %e N", superforce)

# A distortion function based on the Superforce
def spacetime_distortion_with_superforce(qc, qubit, force_fraction):
    """Apply spacetime distortion proportional to a fraction of the superforce."""
    distortion_strength = force_fraction * superforce
    # Scale the distortion strength for the quantum circuit gates
    scaled_angle = distortion_strength / (1e30) 
    qc.rx(scaled_angle * np.pi / 4, qubit)
    qc.rz(scaled_angle * np.pi / 3, qubit)
    qc.ry(scaled_angle * np.pi / 5, qubit)
    logger. info("Applied spacetime distortion with scaled angle: %f", scaled_angle)

# Noise model 
def apply_force_scaled_noise(qc, qubit, force_fraction):
    """Apply noise scaled to the fraction of the superforce."""
    noise_strength = force_fraction * superforce
    scaled_noise = noise_strength / (1e30)  
    qc.rx(scaled_noise * np.pi / 2, qubit)
    qc.ry(scaled_noise * np.pi / 4, qubit)
    logger. info("Applied noise to qubit %s with scaled noise: %f", qubit, scaled_noise)

# Apply distortions and save results 
distortion_strengths = [0.1, 0.5, 1.0]
for fraction in distortion_strengths:
    # Create a fresh quantum circuit for each distortion strength
    qc = QuantumCircuit(qr, cr)
    
    # Create Bell state
    qc.h(qr[0])
    qc. cx(qr[0], qr[1])
    
    # Apply spacetime distortion
    spacetime_distortion_with_superforce(qc, qr[1], fraction)
    
    # Apply noise 
    apply_force_scaled_noise(qc, qr[1], fraction)
    
    # Measure 
    qc.measure(qr, cr)
    
    # Transpile 
    qc_transpiled = transpile(qc, backend=backend, optimization_level=3)
    
    # Execute 
    with Session(service=service, backend=backend) as session:
        sampler = SamplerV2(session=session)
        logger. info("Executing the circuit on the backend for distortion strength: %f", fraction)
        job = sampler. run([qc_transpiled], shots=16384)
        job_result = job.result()
    
        # Extract counts
        data_bin = job_result._pub_results[0]['__value__']['data']
        if 'c' in data_bin:
            counts = data_bin['c'].get_counts()
        else:
            raise KeyError("No valid key found in data_bin to extract counts.")
        
        # Save results to separate Jsons 
        results_data = {
            "distortion_strength": fraction,
            "raw_counts": counts
        }
        output_file = f'/Users/Documents/Entanglement_Dynamics_Curved_Spacetime_SF_{fraction}.json'
        with open(output_file, 'w') as f:
            json.dump(results_data, f, indent=4)
        logger. info(f"Results for distortion {fraction} saved to {output_file}")

////////////////////
Code For all Visuals from Run Data
# Imports
import json
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Load run results
file_paths = [
    '/Users/Documents/Entanglement_Dynamics_Curved_Spacetime_SF_0.1.json',
    '/Users/Documents/Entanglement_Dynamics_Curved_Spacetime_SF_0.5.json',
    '/Users/Documents/Entanglement_Dynamics_Curved_Spacetime_SF_1.0.json'
]

# Distortion strengths corresponding to the file paths
distortion_strengths = [0.1, 0.5, 1.0]

# Load run data
results = []
for path in file_paths:
    with open(path, 'r') as f:
        results.append(json.load(f))

# Extract raw counts and normalize probabilities for each distortion strength
state_labels = list(results[0]["raw_counts"].keys())
probabilities = []
entropies = []
asymmetries = []
cumulative_entangled_probs = []
probability_ratios = []
coherence_losses = []

for result in results:
    counts = np.array(list(result["raw_counts"].values()))
    total_counts = counts.sum()
    probs = counts / total_counts
    probabilities.append(probs)
    
    # Entropy
    entropy = -np.sum(probs * np.log2(probs + 1e-10))  # Avoid log(0)
    entropies.append(entropy)

    # Cumulative probabilities of entangled states
    entangled_prob = probs[state_labels.index("10")] + probs[state_labels.index("01")]
    cumulative_entangled_probs.append(entangled_prob)
    
    # Probability ratio between |10> and |01>
    prob_ratio = probs[state_labels.index("10")] / (probs[state_labels.index("01")] + 1e-10)  # Avoid division by 0
    probability_ratios.append(prob_ratio)
    
    # Coherence loss (difference between entangled and non-entangled probabilities)
    coherence_loss = abs(entangled_prob - (probs[state_labels.index("00")] + probs[state_labels.index("11")]))
    coherence_losses.append(coherence_loss)
    
    # Asymmetry
    asymmetry = abs(probs[state_labels.index("10")] - probs[state_labels.index("01")])
    asymmetries.append(asymmetry)

# Convert probabilities to a numpy array for easier manipulation
probabilities = np.array(probabilities)
asymmetries = np.array(asymmetries)
entropies = np.array(entropies)

# State Probability Distribution for Each Distortion
plt.figure(figsize=(10, 6))
for i, (f, probs) in enumerate(zip(distortion_strengths, probabilities)):
    plt. bar(np.arange(len(state_labels)) + i * 0.25, probs, width=0.25, label=f"f = {f}")
plt.xticks(np.arange(len(state_labels)) + 0.25, state_labels)
plt.xlabel('States')
plt.ylabel('Probability')
plt.title('State Probability Distribution Across Distortions')
plt.legend()
plt.grid(axis='y', linestyle='--', alpha=0.6)
plt. show()

# Asymmetry Across Distortions
plt.figure(figsize=(8, 5))
plt.plot(distortion_strengths, asymmetries, marker='o', color='orange', label="Asymmetry")
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Asymmetry (|P(|10⟩) - P(|01⟩)|)')
plt.title('Asymmetry Across Distortion Strengths')
plt.grid(linestyle='--', alpha=0.6)
plt.legend()
plt. show()

# Entanglement Entropy Across Distortions
plt.figure(figsize=(8, 5))
plt.plot(distortion_strengths, entropies, marker='o', color='green', label="Entropy")
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Entropy (bits)')
plt.title('Entanglement Entropy Across Distortion Strengths')
plt.grid(linestyle='--', alpha=0.6)
plt.legend()
plt. show()

# State Evolution Across Distortions
plt.figure(figsize=(10, 6))
width = 0.25
for i, state in enumerate(state_labels):
    plt. bar(np.arange(len(distortion_strengths)) + i * width, probabilities[:, i], width=width, label=state)
plt.xticks(np.arange(len(distortion_strengths)) + 0.5 * width, [f"f = {f}" for f in distortion_strengths])
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Probability')
plt.title('State Evolution Across Distortion Strengths')
plt.legend()
plt.grid(axis='y', linestyle='--', alpha=0.6)
plt. show()

# Cumulative Probability of Entangled States
plt.figure(figsize=(8, 5))
plt.plot(distortion_strengths, cumulative_entangled_probs, marker='o', color='blue', label="Cumulative Entangled Prob.")
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Cumulative Probability')
plt.title('Cumulative Probability of Entangled States')
plt.grid(linestyle='--', alpha=0.6)
plt.legend()
plt. show()

# Probability Ratios (|10⟩ / |01⟩)
plt.figure(figsize=(8, 5))
plt.plot(distortion_strengths, probability_ratios, marker='o', color='purple', label="Probability Ratio |10⟩ / |01⟩")
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Ratio')
plt.title('Probability Ratios (|10⟩ / |01⟩) Across Distortions')
plt.grid(linestyle='--', alpha=0.6)
plt.legend()
plt. show()

# Entropy Change Rate
entropy_change_rate = np.gradient(entropies, distortion_strengths)  # Derivative of entropy
plt.figure(figsize=(8, 5))
plt.plot(distortion_strengths, entropy_change_rate, marker='o', color='green', label="Entropy Change Rate")
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Change Rate')
plt.title('Rate of Entropy Change Across Distortions')
plt.grid(linestyle='--', alpha=0.6)
plt.legend()
plt. show()

# State Coherence Analysis
plt.figure(figsize=(8, 5))
plt.plot(distortion_strengths, coherence_losses, marker='o', color='orange', label="State Coherence Loss")
plt.xlabel('Distortion Strength (f)')
plt.ylabel('Coherence Loss')
plt.title('State Coherence Analysis Across Distortions')
plt.grid(linestyle='--', alpha=0.6)
plt.legend()
plt. show()

# Heatmap of State Probabilities
plt.figure(figsize=(10, 6))
plt.imshow(probabilities.T, cmap='viridis', aspect='auto', interpolation='nearest', 
           extent=[distortion_strengths[0], distortion_strengths[-1], 0, len(state_labels)])
plt.colorbar(label='Probability')
plt.yticks(np.arange(len(state_labels)), state_labels)
plt.xlabel('Distortion Strength (f)')
plt.ylabel('States')
plt.title('Heatmap of State Probabilities Across Distortions')
plt. show()

# 3D Surface Plot of State Probabilities
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(distortion_strengths, np.arange(len(state_labels)))
Z = probabilities.T
ax.plot_surface(X, Y, Z, cmap='plasma', edgecolor='k', linewidth=0.3)
ax.set_xticks(distortion_strengths)
ax.set_xticklabels([f"f = {f}" for f in distortion_strengths])
ax.set_yticks(np.arange(len(state_labels)))
ax.set_yticklabels(state_labels)
ax.set_xlabel('Distortion Strength (f)')
ax.set_ylabel('States')
ax.set_zlabel('Probability')
ax.set_title('3D Surface Plot of State Probabilities')
plt. show()

# Heatmap of Asymmetry
plt.figure(figsize=(10, 6))
asymmetry_matrix = np.tile(asymmetries, (len(state_labels), 1)).T
plt.imshow(asymmetry_matrix, cmap='coolwarm', aspect='auto', interpolation='nearest', 
           extent=[distortion_strengths[0], distortion_strengths[-1], 0, len(state_labels)])
plt.colorbar(label='Asymmetry')
plt.yticks([])
plt.xlabel('Distortion Strength (f)')
plt.title('Heatmap of Asymmetry Across Distortions')
plt. show()

# 3D Surface Plot of Entanglement Entropy
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(distortion_strengths, [0])  # Single layer for entropy
Z = np.tile(entropies, (1, len(state_labels))).T
ax.plot_surface(X, Y, Z, cmap='cividis', edgecolor='k', linewidth=0.3)
ax.set_xticks(distortion_strengths)
ax.set_xticklabels([f"f = {f}" for f in distortion_strengths])
ax.set_yticks([])
ax.set_zticks(np.linspace(min(entropies), max(entropies), 5))
ax.set_xlabel('Distortion Strength (f)')
ax.set_ylabel('Entropy Layer')
ax.set_zlabel('Entropy (bits)')
ax.set_title('3D Surface Plot of Entanglement Entropy')
plt. show()

# End