Discussion about this post

User's avatar
Sid's avatar
4dEdited

I took your challenge to an actual quantum computer.

You proposed measuring an electron's spin, then measuring it a second way with a dial nobody reads, then measuring the first way again — predicting that if no conscious being looks at the middle dial, that measurement effectively didn't happen. I ran the quantum core of this on one of IBM's 156-qubit processors.

First, the interference pattern — the signature of a system genuinely in two states at once. On the hardware it came out crisp. The machine is doing real quantum mechanics.

Then I added your unread apparatus: a second quantum bit that couples to the first and records which path it took, but that nobody ever looks at. The interference pattern vanished completely. Flat line. The information being physically recorded somewhere — with no mind near it — was enough to destroy the quantum behavior. Your framework predicts an unread measurement leaves things undisturbed. The hardware says the opposite.

Then the interesting part. I erased that recorded information, again with nobody looking — one automatic operation. The interference pattern came back. No one observed, decided, or acted. A physical operation put the information beyond recovery, and coherence returned on its own.

So what controls collapse isn't whether a mind is watching. It's whether the which-path information is physically recoverable. Record it and you lose the pattern; erase it and you get it back — consciousness never enters either way.

The limit you flagged yourself still holds: the version where the experimenter looks and then acts in the world can't be tested by anyone, because every interpretation gives identical statistics. My run can't touch that. What it shows is that the measurable prediction — unobserved apparatus leaves the system uncollapsed — fails on real hardware.

Fun experiment, and your essay was the reason I ran it. Happy to share the code — it's a two-qubit circuit anyone with a free IBM account can reproduce.

Cheers,

Sid

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

"""Delayed-choice quantum eraser. LOCAL_TEST=True -> Aer; False -> ibm_fez.

Open-plan compatible: uses bare single-job mode (SamplerV2(mode=backend)),

no Session and no Batch, since the open plan forbids sessions (error 1352).

Each circuit is its own job; for a handful of 2-qubit circuits that is fine.

Four conditions vs swept phase phi:

A no marker -> full fringe (coherence present)

B marker, not erased -> flat, no fringe (which-path destroys it)

C erased, post m=0 -> fringe returns

D erased, post m=1 -> complementary fringe (pi shift)

The C/D anti-correlation is the eraser signature: an UNOBSERVED gate erases the

which-path info and the fringe reappears only after sorting on the marker bit.

No observer enters anywhere -- collapse tracks information, not looking.

"""

# ============================ CONFIG =========================================

LOCAL_TEST = False # True = Aer simulator, False = hardware

BACKEND_NAME = "ibm_fez"

INSTANCE_CRN = ("crn:v1:bluemix:public:quantum-computing:us-east:"

"Your ID"

"Your ID")

SHOTS = 4096

POINTS = 5 # phi samples over [0, 2pi]; 5 = cheap, 9 = smooth

CONDITIONS = ["B", "C", "D"] # A already collected on hardware.

# set to ["A","B","C","D"] for all four.

SAVE_JOB_IDS = "eraser_job_ids.txt" # job IDs are appended here as they submit

# =============================================================================

def build_circuit(phi, marker, erase):

from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2)

qc.h(0) # system into a superposition of two paths

qc.p(phi, 0) # tunable relative phase (the fringe axis)

if marker:

qc.cx(0, 1) # copy which-path info onto the marker

if erase:

qc.h(1) # unobserved physical erasure of the marker

qc.h(0) # recombine the paths

qc.measure(0, 0)

qc.measure(1, 1)

return qc

def fringe(counts, postselect=None):

"""P(system=0). Key order is c1 c0, so c0 is the last char."""

n0 = tot = 0

for key, c in counts.items():

b = key.replace(" ", "")

c0, c1 = b[-1], b[-2]

if postselect is not None and int(c1) != postselect:

continue

tot += c

if c0 == "0":

n0 += c

return (n0 / tot if tot else float("nan")), tot

def get_counts(executor, backend, qc, runtime, tag=""):

from qiskit import transpile

tqc = transpile(qc, backend=backend, optimization_level=1) \

if backend is not None else qc

if runtime:

job = executor.run([tqc], shots=SHOTS)

try:

jid = job.job_id()

with open(SAVE_JOB_IDS, "a") as f:

f.write(f"{tag}\t{jid}\n")

print(f" [{tag}] job {jid} submitted")

except Exception:

pass

res = job.result()

try:

return res[0].data.c.get_counts()

except AttributeError:

return list(res[0].data.values())[0].get_counts()

return executor.run(tqc, shots=SHOTS).result().get_counts()

def run(executor, backend, runtime):

import math

phis = [2 * math.pi * k / (POINTS - 1) for k in range(POINTS)]

spec = {

"A": (False, False, None, "no marker -> full fringe"),

"B": (True, False, None, "marked, not erased -> flat"),

"C": (True, True, 0, "erased, post m=0 -> fringe"),

"D": (True, True, 1, "erased, post m=1 -> fringe shifted pi"),

}

header = "cond | " + " | ".join(f"{p/math.pi:.2f}p" for p in phis) + " | contrast"

print(header)

print("-" * len(header))

results = {}

for label in CONDITIONS:

marker, erase, ps, desc = spec[label]

row = []

for i, phi in enumerate(phis):

counts = get_counts(executor, backend,

build_circuit(phi, marker, erase), runtime,

tag=f"{label}_phi{i}")

p0, _ = fringe(counts, postselect=ps)

row.append(p0)

results[label] = row

good = [p for p in row if p == p]

con = (max(good) - min(good)) if good else 0.0

cells = " | ".join(f"{p:.3f}" for p in row)

print(f" {label} | {cells} | {con:.3f} {desc}")

return results, phis

def readout(results, phis):

import statistics

def con(lbl):

if lbl not in results:

return None

g = [p for p in results[lbl] if p == p]

return (max(g) - min(g)) if g else 0.0

print("\n" + "=" * 58)

for lbl, note in [("A", "coherence present"),

("B", "should be ~0"),

("C", "fringe returns"),

("D", "complementary")]:

c = con(lbl)

if c is not None:

print(f" {lbl} contrast {c:.3f} {note}")

if "C" in results and "D" in results:

prod = [(results["C"][i] - 0.5) * (results["D"][i] - 0.5)

for i in range(len(phis))

if results["C"][i] == results["C"][i]

and results["D"][i] == results["D"][i]]

if prod:

print(f"\n C/D anti-correlation {statistics.mean(prod):+.4f} "

"(negative = complementary fringes: the eraser signature)")

def main():

if LOCAL_TEST:

from qiskit_aer import AerSimulator

print("[MODE] ideal Aer simulator")

results, phis = run(AerSimulator(), None, False)

else:

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2

service = QiskitRuntimeService(instance=INSTANCE_CRN)

backend = service.backend(BACKEND_NAME)

print(f"[MODE] hardware {BACKEND_NAME} (open-plan single-job mode)")

print(f"[INSTANCE] ...{INSTANCE_CRN.split('/')[-1][:28]}")

# open plan: no Session, no Batch -- pass the backend as the mode

sampler = SamplerV2(mode=backend)

results, phis = run(sampler, backend, True)

readout(results, phis)

if __name__ == "__main__":

main()

Terminal output

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2

[MODE] hardware ibm_fez (open-plan single-job mode)

[INSTANCE] ...53be0b4019f9455da9e601f21b40

cond | 0.00p | 0.50p | 1.00p | 1.50p | 2.00p | contrast

-------------------------------------------------------

[B_phi0] job d9du9n9htsac739di3ng submitted

[B_phi1] job d9du9oqneu4c739novag submitted

[B_phi2] job d9du9q4jeosc73fi2tug submitted

[B_phi3] job d9du9rineu4c739noveg submitted

[B_phi4] job d9du9t1htsac739di40g submitted

B | 0.519 | 0.475 | 0.503 | 0.513 | 0.516 | 0.043 marked, not erased -> flat

[C_phi0] job d9dua34jeosc73fi2ub0 submitted

[C_phi1] job d9dua4kinv1c73apie30 submitted

[C_phi2] job d9dua64inv1c73apie50 submitted

[C_phi3] job d9dua7sinv1c73apie70 submitted

[C_phi4] job d9dua9cjeosc73fi2uj0 submitted

C | 0.957 | 0.541 | 0.049 | 0.474 | 0.966 | 0.918 erased, post m=0 -> fringe

[D_phi0] job d9duaaqneu4c739np01g submitted

[D_phi1] job d9duackinv1c73apiee0 submitted

[D_phi2] job d9duaecjeosc73fi2uog submitted

[D_phi3] job d9duafsinv1c73apiei0 submitted

[D_phi4] job d9duahaneu4c739np0b0 submitted

D | 0.043 | 0.459 | 0.968 | 0.615 | 0.042 | 0.926 erased, post m=1 -> fringe shifted pi

==========================================================

B contrast 0.043 should be ~0

C contrast 0.918 fringe returns

D contrast 0.926 complementary

C/D anti-correlation -0.1277 (negative = complementary fringes: the eraser signature)

Josh Mitteldorf's avatar

Richard Lucido has done his own experiment which he claims is related to the question whether consciousness collapses the wave function. His is a psychological experiment more than a physics experiment. See if you understand and agree with his logic.

https://www.testingtheccc.com/

16 more comments...

No posts

Ready for more?