The Cost of Garbage: Why We Must Clean “Junk Bits”

The Hidden Witness

Why You Must Clean Up “Junk Bits” with Uncomputation

1. The “Observer” Effect

In quantum computing, anything that “knows” what a qubit is doing acts as a Witness. Leftover data (Junk Bits) on an ancilla qubit act as witnesses, destroying the interference your algorithm needs to work.

Case A: Ideal (No Junk)

H
H
|0>
|0>

100% Interference

Case B: Broken (With Junk)

H
+
H
|0>
|0>
?
|junk>

Random 50/50 Noise

2. Mathematical Working

Ideal Case: (1/2) ( |0> + |1> + |0> – |1> ) = |0>
(Identical paths cancel perfectly.)

Junk Case: (1/2) ( |00> + |10> + |01> – |11> )
(Terms cannot cancel because the ancilla bit is different. Interference is destroyed.)

3. The Solution: Uncomputation

To restore interference, we follow the Compute-Copy-Uncompute pattern. This resets our ancilla to |0> and removes the “witness.”

Input |x>
Ancilla |0>
Target |0>
COMPUTE
+
UNCOMPUTE
|x> (Clean)
|0> (Clean)
|f(x)> (Result)

4. Qiskit Implementation

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

qc = QuantumCircuit(3)
qc.h(0) 
qc.cx(0, 1) # COMPUTE: Create Junk on q1
qc.cx(1, 2) # COPY Result to q2
qc.cx(0, 1) # UNCOMPUTE: Clean Junk back to |0>
qc.h(0)     # Interference Restored!

qc.measure_all()
counts = AerSimulator().run(transpile(qc, AerSimulator())).result().get_counts()
print(f"Resulting state: {counts}")

Built with Qiskit 1.x • Quantum Series 2025

Reversible Computation in Quantum Computing

Reversible Computation in Quantum Computing

Mastering Reversibility, Ancilla Bits, and Unitary Logic

1. The Necessity of Reversibility

In classical logic, gates like AND are irreversible. In quantum computing, all operations must be Unitary ($U^{\dagger}U = I$), meaning they are perfectly reversible. Information is never lost; it is simply transformed.

AND
Out: ?

Information Loss: You cannot reconstruct inputs from the output.

2. Ancilla Bits & Uncomputation

Because we cannot erase information, we use Ancilla bits as temporary “scratch space.” However, if these qubits are left in an arbitrary state, they remain entangled with the computation. Uncomputation (running gates in reverse) resets them to |0>, “cleaning” the quantum workspace.

The Toffoli Gate (CCX)

The Toffoli gate is reversible because its mapping is bijective. No two inputs result in the same output.

Input (A, B, C) Output (A, B, C ⊕ AB) Status
0, 0, 00, 0, 0Unique
1, 1, 01, 1, 1Flipped (AND)
1, 1, 11, 1, 0Flipped Back

The Fredkin Gate (CSWAP)

In: C
In: T1
In: T2

3. Mathematics: Unitary vs. Hermitian

Proof: Is Pauli-Y Unitary?

Y =
0i
i0
Y =
0i
i0

Pauli-Y is Unitary (YY = I). Because Y = Y, it is also Hermitian.

Unitary but NOT Hermitian: The S Gate

S =
10
0i
S =
10
0i

Since SS, you must apply the S-Dagger gate to reverse an S rotation.

4. Qiskit Verification

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

qc = QuantumCircuit(3)
qc.x([0, 1]) # Controls to |1>

# Toffoli is Hermitian (U = U†), so applying it twice cleans the ancilla
qc.ccx(0, 1, 2) # Calculation step
qc.ccx(0, 1, 2) # Uncomputation step

qc.measure_all()
counts = AerSimulator().run(transpile(qc, AerSimulator())).result().get_counts()
print(f"Resulting state: {counts}") # Expect {'011': 1024}
            

Built with Qiskit 1.x • Quantum Series 2025

Deutsch Algorithm Revisited: Quantum vs Classical Implementation in Qiskit

Deutsch Algorithm Revisited: Quantum vs Classical Implementation in Qiskit

A practical comparison showing the quantum advantage with working code

Introduction

In the previous post on the Deutsch algorithm, we explored the theoretical foundations of this groundbreaking quantum algorithm. Today, we’re taking it further by implementing both the quantum and classical approaches in Qiskit, allowing us to see the quantum advantage in action.

This hands-on implementation demonstrates why the Deutsch algorithm is considered the first example of quantum computational superiority—solving a problem with fewer oracle queries than any classical algorithm can achieve.

The Challenge

Given a black-box function f: {0,1} → {0,1}, determine whether it is:

  • Constant: f(0) = f(1) (always returns 0 or always returns 1)
  • Balanced: f(0) ≠ f(1) (returns 0 for one input, 1 for the other)
🔑 Key Question: How many times must we query the function?
  • Classical: 2 queries required
  • Quantum: 1 query required

Complete Qiskit Implementation

Oracle Functions

First, we create the oracle functions representing all possible single-bit Boolean functions:

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator

def create_constant_oracle(constant_value):
    """Creates a constant oracle (returns 0 or 1 for all inputs)"""
    oracle = QuantumCircuit(2, name=f"Constant_{constant_value}")
    if constant_value == 1:
        oracle.x(1)  # Flip the output qubit
    return oracle

def create_balanced_oracle(balance_type):
    """Creates a balanced oracle"""
    oracle = QuantumCircuit(2, name=f"Balanced_{balance_type}")
    if balance_type == 'identity':
        # f(x) = x
        oracle.cx(0, 1)
    elif balance_type == 'negation':
        # f(x) = NOT x
        oracle.x(0)
        oracle.cx(0, 1)
        oracle.x(0)
    return oracle

Classical Approach: Two Queries Required

The classical algorithm must query the oracle twice—once for f(0) and once for f(1):

def classical_deutsch_query1(oracle):
    """First query: Evaluate f(0)"""
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(1, 'c')
    qc = QuantumCircuit(qr, cr)
    
    # Input: x = 0 (already initialized to |0⟩)
    qc.barrier()
    qc.compose(oracle, inplace=True)
    qc.barrier()
    qc.measure(1, 0)  # Measure output to get f(0)
    
    return qc

def classical_deutsch_query2(oracle):
    """Second query: Evaluate f(1)"""
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(1, 'c')
    qc = QuantumCircuit(qr, cr)
    
    qc.x(0)  # Input: x = 1
    qc.barrier()
    qc.compose(oracle, inplace=True)
    qc.barrier()
    qc.measure(1, 0)  # Measure output to get f(1)
    
    return qc

Quantum Approach: One Query Suffices

The quantum Deutsch algorithm uses superposition and interference to determine the answer with a single oracle query:

def deutsch_algorithm(oracle):
    """Implements the Deutsch algorithm - requires only ONE query"""
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(1, 'c')
    qc = QuantumCircuit(qr, cr)
    
    # Step 1: Initialize q[1] to |1⟩
    qc.x(1)
    qc.barrier()
    
    # Step 2: Apply Hadamard gates (create superposition)
    qc.h(0)
    qc.h(1)
    qc.barrier()
    
    # Step 3: Apply the oracle (SINGLE QUERY!)
    qc.compose(oracle, inplace=True)
    qc.barrier()
    
    # Step 4: Apply Hadamard to input qubit
    qc.h(0)
    qc.barrier()
    
    # Step 5: Measure
    qc.measure(0, 0)
    
    return qc

Running the Comparison

Now let’s test all four possible oracles with both approaches:

oracles = [
    ("Constant 0", create_constant_oracle(0)),
    ("Constant 1", create_constant_oracle(1)),
    ("Balanced (Identity)", create_balanced_oracle('identity')),
    ("Balanced (Negation)", create_balanced_oracle('negation'))
]

simulator = AerSimulator()

for name, oracle in oracles:
    # Classical: 2 queries
    qc1 = classical_deutsch_query1(oracle)
    result1 = simulator.run(qc1, shots=1).result()
    f_0 = int(list(result1.get_counts().keys())[0])
    
    qc2 = classical_deutsch_query2(oracle)
    result2 = simulator.run(qc2, shots=1).result()
    f_1 = int(list(result2.get_counts().keys())[0])
    
    classical_result = "CONSTANT" if f_0 == f_1 else "BALANCED"
    
    # Quantum: 1 query
    qc_quantum = deutsch_algorithm(oracle)
    result_quantum = simulator.run(qc_quantum, shots=1000).result()
    counts = result_quantum.get_counts()
    
    quantum_result = "CONSTANT" if '0' in counts else "BALANCED"
    
    print(f"{name}: Classical={classical_result}, Quantum={quantum_result}")

Circuit Diagrams

Below are visual representations of the three circuit implementations. The classical approach requires two separate queries, while the quantum approach accomplishes the same task with a single query.

Classical Query 1: Evaluating f(0)

q[0]:
q[1]:
|0⟩
|0⟩
Oracle (Constant_0)
f(0)

Classical Query 1: Input qubit q[0] remains in state |0⟩ → Oracle processes the input → Output qubit q[1] is measured to obtain f(0)

Classical Query 2: Evaluating f(1)

q[0]:
q[1]:
|0⟩
|0⟩
X
|1⟩
Oracle (Constant_0)
f(1)

Classical Query 2: X gate flips q[0] from |0⟩ to |1⟩ → Oracle processes the input → Output qubit q[1] is measured to obtain f(1)

Quantum Deutsch Algorithm (Single Query)

q[0]:
q[1]:
|0⟩
|0⟩
X
H
H
Oracle (Constant_0)
H
0 or 1

Quantum Deutsch: Initialize |01⟩ → Hadamard gates create superposition → Oracle query (single query!) → Final Hadamard on q[0] → Measure q[0] to determine function type

💡 Understanding the Circuit Elements

🔵 Oracle Box: Represents the black-box function we’re querying

🟠 H Gates: Hadamard gates create quantum superposition

🔴 X Gates: Flip qubit states (NOT gate)

📊 Measurement: Extracts classical information from qubits

📏 Qubit Lines: Horizontal lines represent quantum bits

📍 Input/Output: |0⟩, |1⟩ show quantum states

🔍 Key Observation

Notice that the classical circuits measure the output qubit (q[1]) to get the function values f(0) and f(1), while the quantum circuit measures the input qubit (q[0]) after interference. This fundamental difference allows the quantum algorithm to extract global properties of the function with a single query!

Sample Output

======================================================================
Testing: Constant 0 Oracle
======================================================================

[CLASSICAL APPROACH - Requires 2 queries]
  Query 1: f(0) = 0
  Query 2: f(1) = 0
  Result: Function is CONSTANT
  Total queries needed: 2

[QUANTUM APPROACH - Requires only 1 query]
  Measurement results: {'0': 1000}
  Result: Function is CONSTANT
  Total queries needed: 1

  ✓ Both methods agree: True

======================================================================
Testing: Balanced (Identity) Oracle
======================================================================

[CLASSICAL APPROACH - Requires 2 queries]
  Query 1: f(0) = 0
  Query 2: f(1) = 1
  Result: Function is BALANCED
  Total queries needed: 2

[QUANTUM APPROACH - Requires only 1 query]
  Measurement results: {'1': 1000}
  Result: Function is BALANCED
  Total queries needed: 1

  ✓ Both methods agree: True

Understanding the Quantum Advantage

Classical Approach

  • Evaluate f(0) explicitly
  • Evaluate f(1) explicitly
  • Compare the two results
  • 2 queries required

Must check both inputs individually

Quantum Approach

  • Query with superposition of both inputs
  • Use interference to extract global property
  • Measure to get answer
  • 1 query required

Exploits quantum parallelism

🎯 The Key Insight

The quantum algorithm queries the oracle with a superposition of both inputs simultaneously (|0⟩ + |1⟩), then uses quantum interference to extract global properties of the function without ever evaluating it on individual inputs. The measurement result directly tells us whether the function is constant or balanced.

Measurement Interpretation

Measurement Result Function Type Explanation
|0⟩ Constant Constructive interference – f(0) ⊕ f(1) = 0
|1⟩ Balanced Destructive interference – f(0) ⊕ f(1) = 1

Running the Code

To run this code yourself, you’ll need to install Qiskit:

pip install qiskit qiskit-aer

The complete code is available as a Python script that you can run directly. It will output the comparison for all four oracle types and display the results.

Conclusion

This implementation demonstrates the Deutsch algorithm’s quantum advantage in concrete terms:

  • Quantum speedup: 2x reduction in oracle queries (from 2 to 1)
  • First proof of concept: First algorithm to show quantum advantage over classical
  • Foundational technique: Introduces key quantum concepts (superposition, interference, phase kickback)

While the speedup may seem modest for this toy problem, the techniques demonstrated here—querying a function with superposition and extracting global properties through interference—scale to more complex algorithms like Deutsch-Jozsa, Simon’s algorithm, and ultimately Shor’s algorithm for factoring.

🚀 Next Steps:
  • Experiment with the code and modify the oracles
  • Try visualizing the quantum states at each step
  • Explore the Deutsch-Jozsa algorithm (generalization to n-bit functions)
  • Study the mathematical foundations of quantum interference

Have questions or want to discuss quantum algorithms? Drop a comment below!

Happy quantum coding! 🎯⚛️

Deutsch’s Algorithm in Quantum Computing: The 4 Cases

Deutsch’s Algorithm: Complete Guide

From Initialization to Measurement.

Deutsch’s Algorithm determines if a function f(x) is Constant or Balanced using only a single query. First, we examine how these functions are physically built.

The 4 Possible Functions

In these examples, we set the bottom input to 0 so the output is exactly f(x).

1. Constant Zero Function: f(x) = 0
x
0
Identity (No Gates)
2. Constant One Function: f(x) = 1
X
3. Balanced ID Function: f(x) = x
+
4. Balanced NOT Function: f(x) = ¬x
+
X

The General Oracle (Uf)

x
y
Uf
x
y ⊕ f(x)

The Complete Circuit

To detect the function type, we initialize the bottom wire to |1⟩ and use Hadamard gates to create superposition.

|0⟩
|1⟩
H
H
Uf
KICKBACK ↑
H
|ψ₀⟩
|ψ₁⟩
|ψ₂⟩

Mathematical Proof

1. Initialization: |ψ₀⟩ = |0⟩|1⟩

2. Superposition: |ψ₁⟩ = |+⟩|-⟩ = ½(|0⟩+|1⟩)(|0⟩-|1⟩)

3. The Kickback Effect: Applying Uf to |x⟩|-⟩ results in:
Uf |x⟩|-⟩ = (-1)f(x) |x⟩|-⟩

This means the output of the function is shifted into the phase of the first qubit.

4. Global State |ψ₂⟩:
|ψ₂⟩ = 1/√2 [ (-1)f(0)|0⟩ + (-1)f(1)|1⟩ ] ⊗ |-⟩

Final Measurement

If f(0) = f(1) (Constant) → State is ±|+⟩ → Measure 0
If f(0) ≠ f(1) (Balanced) → State is ±|-⟩ → Measure 1

Understanding Phase Kickback in Quantum Computing

How the target controls the controller.

In standard classical logic, a Control Bit dictates what happens to a target. However, in quantum mechanics, the relationship is symmetric. When the target qubit is in an eigenstate of the operator, the phase is “kicked back” to the control qubit.

|+⟩
|−⟩
|−⟩
|−⟩
CNOT CIRCUIT

Notice above: The Target qubit remains unchanged (|−⟩), but the Control qubit flips from |+⟩ to |−⟩.

STEP 1: DEFINE INITIAL STATE

0⟩ = |+⟩ ⊗ |−⟩

= (1/√2) (|0⟩ + |1⟩)  ⊗  (1/√2) (|0⟩ − |1⟩)

STEP 2: EXPAND TERMS

Multiplying coefficients gives 1/2:
0⟩ = ½ [ |00⟩ − |01⟩ + |10⟩ − |11⟩ ]

STEP 3: APPLY CNOT GATE

Target flips (0↔1) only if Control is 1:
1⟩ = ½ [ |00⟩ − |01⟩ + |11⟩ − |10⟩ ]

STEP 4: FACTOR & REARRANGE

Group terms by the control qubit:
1⟩ = ½ [ |0⟩(|0⟩ − |1⟩) − |1⟩(|0⟩ − |1⟩) ]
∴ |ψ1⟩ = |−⟩ ⊗ |−⟩

Why is this important?

The math shows that while we applied the gate to the target, the relative phase of the control qubit changed from positive to negative. This mechanism is the foundation of quantum algorithms like Shor’s and Grover’s.

Introduction to Quantum Computing: Qubits, Hadamard Gates, and Superposition

What Makes Quantum Computing Different?

Classical computers process information using bits that exist in one of two states: 0 or 1. Quantum computers, however, leverage the strange and powerful principles of quantum mechanics to process information in fundamentally different ways. At the heart of this difference lies the qubit (quantum bit) and quantum gates like the Hadamard gate that manipulate these qubits.

Understanding the Qubit

A qubit is the basic unit of quantum information. Unlike classical bits, qubits can exist in a superposition of states, meaning they can be in state |0⟩, state |1⟩, or any quantum combination of both simultaneously.

Mathematical Representation

We represent qubit states using Dirac notation (bra-ket notation):

|0⟩ state:

1
0

|1⟩ state:

0
1

A general qubit state can be written as:

|ψ⟩ = α|0⟩ + β|1⟩

where α and β are complex numbers called probability amplitudes, and they must satisfy the normalization condition:

|α|² + |β|² = 1

When we measure a qubit in this state, we get:

  • |0⟩ with probability |α|²
  • |1⟩ with probability |β|²

The Hadamard Gate: Creating Superposition

The Hadamard gate (H) is one of the most important quantum gates. It creates an equal superposition from a classical state, which is the key to quantum algorithms’ power.

Hadamard Gate Matrix

The Hadamard gate is represented by the following 2×2 matrix:

H = (1/√2) ×

1 1
1 −1

Opening Superposition

Let’s see what happens when we apply the Hadamard gate to the |0⟩ state:

Step 1: Matrix Multiplication

H|0⟩ = (1/√2) ×
1 1
1 −1
×
1
0

Step 2: Result

= (1/√2) ×
1
1

Step 3: Final State

H|0⟩ = (1/√2)(|0⟩ + |1⟩)

🎯 Key Insight: This creates an equal superposition! The qubit now has a 50% probability of being measured as 0 and 50% as 1.

Similarly, applying H to |1⟩:

H|1⟩ = (1/√2)(|0⟩ − |1⟩)

Closing Superposition

Here’s the remarkable property: the Hadamard gate is its own inverse. Applying it twice returns the qubit to its original state.

H(H|0⟩) calculation:

= H( (1/√2)(|0⟩ + |1⟩) )

= (1/√2)(H|0⟩ + H|1⟩)

= (1/√2)( (1/√2)(|0⟩+|1⟩) + (1/√2)(|0⟩−|1⟩) )

= (1/2)(|0⟩ + |1⟩ + |0⟩ − |1⟩)

= (1/2)(2|0⟩)

= |0⟩ ✓

💡 Quantum Interference: The amplitude for |1⟩ cancels out completely, and we return to the definite state |0⟩. This is the magic of quantum interference!

Example Circuit: Creating and Collapsing Superposition

Let’s look at a simple quantum circuit:

     ┌───┐┌───┐┌─┐
q_0: ┤ H ├┤ H ├┤M├
     └───┘└───┘└─┘

Legend: H = Hadamard gate, M = Measurement

Step-by-step Execution:

Step State Description
1. Initial |ψ₀⟩ = |0⟩ Qubit starts in state 0
2. After H |ψ₁⟩ = (1/√2)(|0⟩+|1⟩) Superposition! 50% chance of 0 or 1
3. After H |ψ₂⟩ = |0⟩ Back to |0⟩! Superposition collapsed
4. Measure Result = 0 We measure 0 with 100% probability

Multi-Qubit Systems and Tensor Products

When working with multiple qubits, we use the tensor product (⊗) to describe the combined state space.

Two-Qubit System

For two qubits, we have four possible basis states:

|00⟩ = |0⟩ ⊗ |0⟩
|01⟩ = |0⟩ ⊗ |1⟩
|10⟩ = |1⟩ ⊗ |0⟩
|11⟩ = |1⟩ ⊗ |1⟩

Tensor Product Example

Let’s calculate |0⟩ ⊗ |1⟩ step by step:

|0⟩ ⊗ |1⟩ =
1
0
0
1

The tensor product stacks the results:

  • First element (1) × [0, 1] = [0, 1]
  • Second element (0) × [0, 1] = [0, 0]
  • Stack them: [0, 1, 0, 0]
Result:
0
1
0
0
= |01⟩

Creating Multi-Qubit Superposition

Consider applying Hadamard gates to both qubits starting from |00⟩:

     ┌───┐
q_0: ┤ H ├
     ├───┤
q_1: ┤ H ├
     └───┘

Initial: |ψ₀⟩ = |00⟩

After H gates on both qubits:

(H ⊗ H)|00⟩ = (H|0⟩) ⊗ (H|0⟩)

= ( (1/√2)(|0⟩+|1⟩) ) ⊗ ( (1/√2)(|0⟩+|1⟩) )

= (1/2)(|0⟩⊗|0⟩ + |0⟩⊗|1⟩ + |1⟩⊗|0⟩ + |1⟩⊗|1⟩)

= (1/2)(|00⟩ + |01⟩ + |10⟩ + |11⟩)

🌟 Amazing Result: Both qubits are now in superposition! The system has an equal 25% probability of being measured in ANY of the four possible states: |00⟩, |01⟩, |10⟩, or |11⟩.

Opening and Closing Multi-Qubit Superposition

Here’s the complete example showing interference:

     ┌───┐┌───┐
q_0: ┤ H ├┤ H ├
     ├───┤├───┤
q_1: ┤ H ├┤ H ├
     └───┘└───┘

Step 1: Initial State

|ψ₀⟩ = |00⟩

Step 2: After First H Gates (Opening Superposition)

|ψ₁⟩ = (1/2)(|00⟩ + |01⟩ + |10⟩ + |11⟩)

Equal superposition of all 4 states!

Step 3: After Second H Gates (Closing Superposition)

We need to apply H⊗H to each of the four states:

Input State After (H⊗H)
|00⟩ (1/2)(|00⟩ + |01⟩ + |10⟩ + |11⟩)
|01⟩ (1/2)(|00⟩ − |01⟩ + |10⟩ − |11⟩)
|10⟩ (1/2)(|00⟩ + |01⟩ − |10⟩ − |11⟩)
|11⟩ (1/2)(|00⟩ − |01⟩ − |10⟩ + |11⟩)

⚡ Quantum Interference Analysis:

For |00⟩: (1/4) × (+1 +1 +1 +1) = 4/4 = 1 ✓

Constructive interference!

For |01⟩: (1/4) × (+1 −1 +1 −1) = 0 ✗

Destructive interference – cancels out!

For |10⟩: (1/4) × (+1 +1 −1 −1) = 0 ✗

Destructive interference – cancels out!

For |11⟩: (1/4) × (+1 −1 −1 +1) = 0 ✗

Destructive interference – cancels out!

Final Result:

|ψ₂⟩ = |00⟩

🎉 We’re back to the original state through quantum interference!

Tensor Product of Hadamard Gates

The combined Hadamard operator H⊗H creates a 4×4 matrix:

H ⊗ H = (1/2) ×

1 1 1 1
1 −1 1 −1
1 1 −1 −1
1 −1 −1 1

This 4×4 matrix operates on the four-dimensional space of two-qubit states.

Why This Matters

The ability to create and manipulate superposition is what gives quantum computers their potential power. While a classical computer must check each possibility one at a time, a quantum computer in superposition can process multiple possibilities simultaneously.

The Art of Quantum Algorithm Design

  1. Opening Superposition: Using Hadamard gates to explore multiple states simultaneously
  2. Quantum Operations: Manipulating the superposition in clever ways
  3. Closing Superposition: Using interference to amplify the correct answer and cancel wrong ones

This is the foundation upon which all quantum algorithms are built, from Grover’s search algorithm to Shor’s factoring algorithm.

Conclusion

The qubit and Hadamard gate are the building blocks of quantum computation. By understanding how the Hadamard gate creates and collapses superposition through the mathematics of state vectors and tensor products, we gain insight into the fundamental principles that make quantum computing possible.

The next time you hear about quantum speedup or quantum advantage, remember that it all starts with these simple mathematical operations on qubits in superposition.


🚀 Ready to experiment yourself?

Popular quantum computing frameworks like Qiskit, Cirq, and Q# allow you to create and simulate these circuits on your own computer, and even run them on real quantum hardware through cloud platforms!

Exploring Quantum Entanglement: CHSH Game Simulator

Have you ever wondered how quantum mechanics and quantum computing defies our everyday intuition? Below is a project I built that demonstrates one of the most mind-bending phenomena in quantum physics: quantum entanglement and its ability to violate classical physics constraints.

Live Demo

🎮 Try the CHSH Game Simulator

📂 View on GitHub

What is the CHSH Game?

The CHSH (Clauser-Horne-Shimony-Holt) game is a fascinating thought experiment that reveals the strange power of quantum entanglement. It’s a cooperative game between two players, Alice and Bob, who cannot communicate with each other but share a special resource.

The Game Rules

  1. A referee sends random bits x and y to Alice and Bob respectively
  2. Alice outputs a bit a based on her input x
  3. Bob outputs a bit b based on his input y
  4. They win if: (a + b) mod 2 = x × y

The fascinating part? With classical strategies (no quantum physics), the maximum win rate is 75%. But with quantum entanglement, Alice and Bob can achieve approximately 85.4% – seemingly breaking the laws of classical physics!

Key Features

🎯 Interactive Visualization

The app features a real-time p5.js visualization that shows:

  • Entangled State: Two qubits in a maximally entangled Bell state
  • After Alice’s Measurement: How Alice’s measurement affects both qubits
  • After Bob’s Measurement: The final collapsed state after both measurements

Each stage includes:

  • Colored measurement basis quadrants (red, blue, orange, green)
  • Clear labels showing measurement outcomes (0 and 1)
  • Visual indication of quantum correlation (parallel or orthogonal)

🧪 Four Bell States

The simulator supports all four maximally entangled Bell states:

  1. |Φ+⟩ = (|00⟩ + |11⟩)/√2
  2. |Φ-⟩ = (|00⟩ – |11⟩)/√2
  3. |Ψ+⟩ = (|01⟩ + |10⟩)/√2
  4. |Ψ-⟩ = (|01⟩ – |10⟩)/√2

Each Bell state uses carefully optimized measurement angles to maximize the CHSH violation and achieve the theoretical ~85% win rate.

🎮 Strategy Comparison

Switch between:

  • Classical Strategy: Always outputs 0, achieving the theoretical 75% maximum
  • Quantum Strategy: Uses entangled qubits to beat classical limits

🎲 Flexible Input Controls

Choose input bits for Alice (x) and Bob (y):

  • Random: Simulates realistic random inputs
  • Fixed (0 or 1): Test specific measurement configurations

📊 Real-Time Statistics

Track performance with:

  • Total rounds played
  • Wins and losses
  • Win percentage that converges to theoretical predictions

🔄 Round History Navigation

Navigate through previous rounds to review specific outcomes and understand the quantum measurement process better.

The Science Behind It

Bell’s Inequality and CHSH

In 1964, physicist John Bell proved that no local hidden variable theory could reproduce all predictions of quantum mechanics. The CHSH inequality is a specific formulation of Bell’s theorem:

Classical limit: S ≤ 2

Quantum mechanics: S = 2√2 ≈ 2.828

This violation proves that quantum entanglement exhibits correlations that cannot be explained by any classical mechanism, even with shared randomness!

Measurement Angles

The key to achieving the quantum advantage lies in choosing the right measurement angles. For the standard |Φ+⟩ Bell state:

  • Alice’s bases: 0° (x=0), 45° (x=1)
  • Bob’s bases: 22.5° (y=0), -22.5° (y=1)

The probability that Alice and Bob get the same outcome is:

P(same) = cos²(δ)

where δ is the relative angle between their measurement bases. This quantum correlation is what allows them to beat the 75% classical limit.

Orthogonal vs Parallel Correlation

Different Bell states exhibit different correlation patterns:

  • Parallel correlation (|Φ+⟩, |Ψ+⟩): Qubits tend to give the same measurement outcome
  • Orthogonal correlation (|Φ-⟩, |Ψ-⟩): One qubit is rotated 90° relative to the other

The simulator accounts for these differences and adjusts the probability calculations accordingly.

Try It Yourself!

You can try the simulator and explore:

  1. Start with the Classical strategy and run 100 rounds – you’ll see it converge to ~75%
  2. Switch to Quantum with the |Φ+⟩ Bell state – watch it reach ~85%
  3. Try different Bell states and input combinations
  4. Use the round navigation to review specific outcomes

Future Enhancements

  • 3D Bloch Sphere Visualization: Show quantum states on the Bloch sphere using Three.js
  • Animated Transitions: Step-by-step animation of the measurement process
  • Educational Tutorial: Guided walkthrough explaining each concept
  • Mathematical Deep Dive: Optional panel with detailed probability calculations
  • Mobile Optimization: Touch-friendly controls and responsive layout

Open Source

The complete source code is available on GitHub. Feel free to:

  • Explore the code
  • Report issues
  • Suggest improvements
  • Fork and build your own quantum visualizations!

Conclusion

The CHSH game beautifully demonstrates that quantum entanglement isn’t just mathematical abstraction – it has measurable, observable consequences that defy classical intuition. This simulator makes that phenomenon interactive and accessible.

Whether you’re a physics student, educator, or simply curious about quantum mechanics, I hope this tool helps you develop an intuition for one of nature’s most fascinating phenomena.


Built with: React, p5.js, and Claude Code

Try it now: https://myhlow.github.io/chsh-game-simulator

Source code: https://github.com/myhlow/chsh-game-simulator


Have questions or suggestions? Leave a comment below or open an issue on GitHub!

Google’s Quantum Chip Sparks Debate on Multiverse Theory

According to Google, Willow solved a computational problem in under five minutes — a task that would have taken the world’s fastest supercomputers approximately 10 septillion years.

https://thequantuminsider.com/2024/12/16/googles-quantum-chip-sparks-debate-on-multiverse-theory/