I have an open-source-always philosophy. Today, that philosophy led to a 71% fidelity breakthrough on IBM’s 127-qubit Eagle processor. I have an open-source-always philosophy. Today, that philosophy led to a 71% fidelity breakthrough on IBM’s 127-qubit Eagle processor. The Origin Story I’ve been building the Perceptual Grid Engine (PGE) for a while. Originally, it was an architecture for Artificial Intelligence—designed to help models maintain memory consistency and "object permanence" over long context windows. Perceptual Grid Engine (PGE) It is based off of navigational techniques used by blind individuals like myself, as I do everything in a systematic grid-like pattern. I scan from left to right, down, then right to left until I have completed my task. Originally, I saw no reason why AI and now Quantum Computing shouldn’t do the same. This morning, I stared at my architecture diagram and realized something strange. The logic I used to "hand off" memory states in AI looked suspiciously like Quantum Teleportation. Quantum Teleportation So I asked the dangerous question: Can I map my software-defined AI grid onto physical quantum hardware to solve the decoherence problem? Can I map my software-defined AI grid onto physical quantum hardware to solve the decoherence problem? An hour later, I had my answer. I didn't just run a simulation. I ran a Round-Trip Stress Test on ibm_fez (one of IBM’s utility-scale quantum processors). The results shocked me. Round-Trip Stress Test ibm_fez The Problem: Quantum Amnesia In AI, if you lose context, the model hallucinates. In Quantum Computing, if you lose coherence, the qubit becomes noise. Current quantum processors (QPUs) have a "T1 time" (coherence lifetime) of roughly 100-300 microseconds. If your calculation takes longer than that, your data dies. This is the biggest bottleneck in the industry. Most researchers try to solve this with better hardware (shielding, colder fridges). I decided to solve it with better software logic. better software logic The Solution: The Perceptual Grid Engine (PGE) My hypothesis was simple: Don't let the qubit die. Don't let the qubit die. Instead of leaving data in a single qubit (Q0) until it rots, I adapted my PGE logic to "teleport" the state to a fresh qubit (Q2) the moment coherence starts to dip. Then, crucially, I wipe the original qubit clean and send the data back. It’s effectively a Quantum RAM Refresh Cycle, derived entirely from AI consistency logic. Quantum RAM Refresh Cycle The Architecture To make this work on real atoms, I had to use IBM’s latest Qiskit SDK v1.0 and the SamplerV2 primitive. The key was using Dynamic Circuits—specifically the if_test logic. Qiskit SDK v1.0 SamplerV2 Dynamic Circuits if_test This isn't a pre-recorded script. The hardware measures the "dying" qubit mid-flight, makes a classical logic decision (0 or 1), and fires a correction gate ($X$ or $Z$) to the fresh qubit before the data decays. before Here is the "Round Trip" engine that ran on the metal: # The PGE "Ping-Pong" Protocol
# 1. Hop 1: Teleport q0 -> q2
# 2. Reset q0 (Mid-circuit wipe)
# 3. Hop 2: Teleport q2 -> q0 (Return home)

def create_round_trip_circuit():
    qc = QuantumCircuit(qr, crz, crx, result)
    
    # --- HOP 1: OUTBOUND ---
    # Entangle & Teleport to Grid (q2)
    qc.h(1)
    qc.cx(1, 2)
    qc.cx(0, 1)
    qc.h(0)
    qc.measure(0, crz)
    qc.measure(1, crx)
    
    # Real-time Hardware Correction
    with qc.if_test((crx, 1)):
        qc.x(2)
    with qc.if_test((crz, 1)):
        qc.z(2)

    # --- THE CRITICAL STEP: RESET ---
    qc.reset(0) 
    qc.reset(1)
    
    # --- HOP 2: INBOUND ---
    # Teleport back to Home (q0)
    # ... (Repeat logic in reverse) ...
    
    return qc # The PGE "Ping-Pong" Protocol
# 1. Hop 1: Teleport q0 -> q2
# 2. Reset q0 (Mid-circuit wipe)
# 3. Hop 2: Teleport q2 -> q0 (Return home)

def create_round_trip_circuit():
    qc = QuantumCircuit(qr, crz, crx, result)
    
    # --- HOP 1: OUTBOUND ---
    # Entangle & Teleport to Grid (q2)
    qc.h(1)
    qc.cx(1, 2)
    qc.cx(0, 1)
    qc.h(0)
    qc.measure(0, crz)
    qc.measure(1, crx)
    
    # Real-time Hardware Correction
    with qc.if_test((crx, 1)):
        qc.x(2)
    with qc.if_test((crz, 1)):
        qc.z(2)

    # --- THE CRITICAL STEP: RESET ---
    qc.reset(0) 
    qc.reset(1)
    
    # --- HOP 2: INBOUND ---
    # Teleport back to Home (q0)
    # ... (Repeat logic in reverse) ...
    
    return qc The Receipts: 71.9% Fidelity on ibm_fez ibm_fez I didn't want to rely on a simulator. Simulators are perfect; reality is noisy. I queued the job on the IBM Quantum Platform. The Test: The Test: Initialize: Create a specific unbalanced superposition state on Q0 (Rx Rotation $\pi/3$) creating a target distribution of roughly 75% $|0\rangle$ / 25% $|1\rangle$.
Execute: Run the full Round-Trip circuit (Teleport $\rightarrow$ Reset $\rightarrow$ Return).
Measure: Check if the data survived the loop. Initialize: Create a specific unbalanced superposition state on Q0 (Rx Rotation $\pi/3$) creating a target distribution of roughly 75% $|0\rangle$ / 25% $|1\rangle$. Initialize: 75% $|0\rangle$ / 25% $|1\rangle$ Execute: Run the full Round-Trip circuit (Teleport $\rightarrow$ Reset $\rightarrow$ Return). Execute: Measure: Check if the data survived the loop. Measure: The Results: The Results: Hardware Target: ibm_fez (127-qubit Eagle Processor)
Single Hop Fidelity: 74.5% (Theoretical Max: 75.0%)
Round Trip Fidelity: 71.9% Hardware Target: ibm_fez (127-qubit Eagle Processor) Hardware Target: ibm_fez Single Hop Fidelity: 74.5% (Theoretical Max: 75.0%) Single Hop Fidelity: 74.5% Round Trip Fidelity: 71.9% Round Trip Fidelity: 71.9% Job ID: d4usjvcgk3fc73auamsg (Publicly verifiable on IBM Quantum) Job ID: d4usjvcgk3fc73auamsg I expected the signal to drop to 50% (random noise) after the second hop. Instead, it stayed rock solid. We lost less than 3% fidelity after doubling the circuit depth and adding a hardware reset. 3% Why This Matters I didn't invent quantum teleportation (physics did that in 1993). But I believe this is one of the first demonstrations of a Software-Defined Quantum Memory derived from AI principles. Software-Defined Quantum Memory By treating physical qubits not as "registers" but as "disposable containers" that can be refreshed via teleportation loops, the Perceptual Grid Engine effectively extends the lifespan of quantum data. We are moving from "Static Quantum Computing" to "Dynamic, Self-Healing Quantum Computing." Perceptual Grid Engine What's Next? This proved that the PGE is substrate-independent. It works on neural networks, and it works on superconducting transmon qubits. PGE I’m open-sourcing the entire codebase today. If you have an IBM Quantum account (even the free tier), you can clone the repo and run the Grid Handoff yourself. https://github.com/damianwgriggs/Perceptual-Grid-Engine-Quantum-Experiment AI PGE Memory Article: https://medium.com/@dgriggsde/the-engine-of-creation-unleashed-why-im-giving-away-the-ai-that-writes-marathon-stories-1b4b13107213

Quant

I Ported My AI "Perceptual Grid Engine" to a Quantum Processor (and it Survived)

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Experiment Log: Validating Echo-Stabilized Recursive Routing on IBM Heron

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

100 Days of AI Day 1: From Newsletter to Podcast, Leveraging AI for Audio Transformation

Experiment Log: Validating Echo-Stabilized Recursive Routing on IBM Heron

The Noonification: How Often Do NFTs Pass The Howey Test? (1/13/2023)

Darwin's Hybrid Intelligence to Align AI & Human Goals for Startups & VCs

The Noonification: White Man (11/26/2022)

The Noonification: The Metaverse is a Sh*tshow (11/2/2022)

100 Days of AI Day 1: From Newsletter to Podcast, Leveraging AI for Audio Transformation

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps