DEV Community: Malcolm Low

The Curious Case of 1/998001: Missing Number & Math Guide

Malcolm Low — Sat, 03 Oct 2026 04:55:36 +0000

Originally published at malcolmlow.com.

Quick Answer & Key Insight: Why Does 1/998001 Generate All 3-Digit Numbers?

Yes, 1/998001 generates every 3-digit sequence. Because 998001 equals $999^2$, the decimal expansion cascades through consecutive integers, but carrying digits at the 998th block creates an unexpected loop trap that skips 998. See the mathematical proof and sequence breakdown table below →

Mathematics reveals elegant patterns in unexpected places. Consider the fraction $\frac{1}{998001}$, which equals:

0.000001002003004005006...

Notice the pattern: it contains every three-digit integer in sequential ascending order (000, 001, 002, 003, 004, 005...).

1. The Power-of-10 Denominator Family

This phenomenon occurs because $998001 = 999^2$. Similar cascading patterns emerge in related fractions based on $10^k - 1$:

$\frac{1}{9} = 0.111111\dots$ (repeating 1-digit sequence)
$\frac{1}{99} = 0.010101\dots$ (repeating 2-digit sequence)
$\frac{1}{999} = 0.001001001\dots$ (repeating 3-digit sequence)

When we square the denominator, something extraordinary happens.

Consider $\frac{1}{9^2} = \frac{1}{81}$:

1 / 81 = 0.012345679012345679...

Notice that it generates all digits from 0 to 9 in order, except the number 8 is skipped!

Similarly, $\frac{1}{99^2} = \frac{1}{9801}$:

1 / 9801 = 0.000102030405...9697990001...

It generates all 2-digit numbers 00 to 99, except 98 is skipped!

And for $\frac{1}{999^2} = \frac{1}{998001}$, it generates all 3-digit numbers from 000 to 999, except 998 is skipped.

2. Mathematical Proof: The Series Expansion

To understand why this happens, consider the Taylor series for $\frac{1}{(1 - x)^2}$:

$$\frac{1}{(1 - x)^2} = \sum_{n=1}^{\infty} n x^{n-1} = 1 + 2x + 3x^2 + 4x^3 + 5x^4 + \dots$$

Let $x = 10^{-3} = \frac{1}{1000}$. Then:

$$1 - x = 1 - \frac{1}{1000} = \frac{999}{1000}$$

$$(1 - x)^2 = \left(\frac{999}{1000}\right)^2 = \frac{998001}{1000000}$$

Taking the reciprocal:

$$\frac{1}{(1 - x)^2} = \frac{1000000}{998001} = 1 + \frac{2}{1000} + \frac{3}{1000^2} + \frac{4}{1000^3} + \dots$$

Dividing both sides by $10^6$:

$$\frac{1}{998001} = \sum_{n=1}^{\infty} n \cdot 10^{-3(n+1)} = \frac{1}{1000^2} + \frac{2}{1000^3} + \frac{3}{1000^4} + \dots$$

Written out in decimal form:

  0.000001
+ 0.000000002
+ 0.000000000003
+ 0.000000000000004
...
= 0.000 001 002 003 004 005 ...

3. Why is 998 Missing?

Every term adds an increment of $+1$ to its respective 3-digit block. However, what happens when $n = 998$, $999$, and $1000$?

For $n = 998$, the block is ... 997 [998] ...
For $n = 999$, the block is ... [999] ...
For $n = 1000$, we have four digits! The leading digit 1 cannot fit in the 3-digit slot, so it carries over into the preceding block:

$$\dots 998 + 1 \text{ (carry)} = 999$$

The cascading carry propagates backward:

Block $999 + 1 = 1000$, which carries 1 into the $998$ block.
The $998$ block receives the carry: $998 + 1 = 999$.
The $999$ block itself becomes 000 (since its 1 was carried from the 1000 block).
Thus, the sequence outputs ... 996, 997, 999, 000, 001 ...

The number 998 is absorbed by the carry from 999 and 1000!

4. Python Verification Script

You can verify this in Python using the decimal module with high precision:

from decimal import Decimal, getcontext

# Set precision to 3000 decimal places (999 * 3 digits)
getcontext().prec = 3010

fraction = Decimal(1) / Decimal(998001)
dec_str = str(fraction).split('.')[1]

# Extract 3-digit blocks
blocks = [dec_str[i:i+3] for i in range(0, len(dec_str)-10, 3)]

print(f"First 10 blocks: {blocks[:10]}")
print(f"Blocks around 998: {blocks[995:1002]}")

# Check missing number
for num in range(1000):
    expected = f"{num:03d}"
    if expected not in blocks[:1000]:
        print(f"Missing block found: {expected}")

Output:

First 10 blocks: ['000', '001', '002', '003', '004', '005', '006', '007', '008', '009']
Blocks around 998: ['995', '996', '997', '999', '000', '001', '002']
Missing block found: 998

Frequently Asked Questions (FAQ)

Why does 1/998001 generate all 3-digit numbers?

1/998001 equals $1/(999^2)$. Expanding $1/(10^3 - 1)^2$ produces the series $\sum n \cdot 10^{-3(n+1)}$, yielding consecutive 3-digit blocks 000, 001, 002, 003... in ascending order.

Why is 998 missing in the decimal expansion of 1/998001?

The number 998 is skipped because the addition of subsequent carried terms (specifically 999 and 1000) cascades into the 998 block, turning 998 into 999 and resetting the sequence counter.

What practical applications do these repeating fractions have?

These properties underpin cyclic decimal algorithms, pseudo-random number generation, digital filter design, and error-correcting codes where dense periodic bit sequences are required.

Drawing Quantum Diagrams with Matplotlib on Android Termux

Malcolm Low — Fri, 02 Oct 2026 23:59:52 +0000

Part of the Quantum Computing: A Complete Learning Path and Developer Workflows on Termux series on malcolmlow.com.

Rendering publication-grade quantum state diagrams directly on an Android device is surprisingly practical. With modern high-resolution mobile screens and terminal environments like Termux, you can generate vector charts, calculate unitary matrix transformations, and export WebP figures on the go.

However, anyone who has tried running pip install qiskit directly on Termux knows the pain: modern Qiskit requires a Rust toolchain (qiskit-aer and core binaries) that often fails to compile on mobile ARM64 or exhausts device memory during wheel builds.

In this guide, we walk through a lean, tested workflow for rendering multi-panel 3D Bloch sphere progression diagrams (tracking Pauli $X$, Hadamard $H$, and Pauli $Z$ gates) on Android Termux using pure NumPy, Matplotlib, and a lightweight standalone loader—no Rust compiler required.

Quick Answer & Key Insight

Can you render 3D Bloch spheres and quantum circuits on Android Termux without building full Qiskit?

Yes, you can generate 3D Bloch spheres on Termux using pure NumPy and Matplotlib. Full Qiskit wheel builds frequently crash mobile devices due to Rust compiler memory exhaustion. By dynamically isolating Qiskit's pure-Python bloch.py module and computing state evolution with 2x2 NumPy matrix operators, you generate identical publication-grade figures in seconds without compiling heavy binaries.

1. What Was Tested

The workflow was verified on an Android ARM64 device running Termux under the standard user environment (no root required):

Python: 3.12+ (Termux packages)
Libraries: numpy, matplotlib, cwebp (libwebp)
Diagram: 3 rows × 2 columns of 3D Bloch spheres (X, H, and Z gate before/after states)
Output: High-resolution WebP image under 150 KB with crisp vector typography

2. Install Termux Prerequisites

Open Termux and install Python, Clang, and Matplotlib's system dependencies:

pkg update && pkg upgrade -y
pkg install -y python python-numpy python-matplotlib libpng libjpeg-turbo libwebp

Verify your Matplotlib installation:

python -c "import matplotlib, numpy; print('Matplotlib:', matplotlib.__version__, '| NumPy:', numpy.__version__)"

3. When Full Qiskit Will Not Install

Running pip install qiskit on native Android Termux typically fails with:

error: can't find Rust compiler
...
Building wheel for qiskit-aer (setup.py) ... error: killed

Even if you install the rust package via pkg install rust, compiling Qiskit’s core C/Rust extensions takes 30–45 minutes and often triggers the Linux Out-Of-Memory (OOM) killer on phones with less than 8 GB of RAM.

The Solution: We don't need the entire quantum simulator just to draw a Bloch sphere! Qiskit's Bloch class is written in pure Python using Matplotlib 3D axes (mpl_toolkits.mplot3d). We can download the pinned Qiskit source tarball, extract only qiskit/visualization/bloch.py, and dynamically import it into our script.

4. The Lean Standalone Bloch Loader

Run this one-time command in Termux to download and extract the visualizer module:

mkdir -p $PREFIX/tmp/qiskit-source
cd $PREFIX/tmp/qiskit-source
curl -sL https://github.com/Qiskit/qiskit/archive/refs/tags/2.5.2.tar.gz -o qiskit-2.5.2.tar.gz
tar -xzf qiskit-2.5.2.tar.gz qiskit-2.5.2/qiskit/visualization/bloch.py

Now, create your standalone generator script generate_bloch.py:

from pathlib import Path
import importlib.util
import os
import sys
import types
import matplotlib.pyplot as plt
import numpy as np

# 1. Locate the standalone bloch.py module
version = "2.5.2"
bloch_source = (
    Path(os.environ.get("PREFIX", "/data/data/com.termux/files/usr"))
    / "tmp"
    / "qiskit-source"
    / f"qiskit-{version}"
    / "qiskit"
    / "visualization"
    / "bloch.py"
)

# 2. Stub minimal Qiskit visualization namespace
def matplotlib_close_if_inline(_figure):
    return None

visualization_pkg = types.ModuleType("qiskit.visualization")
visualization_pkg.__path__ = []
utils_module = types.ModuleType("qiskit.visualization.utils")
utils_module.matplotlib_close_if_inline = matplotlib_close_if_inline

sys.modules["qiskit"] = types.ModuleType("qiskit")
sys.modules["qiskit.visualization"] = visualization_pkg
sys.modules["qiskit.visualization.utils"] = utils_module

# 3. Dynamically import the Bloch class
spec = importlib.util.spec_from_file_location("qiskit.visualization.bloch", bloch_source)
module = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = module
spec.loader.exec_module(module)
Bloch = module.Bloch

# 4. Pure NumPy state vector coordinate calculation
def bloch_vector(state):
    """Converts a 2-element complex state vector [alpha, beta] to [x, y, z]."""
    alpha, beta = state
    overlap = np.conj(alpha) * beta
    return [
        float(2 * np.real(overlap)),
        float(2 * np.imag(overlap)),
        float(abs(alpha) ** 2 - abs(beta) ** 2),
    ]

# 5. Define Unitary Operators
zero = np.array([1, 0], dtype=complex)
x_gate = np.array([[0, 1], [1, 0]], dtype=complex)
h_gate = np.array([[1, 1], [1, -1]], dtype=complex) / np.sqrt(2)
z_gate = np.array([[1, 0], [0, -1]], dtype=complex)

# State progressions
one = x_gate @ zero
plus = h_gate @ zero
minus = z_gate @ plus

# Verify unit normalization
assert np.allclose(one, [0, 1])
assert np.allclose(plus, np.array([1, 1]) / np.sqrt(2))
assert np.allclose(minus, np.array([1, -1]) / np.sqrt(2))

states = [zero, one, zero, plus, plus, minus]
titles = [
    r"X input: $|0\rangle$",
    r"X output: $|1\rangle$",
    r"H input: $|0\rangle$",
    r"H output: $|+\rangle$",
    r"Z input: $|+\rangle$",
    r"Z output: $|-\rangle$",
]
colors = ["#1565C0", "#D32F2F"] * 3

# 6. Render the 3x2 Figure
fig = plt.figure(figsize=(9.6, 12.6), facecolor="white")

for index, (state, title, color) in enumerate(zip(states, titles, colors)):
    axis = fig.add_subplot(3, 2, index + 1, projection="3d")
    sphere = Bloch(fig=fig, axes=axis, font_size=13)
    sphere.xlabel = [r"$|+\rangle$", r"$|-\rangle$"]
    sphere.vector_color = [color]
    sphere.add_vectors(bloch_vector(state))
    sphere.render(title=title)

# Annotate Gate labels along the left margin
gate_labels = [("X gate", 0.805), ("H gate", 0.495), ("Z gate", 0.185)]
for label, y_pos in gate_labels:
    fig.text(0.03, y_pos, label, rotation=90, va="center", ha="center", fontweight="bold", fontsize=14)

fig.suptitle("Bloch-Sphere Gate Order: X, then H, then Z", fontsize=18, fontweight="bold", y=0.98)
plt.savefig("bloch_progression.png", dpi=300, bbox_inches="tight")
print("✓ Rendered bloch_progression.png in < 3 seconds!")

5. Convert PNG to High-Performance WebP

Matplotlib outputs high-DPI PNGs, but for web publishing, converting to lossy WebP dramatically reduces file size while retaining crystal-clear vector line rendering:

python generate_bloch.py
cwebp -q 88 bloch_progression.png -o bloch_progression.webp

Original PNG: ~1.4 MB
WebP Output: ~128 KB (91% reduction)

6. Problems Encountered and Their Fixes

Issue Encountered	Root Cause	Working Solution
`No module named 'mpl_toolkits.mplot3d'`	Incomplete Matplotlib build	Run `pkg install python-matplotlib` instead of pip
Matplotlib GUI window fails	Termux has no X11/Wayland display by default	Use non-interactive backend: `plt.switch_backend('Agg')`
Labels truncated at figure boundaries	Complex 3D subplots clipping margins	Use `bbox_inches="tight"` and adjust `figsize`
LaTeX math font syntax errors	Missing system LaTeX distribution	Matplotlib's built-in `mathtext` parser handles $...$ without LaTeX installed

Frequently Asked Questions

Can I run Qiskit Aer simulations on Termux?

Yes, but running Qiskit Aer reliably on Termux requires using PRoot Debian or Ubuntu (pkg install proot-distro), which provides pre-compiled glibc ARM64 Linux wheels rather than compiling against Android Bionic libc.

Why not just use matplotlib-inline?

matplotlib-inline is designed for interactive Jupyter notebooks. For headless mobile scripting and automation pipelines, using Matplotlib's Agg backend and exporting directly to disk is significantly faster and requires zero server overhead.

Originally published at malcolmlow.com.

Bloch Sphere Visual Guide: Basis States |0⟩, |1⟩, and Pauli X & Z Gates

Malcolm Low — Fri, 02 Oct 2026 23:58:08 +0000

Module 2 in the Quantum Computing: A Complete Learning Path series on malcolmlow.com. Following our Introduction to Qubits and Superposition (Module 1), this guide establishes the 3D geometric intuition for single-qubit quantum states and rotations before moving to Two-Qubit Entanglement (Module 3).

Every single-qubit quantum state lives on the surface of a unit sphere in three-dimensional Euclidean space: the Bloch sphere. While classical bits are confined to discrete binary values $0$ and $1$, a qubit can point in any direction defined by spherical coordinates $(\theta, \phi)$.

Yet many beginners struggle to bridge the algebraic definition of a state $|\psi\rangle = \alpha |0\rangle + \beta |1\rangle$ with its physical geometry. Why is $|1\rangle$ at the South Pole when classical intuition expects it to be 90° away from $|0\rangle$? How does an $X$ gate flip a state without changing relative phase? And how does a $Z$ gate alter quantum information if it never changes measurement probabilities in the computational basis?

In this guide, we break down single-qubit geometry from first principles: deriving the polar angles $\theta$ and $\phi$, tracking the basis states $|0\rangle$ and $|1\rangle$, visualizing the equatorial superposition states $|+\rangle$ and $|-\rangle$, analyzing how the Pauli $X$, Hadamard $H$, and Pauli $Z$ gates rotate vectors, and verifying the complete transformation with runnable Qiskit visualization code.

Quick Answer & Key Insight

How do Pauli X and Z gates rotate qubit states on the Bloch sphere?

Yes, Pauli X and Z gates flip states on the sphere. The Pauli $X$ gate rotates the qubit state vector by $\pi$ radians (180°) around the x-axis, flipping computational basis state $|0\rangle$ to $|1\rangle$. The Pauli $Z$ gate rotates the state vector by $\pi$ radians around the z-axis, leaving $|0\rangle$ and $|1\rangle$ unchanged in probability while flipping relative phase on equatorial superposition states (transforming $|+\rangle$ to $|-\rangle$). Blindly rotating qubits without tracking orthogonal axes causes fatal phase errors in quantum algorithms.

1. Why the Bloch Sphere Works: Geometry of a Pure State

A pure single-qubit state is a normalized vector in two-dimensional complex Hilbert space $\mathbb{C}^2$:

Because physical measurements depend only on relative phase (global phase factor $e^{i\gamma}$ is unobservable), any pure state can be uniquely parameterized by two real angles $\theta \in [0, \pi]$ and $\phi \in [0, 2\pi)$:

$$|\psi\rangle = \cos\left(\frac{\theta}{2}\right) |0\rangle + e^{i\phi} \sin\left(\frac{\theta}{2}\right) |1\rangle$$

This corresponds directly to a unit vector $\vec{r} = (x, y, z)$ on the 3D Bloch sphere:

$x = \sin\theta \cos\phi$
$y = \sin\theta \sin\phi$
$z = \cos\theta$

Why the Half-Angle $\theta/2$?

Notice that $\theta$ ranges from $0$ to $\pi$ (180°), but $\theta/2$ ranges from $0$ to $\pi/2$ (90°). This mathematical half-angle is the key: orthogonal quantum states (90° in Hilbert space) are mapped to antipodal points (180° apart) on the Bloch sphere.

2. Basis States and the Equatorial Plane

Figure 1: Computational basis states at the poles vs. equal superposition states on the equatorial plane.

The Computational Basis (Z-Axis Poles)

North Pole ($z = +1$): $\theta = 0 \implies |\psi\rangle = |0\rangle$
South Pole ($z = -1$): $\theta = \pi \implies |\psi\rangle = |1\rangle$

Because $|0\rangle$ and $|1\rangle$ lie at opposite poles, any state along the z-axis has a well-defined probability of collapsing into classical bits when measured.

The Equatorial Plane (X and Y Axes)

When $\theta = \pi/2$, $\cos(\pi/4) = \sin(\pi/4) = 1/\sqrt{2}$. The qubit has an equal 50/50 probability of yielding $0$ or $1$:

Positive X-Axis ($+x$): $\phi = 0 \implies |+\rangle = \frac{|0\rangle + |1\rangle}{\sqrt{2}}$
Negative X-Axis ($-x$): $\phi = \pi \implies |-\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$
Positive Y-Axis ($+y$): $\phi = \pi/2 \implies |+i\rangle = \frac{|0\rangle + i|1\rangle}{\sqrt{2}}$
Negative Y-Axis ($-y$): $\phi = 3\pi/2 \implies |-i\rangle = \frac{|0\rangle - i|1\rangle}{\sqrt{2}}$

3. The Pauli X Gate: 180° Rotation Around the X-Axis

The Pauli $X$ gate represents quantum bit-flip logic:

$$X = \begin{pmatrix} 0 & 1 \ 1 & 0 \end{pmatrix}$$

Geometrically, $X$ rotates the state vector by $\pi$ radians around the x-axis:

$X |0\rangle = |1\rangle$ (North Pole rotates through the equator to South Pole)
$X |1\rangle = |0\rangle$ (South Pole rotates back to North Pole)
$X |+\rangle = |+\rangle$ (State along the x-axis is an eigenstate and remains unchanged!)

4. The Hadamard Gate: Bridging Poles and Equator

The Hadamard gate $H$ creates quantum superposition:

$$H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \ 1 & -1 \end{pmatrix}$$

Geometrically, $H$ is a 180° rotation around the diagonal $(x + z)$ axis. It swaps the computational basis with the Hadamard basis:

$H |0\rangle = |+\rangle$ (Moves North Pole to positive x-axis)
$H |1\rangle = |-\rangle$ (Moves South Pole to negative x-axis)
$H |+\rangle = |0\rangle$ and $H |-\rangle = |1\rangle$ (Reversible self-inverse: $H^2 = I$)

5. The Pauli Z Gate: 180° Phase Rotation Around the Z-Axis

The Pauli $Z$ gate represents phase-flip logic:

$$Z = \begin{pmatrix} 1 & 0 \ 0 & -1 \end{pmatrix}$$

Geometrically, $Z$ rotates the state vector by $\pi$ radians around the z-axis:

$Z |0\rangle = |0\rangle$ (North Pole lies on the rotation axis; unchanged)
$Z |1\rangle = -|1\rangle$ (Global phase; probability unchanged)
$Z |+\rangle = |-\rangle$ (Rotates the vector across the equatorial plane from $+x$ to $-x$!)
$Z |-\rangle = |+\rangle$

Why this matters: A $Z$ gate does not change measurement outcomes in the computational basis ($|0\rangle$ vs $|1\rangle$), but it fundamentally flips quantum phase. In algorithms like Grover's search and Deutsch-Jozsa, this phase flip enables constructive and destructive interference.

6. X, H, and Z Transformations Side by Side

Figure 2: Visual progression of quantum states under Pauli X, Hadamard H, and Pauli Z gate operations.

Gate	Matrix Operator	Geometric Axis	Input State	Output State	Physical Effect
Pauli X	$\begin{pmatrix} 0 & 1 \ 1 & 0 \end{pmatrix}$	Rotation by $\pi$ around $x$	$	0\rangle$	$
Hadamard	$\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \ 1 & -1 \end{pmatrix}$	Rotation by $\pi$ around $x+z$	$	0\rangle$	$
Pauli Z	$\begin{pmatrix} 1 & 0 \ 0 & -1 \end{pmatrix}$	Rotation by $\pi$ around $z$	$	+\rangle$	$

7. Python Verification in Qiskit

You can generate this exact multi-panel 3D Bloch visualization using Qiskit and Matplotlib:

from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
from qiskit.circuit.library import HGate, XGate, ZGate
from qiskit.quantum_info import Statevector
from qiskit.visualization.bloch import Bloch

def bloch_vector(state):
    """Calculates (x, y, z) Bloch coordinates from a 2-element Statevector."""
    alpha, beta = state.data
    overlap = np.conj(alpha) * beta
    return [
        float(2 * np.real(overlap)),
        float(2 * np.imag(overlap)),
        float(abs(alpha) ** 2 - abs(beta) ** 2),
    ]

# Define base states
zero = Statevector.from_label("0")
one = zero.evolve(XGate())
plus = zero.evolve(HGate())
minus = plus.evolve(ZGate())

assert one.equiv(Statevector.from_label("1"))
assert plus.equiv(Statevector.from_label("+"))
assert minus.equiv(Statevector.from_label("-"))

rows = [
    ("X gate", zero, one, r"Input: $|0\rangle$", r"Output: $|1\rangle$"),
    ("H gate", zero, plus, r"Input: $|0\rangle$", r"Output: $|+\rangle$"),
    ("Z gate", plus, minus, r"Input: $|+\rangle$", r"Output: $|-\rangle$"),
]

fig = plt.figure(figsize=(9.6, 12.6), facecolor="white")

for row_index, (gate, before, after, before_title, after_title) in enumerate(rows):
    for column_index, (state, title, color) in enumerate((
        (before, before_title, "#1565C0"),
        (after, after_title, "#D32F2F"),
    )):
        axis = fig.add_subplot(
            3, 2, row_index * 2 + column_index + 1, projection="3d"
        )
        sphere = Bloch(fig=fig, axes=axis, font_size=13)
        sphere.xlabel = [r"$|+\rangle$", r"$|-\rangle$"]
        sphere.vector_color = [color]
        sphere.add_vectors(bloch_vector(state))
        sphere.render(title=title)

    fig.text(
        0.03, 0.805 - row_index * 0.31, gate,
        rotation=90, va="center", ha="center", fontweight="bold",
    )

fig.suptitle(
    "Bloch-Sphere Gate Progression: X, then H, then Z",
    fontsize=18, fontweight="bold", y=0.98
)
plt.tight_layout()
plt.savefig("bloch_progression.png", dpi=300)
print("Saved bloch_progression.png successfully!")

8. Summary & Key Takeaways

Orthogonality vs. Antipodality: In Hilbert space, orthogonal states $|0\rangle$ and $|1\rangle$ have zero inner product ($\langle 0|1\rangle = 0$). On the Bloch sphere, they point in opposite directions (separated by 180°).
Single-Qubit Unitaries are Rotations: Every single-qubit quantum gate is isomorphic to an $SO(3)$ rotation of the Bloch sphere around some axis.
The Foundation of Entanglement: The Bloch sphere only describes pure single-qubit states. As soon as two qubits become entangled, individual Bloch vectors shrink inside the sphere, representing mixed states.

Frequently Asked Questions

Why is |1⟩ at the South Pole instead of 90° away from |0⟩?

Because of the mathematical half-angle factor $\theta/2$ in the Bloch parametrization $|\psi\rangle = \cos(\theta/2)|0\rangle + e^{i\phi}\sin(\theta/2)|1\rangle$. While $|0\rangle$ and $|1\rangle$ are orthogonal in complex vector space (90°), their geometric representation maps $\theta = \pi$ (180°), placing them at antipodal poles.

Does the Pauli Z gate change measurement probabilities?

Not in the computational basis. For computational states $|0\rangle$ and $|1\rangle$, the $Z$ gate leaves measurement probabilities at 100%. However, for superposition states like $|+\rangle$, $Z$ flips the relative phase to $|-\rangle$, which can be detected with 100% certainty by measuring in the Hadamard basis.

Originally published at malcolmlow.com.

The Deutsch-Jozsa Algorithm Explained: Quantum Complexity & Qiskit

Malcolm Low — Fri, 02 Oct 2026 23:57:13 +0000

Part of the Quantum Computing: A Complete Learning Path series on malcolmlow.com. Following our earlier analyses of the single-qubit Deutsch Algorithm and Phase Kickback, this guide scales the formulation to multi-qubit registers with the Deutsch-Jozsa Algorithm.

In 1985, David Deutsch proposed the first quantum algorithm that demonstrated a computational speedup over any classical counterpart, proving that quantum mechanics could evaluate a global property of a function faster than classical boolean logic. In 1992, together with Richard Jozsa, this was generalized into the Deutsch-Jozsa Algorithm: the very first algorithm to exhibit an exponential query separation between deterministic classical computation and exact quantum computing.

While Deutsch's original prototype applied to single-bit inputs ($n=1$, yielding a factor-of-2 speedup), Deutsch-Jozsa scales to arbitrary $n$-bit registers ($n \ge 1$). In this guide, we break down the mathematical problem, detail the four canonical oracle implementations, derive how phase kickback and Hadamard interference eliminate the exponential query barrier, and demonstrate working code in modern Qiskit 2.x with circuit diagrams.

Quick Answer & Key Insight

Can the Deutsch-Jozsa algorithm determine if an arbitrary Boolean function is constant or balanced in a single evaluation?

Yes, Deutsch-Jozsa solves the promise problem in exactly 1 query ($O(1)$). Classically, a deterministic computer must evaluate $2^{n-1} + 1$ states in the worst case—an exponential barrier that becomes intractable for even moderate register sizes ($n=30$ requires over 536 million queries). Quantum interference extracts the global function property in a single shot by exploiting phase kickback and destructive interference.

1. The Problem: Constant vs. Balanced Boolean Functions

We are given a black-box oracle that computes an unknown Boolean function taking an $n$-bit string and returning a single bit:

f: {0, 1}ⁿ → {0, 1}

We are promised that $f$ belongs strictly to one of two categories:

Constant: The function returns the exact same value for all possible inputs ($f(x) = 0$ for all $x$, or $f(x) = 1$ for all $x$).
Balanced: The function returns 0 for exactly half of the $2^n$ inputs ($2^{n-1}$ states) and 1 for the remaining half ($2^{n-1}$ states).

The Objective: Determine with 100% mathematical certainty whether $f$ is constant or balanced using the absolute minimum number of oracle evaluations.

2. Complexity Comparison: Exponential Separation

Classically, if you query the oracle with an input $x_1$ and receive $f(x_1) = 0$, you learn nothing definitive. If your next query $x_2$ yields $f(x_2) = 1$, you immediately know $f$ is balanced (best-case: 2 queries). However, in the worst-case scenario, every input you test continues to return 0.

Because a balanced function has exactly $2^{n-1}$ zeros, observing $2^{n-1}$ zeros in a row still leaves the possibility that the remaining $2^{n-1}$ inputs are all ones (balanced) or all zeros (constant). To be 100% deterministic, a classical computer must evaluate:

Classical Deterministic Queries (Worst-Case) = 2ⁿ⁻¹ + 1

Quantum computing solves this in exactly 1 query ($O(1)$) with 100% certainty:

Input Bits ($n$)	Search Space ($2^n$)	Classical Deterministic ($2^{n-1}+1$)	Quantum ($O(1)$)	Speedup Ratio
n = 1 (Deutsch)	2	2 queries	1 query	2×
n = 3	8	5 queries	1 query	5×
n = 10	1,024	513 queries	1 query	513×
n = 30	~1.07 × 10⁹	536,870,913 queries	1 query	> 5 × 10⁸×

3. The Mathematical Engine: Phase Kickback

To compute $f(x)$ reversibly, quantum computers use a unitary oracle $U_f$ operating on an input register $|x\rangle$ and an auxiliary target qubit $|y\rangle$:

U_f |x⟩ |y⟩ = |x⟩ |y ⊕ f(x)⟩

Rather than preparing the target qubit in $|0\rangle$, we prepare it in the anti-symmetric superposition state $|-\rangle = \frac{|0\rangle - |1\rangle}{\sqrt{2}}$ using an $X$ gate followed by a Hadamard $H$:

U_f |x⟩ |-⟩ = U_f |x⟩ [ (|0⟩ - |1⟩) / √2 ]
            = [ |x⟩ |0 ⊕ f(x)⟩ - |x⟩ |1 ⊕ f(x)⟩ ] / √2

• If f(x) = 0: [ |x⟩|0⟩ - |x⟩|1⟩ ] / √2 = (+1) |x⟩ |-⟩
• If f(x) = 1: [ |x⟩|1⟩ - |x⟩|0⟩ ] / √2 = (-1) |x⟩ |-⟩

In both cases, we can write the result compactly:

U_f |x⟩ |-⟩ = (-1)^{f(x)} |x⟩ |-⟩

The bit $f(x)$ is not written to the target qubit at all—it is kicked back as an eigenvalue phase factor $(-1)^{f(x)}$ directly onto the input register state!

4. Implementing All 4 Types of Oracles in Qiskit

To understand how oracles are physically constructed, let us take a 3-qubit input register ($q_0, q_1, q_2$) with an auxiliary target qubit ($q_3$). Any Boolean function falls into one of four canonical implementations:

Oracle 1: Constant-0 ($f(x) = 0$ everywhere)

Because $y \oplus 0 = y$, the target qubit is left completely untouched. The circuit is an empty identity wire:

Figure 1 (Oracle 1): Identity wire — target qubit q_3 remains unchanged.

Oracle 2: Constant-1 ($f(x) = 1$ everywhere)

Because $y \oplus 1 = \bar{y}$, the target qubit must flip unconditionally for all inputs. We apply a single NOT ($X$) gate to $q_3$:

Figure 2 (Oracle 2): Unconditional X gate on q_3 — imparts an unobservable global minus sign.

Oracle 3: Balanced Direct ($f(x) = x_0 \oplus x_2$)

To create a balanced function, we can compute an inner product or parity check. In this example, CNOTs are placed on $q_0$ and $q_2$ targeting $q_3$, leaving $q_1$ unattached:

Figure 3 (Oracle 3): CNOT controls on q_0 and q_2 — evaluates f(x) = x_0 ⊕ x_2.

Oracle 4: Balanced Inverted ($f(x) = \neg(x_0 \oplus x_2)$)

This is the complement of Oracle 3 (inverting all outputs). We place CNOTs on $q_0$ and $q_2$, followed by an $X$ gate on target $q_3$:

Figure 4 (Oracle 4): CNOT controls on q_0 and q_2 followed by NOT on q_3.

Oracle Comparison Matrix

Oracle Type	Logic Equation	Gates on Target ($q_3$)	Measurement	Verdict
1. Constant-0	f(x) = 0	None (Wire)	000 (100%)	CONSTANT
2. Constant-1	f(x) = 1	X	000 (100%)	CONSTANT
3. Balanced Direct	f(x) = x₀ ⊕ x₂	CX(q0) + CX(q2)	101 (100%)	BALANCED
4. Balanced Inverted	f(x) = ¬(x₀ ⊕ x₂)	CX(q0) + CX(q2) + X	101 (100%)	BALANCED

5. Full Circuit & Quantum Interference Derivation

Here is the complete end-to-end Deutsch-Jozsa circuit for our 3-qubit balanced function ($f(x) = x_0 \oplus x_2$):

Figure 5: Complete Deutsch-Jozsa Circuit in Qiskit: State prep, superposition, oracle, interference Hadamards, and measurement.

The Mathematical Interference:

Before the final Hadamard transform, the input register is in the state:

$$\frac{1}{\sqrt{2^n}} \sum_{x} (-1)^{f(x)} |x\rangle$$

Applying the Walsh-Hadamard transform $H^{\otimes n}$ maps each basis state $|x\rangle$ to $\frac{1}{\sqrt{2^n}} \sum_{z} (-1)^{x \cdot z} |z\rangle$. The total state becomes:

$$|\psi_{\text{final}}\rangle = \sum_{z} \left[ \frac{1}{2^n} \sum_{x} (-1)^{f(x) + x \cdot z} \right] |z\rangle$$

When we measure, consider the probability amplitude of measuring the all-zero state $|00\dots 0\rangle$ (where $z = 00\dots 0 \implies x \cdot z = 0$):

$$\alpha_{00\dots 0} = \frac{1}{2^n} \sum_{x \in {0, 1}^n} (-1)^{f(x)}$$

If $f$ is Constant: All $(-1)^{f(x)}$ have the same sign ($\pm 1$). The sum adds constructively: $\alpha_{00\dots 0} = \frac{1}{2^n} (\pm 2^n) = \pm 1$. The measurement probability is $|\pm 1|^2 = \mathbf{100\%}$. You will measure 00...0 every single time.
If $f$ is Balanced: Exactly $2^{n-1}$ inputs yield $+1$ and $2^{n-1}$ yield $-1$. The sum cancels out completely: $\alpha_{00\dots 0} = \frac{1}{2^n} (2^{n-1} - 2^{n-1}) = \mathbf{0}$. The probability of measuring all zeros is strictly 0%! Any non-zero bitstring confirms $f$ is balanced.

6. Complete Qiskit 2.x Python Implementation

The script below builds, executes, and verifies all 4 oracles using modern Qiskit 2.x primitives (StatevectorSampler):

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

def create_oracle(oracle_type: str) -> QuantumCircuit:
    """Builds one of the 4 canonical oracles on 4 qubits (q0, q1, q2 input; q3 target)."""
    oracle = QuantumCircuit(4, name=oracle_type)

    if oracle_type == "constant_0":
        # Type 1: f(x) = 0 (Identity wire)
        pass
    elif oracle_type == "constant_1":
        # Type 2: f(x) = 1 (Unconditional target flip)
        oracle.x(3)
    elif oracle_type == "balanced_direct":
        # Type 3: f(x) = x0 ^ x2 (CNOT parity on q0 and q2)
        oracle.cx(0, 3)
        oracle.cx(2, 3)
    elif oracle_type == "balanced_inverted":
        # Type 4: f(x) = ~(x0 ^ x2) (CNOT parity + NOT gate)
        oracle.cx(0, 3)
        oracle.cx(2, 3)
        oracle.x(3)
    else:
        raise ValueError(f"Unknown oracle type: {oracle_type}")

    return oracle

def run_deutsch_jozsa(oracle_circuit: QuantumCircuit):
    """Wraps an oracle inside the full Deutsch-Jozsa algorithm and measures."""
    qc = QuantumCircuit(4, 3)

    # 1. State preparation: target qubit to |->
    qc.x(3)
    qc.h(range(4))
    qc.barrier()

    # 2. Insert the oracle
    qc.compose(oracle_circuit, inplace=True)
    qc.barrier()

    # 3. Interference decoding
    qc.h(range(3))

    # 4. Measure input register
    qc.measure([0, 1, 2], [0, 1, 2])

    # Execute on StatevectorSampler
    sampler = StatevectorSampler()
    result = sampler.run([qc], shots=100).result()
    counts = result[0].data.c.get_counts()
    verdict = "CONSTANT" if list(counts.keys()) == ['000'] else "BALANCED"

    return qc, counts, verdict

# Execute and compare all 4 canonical oracles
oracles = ["constant_0", "constant_1", "balanced_direct", "balanced_inverted"]

print(f"{'Oracle Type':<20} | {'Measurement':<12} | {'Decision':<10}")
print("-" * 50)
for o_name in oracles:
    oracle_qc = create_oracle(o_name)
    full_qc, counts, verdict = run_deutsch_jozsa(oracle_qc)
    print(f"{o_name:<20} | {str(counts):<12} | {verdict:<10}")

Execution Output:

Oracle Type          | Measurement  | Decision  
--------------------------------------------------
constant_0           | {'000': 100} | CONSTANT  
constant_1           | {'000': 100} | CONSTANT  
balanced_direct      | {'101': 100} | BALANCED  
balanced_inverted    | {'101': 100} | BALANCED

7. Key Insights & Takeaways

Global Property vs. Local Evaluation: The algorithm never tells you which inputs produce 0 or 1. It extracts only the collective structural property (constant vs. balanced) by harnessing destructive interference.
Phase Kickback Converts Values to Geometry: Setting the ancilla to $|-\rangle$ turns modular arithmetic ($y \oplus f(x)$) into spatial eigenvalue phase shifts ($(-1)^{f(x)}$).
The Stepping Stone to Modern Quantum Algorithms: Deutsch-Jozsa laid the direct mathematical groundwork for the Bernstein-Vazirani algorithm (finding the hidden bitstring $s$), Simon’s algorithm, and ultimately Shor’s algorithm for integer factorization.

Frequently Asked Questions

Why does classical computing require 2^(n-1) + 1 evaluations for Deutsch-Jozsa?

In the worst-case scenario, a balanced function might return the same value (e.g., 0) for the first $2^{n-1}$ inputs tested. Only on the $(2^{n-1} + 1)$-th query can a classical deterministic algorithm guarantee whether the remaining values are identical (constant) or inverted (balanced).

How does the Deutsch-Jozsa algorithm achieve 100% determinism?

Through quantum phase kickback and Hadamard interference, all balanced states produce completely destructive interference at the $|00\dots 0\rangle$ basis state (amplitude = 0), while constant states produce completely constructive interference (amplitude = 1). Thus, observing all zeros confirms constant, while any non-zero measurement confirms balanced in a single shot.

Originally published at malcolmlow.com.

Quantum Fourier Transform (QFT) of a Single Qubit: The Hadamard Transform

Malcolm Low — Sun, 27 Sep 2026 05:13:51 +0000

Module 4 in the Quantum Computing: A Complete Learning Path series. Bridging the transition from entangled communications in Superdense Coding (Module 3b) and Two-Qubit Entanglement (Module 3) to the multi-qubit Hadamard tools in The Walsh-Hadamard Matrix (Module 5).

The Quantum Fourier Transform (QFT) is one of the most powerful subroutines in all of quantum algorithms. It serves as the mathematical engine powering Shor's Factoring Algorithm, Quantum Phase Estimation (QPE), and quantum order finding. At first glance, the general $n$-qubit QFT formula appears formidable, laden with complex exponential phases and multi-controlled phase rotations.

However, when stripped down to its absolute simplest case—a single qubit ($N = 2^1 = 2$)—an elegant mathematical symmetry emerges: the 1-qubit Quantum Fourier Transform is identical to the familiar Hadamard gate.

In this guide, we derive this equivalence from first principles, evaluate the basis states $|0\rangle$ and $|1\rangle$, inspect the matrix representation, and verify the equivalence in Qiskit 2.x.

1. The General Definition of the Quantum Fourier Transform

In an $N$-dimensional Hilbert space with computational basis states ${|0\rangle, |1\rangle, \dots, |N-1\rangle}$, the Quantum Fourier Transform acts on a computational basis state $|x\rangle$ as:

|x̃⟩ ≡ QFT |x⟩ ≡ ( 1 / √N ) ∑ [ e^(2π i x y / N) ] |y⟩    (summed from y = 0 to N - 1)

Just like the classical Discrete Fourier Transform (DFT), the QFT maps computational basis states into superpositions of states whose relative phases rotate at frequencies proportional to $x$. For an $n$-qubit quantum register, the dimension of the state space is $N = 2^n$.

2. Specializing to One Qubit (N = 2)

Now, let us examine what happens when we set the number of qubits to $n = 1$, which gives $N = 2^1 = 2$. The summation runs over only two values: $y = 0$ and $y = 1$:

QFT |x⟩ = ( 1 / √2 ) ∑ [ e^(2π i x y / 2) ] |y⟩
        = ( 1 / √2 ) ∑ [ e^(i π x y) ] |y⟩
        = ( 1 / √2 ) [ e^(i π x · 0) |0⟩ + e^(i π x · 1) |1⟩ ]
        = ( 1 / √2 ) [ |0⟩ + e^(i π x) |1⟩ ]

Notice how drastically the phase factor simplifies:

$e^{2\pi i x y / 2}$ simplifies immediately to $e^{i \pi x y}$.
Because $y \in {0, 1}$, the first term is always $e^0 = 1$.
This leaves only the single phase factor $e^{i \pi x}$ multiplying the $|1\rangle$ component.

3. Evaluating Basis States |0⟩ and |1⟩

A single qubit has only two computational basis inputs: $x = 0$ and $x = 1$. Let us evaluate each:

Case 1: When $x = 0$

Substitute $x = 0$ into the phase term $e^{i \pi \cdot 0} = e^0 = 1$:

QFT |0⟩ = ( 1 / √2 ) [ |0⟩ + e^(i π · 0) |1⟩ ]
        = ( |0⟩ + |1⟩ ) / √2
        = |+⟩ ≡ H |0⟩

Case 2: When $x = 1$

Substitute $x = 1$ into the phase term using Euler's identity ($e^{i \pi} = -1$):

QFT |1⟩ = ( 1 / √2 ) [ |0⟩ + e^(i π · 1) |1⟩ ]
        = ( |0⟩ - |1⟩ ) / √2
        = |-⟩ ≡ H |1⟩

The Matrix Identity

Because the QFT transforms $|0\rangle \to |+\rangle$ and $|1\rangle \to |-\rangle$, its $2 \times 2$ unitary matrix representation is:

F₂ = ( 1 / √2 ) × [ [ 1,  1 ],
                    [ 1, -1 ] ] ≡ H

Thus, the single-qubit Quantum Fourier Transform and the single-qubit Hadamard gate are literally the exact same unitary operator!

4. Verifying the Equivalence in Qiskit 2.x

In Qiskit 2.x, the Quantum Fourier Transform is available as QFTGate in qiskit.circuit.library. When we decompose a 1-qubit QFTGate, Qiskit compiles it directly into a single H gate:

Here is a reproducible script in Qiskit 2.x verifying that the Frobenius norm difference between QFTGate(1) and Operator.from_label('H') is zero down to machine precision ($10^{-16}$):

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFTGate
from qiskit.quantum_info import Operator

# 1. Build circuit with 1-qubit QFT
qc = QuantumCircuit(1)
qc.append(QFTGate(1), [0])

# 2. Decompose the gate into elementary operations
qc_decomposed = qc.decompose()
print("Decomposed 1-Qubit QFT Circuit:")
print(qc_decomposed)

# 3. Extract the Unitary Matrix Operators
op_qft = Operator(qc).data
op_hadamard = Operator.from_label('H').data

print("\n1-Qubit QFT Matrix:")
print(np.round(op_qft, 4))

print("\nStandard Hadamard Matrix:")
print(np.round(op_hadamard, 4))

# 4. Verify mathematical equivalence
diff = np.linalg.norm(op_qft - op_hadamard)
print(f"\nFrobenius Norm Difference: {diff:.2e}")
print(f"Equivalence Verified    : {np.allclose(op_qft, op_hadamard)}")

Execution Output:

Decomposed 1-Qubit QFT Circuit:
   ┌───┐
q: ┤ H ├
   └───┘

1-Qubit QFT Matrix:
[[ 0.7071+0.j  0.7071+0.j]
 [ 0.7071+0.j -0.7071+0.j]]

Standard Hadamard Matrix:
[[ 0.7071+0.j  0.7071+0.j]
 [ 0.7071+0.j -0.7071+0.j]]

Frobenius Norm Difference: 2.38e-16
Equivalence Verified    : True

5. Frequently Asked Questions

Is the QFT of one qubit the exact same as the Hadamard gate?

Yes. Working through the $N = 2$ case of the QFT definition shows that $\text{QFT}|0\rangle = |+\rangle$ and $\text{QFT}|1\rangle = |-\rangle$, which are identical to the outputs of a Hadamard gate on the same inputs. For one qubit, QFT and $H$ are literally the exact same unitary operator.

What is the Quantum Fourier Transform used for in quantum algorithms?

The QFT is the foundational engine of Quantum Phase Estimation (QPE) and Shor's Factoring Algorithm. It converts periodic phase differences into measurable computational basis states, allowing a quantum computer to find periods exponentially faster than any classical algorithm.

How does the multi-qubit QFT generalize beyond 1 qubit?

When multiple qubits are involved ($n > 1$), the QFT cannot be achieved with independent Hadamard gates alone. It requires an interlocking ladder of Hadamards and controlled phase rotation gates ($R_k$), followed by SWAP gates to reverse qubit order:

R_k = [ [ 1,        0        ],
        [ 0,  e^(2π i / 2^k) ] ]

The 1-qubit case is the unique scenario where all controlled rotations vanish, leaving only the lone Hadamard transformation.

Key Insights & Takeaways

One-Qubit Equivalence: Setting $N = 2$ in the discrete quantum Fourier transform collapses the general phase sum to $(|0\rangle + e^{i \pi x}|1\rangle) / \sqrt{2}$.
Euler's Identity at Work: Because $e^{i \pi \cdot 0} = +1$ and $e^{i \pi \cdot 1} = -1$, the QFT turns $|0\rangle \to |+\rangle$ and $|1\rangle \to |-\rangle$—the hallmark behavior of the Hadamard gate.
The Stepping Stone to Multi-Qubit QFT: Understanding the 1-qubit case is essential before studying how controlled phase rotations generalize the QFT to Shor's algorithm and period finding.

Continue the Quantum Series

← Previous: Superdense Coding Explained: Transmitting 2 Classical Bits in 1 Qubit (Module 3b)
Foundations: Two-Qubit Entanglement & The 4 Bell States (Module 3)
Next: The Walsh-Hadamard Matrix: Backbone of Grover's Diffusion Operator (Module 5) →
Roadmap: Quantum Computing: A Complete Learning Path

Superdense Coding Explained: Transmitting 2 Classical Bits in 1 Qubit with Qiskit 2.x

Malcolm Low — Sun, 27 Sep 2026 04:55:10 +0000

Module 3b in the Quantum Computing: A Complete Learning Path series. Following directly from Two-Qubit Entanglement & The 4 Bell States (Module 3) and bridging the transition to Quantum Teleportation (Module 9).

In classical information theory, transmitting two bits of information (such as 00, 01, 10, or 11) strictly requires sending two physical signals. If you have only a single physical wire or send a single classical pulse, the laws of physics dictate that you can transmit at most one bit of data. In quantum information theory, a celebrated theorem known as Holevo's Bound (1973) proved that an isolated single qubit can likewise communicate at most one bit of classical information.

Yet, in 1992, physicists Charles Bennett and Stephen Wiesner discovered a startling loophole: if the sender and receiver share an entangled pair of qubits beforehand, the sender can physically transmit just one single qubit and deliver two full classical bits with 100% deterministic accuracy. This protocol is called Superdense Coding (or Dense Coding).

In this guide, we break down the mechanics of superdense coding, demonstrate how Alice transforms the shared Bell pair using local Pauli gates, analyze Bob's deterministic Bell decoder, and verify the protocol using Qiskit 2.x with circuit diagrams.

1. The Communication Limit: Holevo’s Bound vs. Entanglement

To appreciate why superdense coding is remarkable, we must first understand the fundamental limit on quantum communication:

Holevo's Bound (Without Entanglement):
1 Transmitted Qubit → At most 1 Accessible Classical Bit

Superdense Coding (With 1 Pre-Shared Bell Pair):
1 Transmitted Qubit → Exactly 2 Accessible Classical Bits

Even though a single qubit pure state $|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$ contains continuous complex amplitudes $\alpha$ and $\beta$ (an infinite amount of theoretical mathematical parameters), any measurement causes the qubit to collapse into either $|0\rangle$ or $|1\rangle$. Therefore, a receiver without prior entanglement can never extract more than 1 classical bit of information from a single qubit.

How does superdense coding bypass this? It does not violate Holevo’s bound because entanglement acts as a physical communication resource. The two classical bits are not crammed into the single transmitted qubit alone. Instead, the transmitted qubit acts as an address key that unlocks the correlation already stored in the shared two-qubit entangled system.

2. The 4-Step Protocol: Alice, Bob, and Charlie

The superdense coding protocol unfolds across four sequential stages between three actors: a source (Charlie), the sender (Alice), and the receiver (Bob):

Step 1 — Entanglement Distribution: Charlie prepares an entangled Bell pair $|\Phi^+\rangle = (|00\rangle + |11\rangle) / \sqrt{2}$. He sends qubit 0 ($q_0$) to Alice and qubit 1 ($q_1$) to Bob. Alice and Bob can now be arbitrarily far apart.
Step 2 — Alice’s Local Encoding: Alice wants to send a 2-bit message $m \in {00, 01, 10, 11}$. She applies a single local Pauli gate ($I$, $Z$, $X$, or $ZX$) to her qubit $q_0$ only. She never touches Bob’s qubit.
Step 3 — Physical Transmission: Alice sends her single physical qubit $q_0$ over a quantum communication channel (such as an optical fiber) to Bob.
Step 4 — Bob’s Bell Basis Decoding: Bob now holds both qubits ($q_0$ and $q_1$). He runs the Bell Basis Decoder (a CNOT gate followed by a Hadamard on $q_0$) and measures both qubits in the computational basis, reading Alice’s 2-bit message with 100% deterministic certainty.

Circuit 1: The complete Superdense Coding protocol showing Entanglement Preparation, Alice’s Local Encoding, and Bob’s Bell Basis Decoder.

3. The 4 Encoding Operations: From Bits to Bell States

In Module 3 (The 4 Bell States), we discovered that the 4 Bell states form an orthonormal basis for two qubits. Alice's brilliance in superdense coding is that by applying only local single-qubit gates to her half of $|\Phi^+\rangle$, she can steer the joint two-qubit state into any one of the four orthogonal Bell states:

Case 1: Message `00` — Identity Gate $I$

Alice leaves her qubit untouched (applies Identity $I$). The joint state remains the original Bell state $|\Phi^+\rangle$:

(I ⊗ I) |Φ+⟩ = ( |00⟩ + |11⟩ ) / √2 = |Φ+⟩

Circuit 2: Superdense coding for message 00 (Identity gate on q_0 → Bob measures 00).

Case 2: Message `01` — Pauli-Z Gate $Z$ (Phase-Flip)

(Z ⊗ I) |Φ+⟩ = ( |00⟩ - |11⟩ ) / √2 = |Phi-⟩

Circuit 3: Superdense coding for message 01 (Z gate on q_0 → Bob measures 01).

Case 3: Message `10` — Pauli-X Gate $X$ (Bit-Flip)

(X ⊗ I) |Φ+⟩ = ( |10⟩ + |01⟩ ) / √2 = |Ψ+⟩

Circuit 4: Superdense coding for message 10 (X gate on q_0 → Bob measures 10).

Case 4: Message `11` — Both Gates $ZX$ (Bit & Phase Flip)

Alice applies both $Z$ and $X$ gates (or $iY$). This flips both the bit values and the relative sign, transforming the state into the Singlet state $|\Psi^-\rangle$ (up to global phase):

(ZX ⊗ I) |Φ+⟩ = ( -|01⟩ + |10⟩ ) / √2 = -|Ψ-⟩ ≡ |Ψ-⟩

Circuit 5: Superdense coding for message 11 (Z followed by X on q_0 → Bob measures 11).

Superdense Coding Protocol Truth Table

Target Message	Alice's Local Gate	Encoded Bell State	Bob's Decoder ($CX \to H$)	Measured Classical Bits
`00`	$I$ (None)	$\	\Phi^+\rangle$	$\
`01`	$Z$ (Phase-Flip)	$\	\Phi^-\rangle$	$\
`10`	$X$ (Bit-Flip)	$\	\Psi^+\rangle$	$\
`11`	$ZX$ (Bit & Phase)	$\	\Psi^-\rangle$	$\

4. Why Superdense Coding Cannot Transmit Faster Than Light

A natural question arises: If Alice applies her encoding gate immediately on qubit 0, does Bob instantly receive her message across the universe?

Can Bob read Alice's message before receiving her qubit?
Answer: NO. Bob's qubit in isolation is in a Maximally Mixed State (|r| = 0).

As we established in Module 3, as long as Bob holds only qubit $q_1$ in isolation, his reduced density matrix is identical regardless of which gate Alice applied:

If Alice applies $I$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)
If Alice applies $Z$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)
If Alice applies $X$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)
If Alice applies $ZX$: Bob's local state is 50% $|0\rangle$, 50% $|1\rangle$ (pure noise)

No measurement Bob performs on his own qubit alone can reveal any information about which gate Alice selected! Zero information is transmitted until Alice physically transports qubit $q_0$ across space to Bob. Because the physical transmission of a qubit is bounded by the speed of light $c$, Einstein's causality is rigorously preserved.

5. The Quantum Resource Duality: Superdense Coding vs. Teleportation

Superdense coding and Quantum Teleportation (Module 9) form the fundamental dual pillars of quantum communication. They represent the exact reciprocal exchange rate between quantum and classical channels:

Feature	Superdense Coding (Module 3b)	Quantum Teleportation (Module 9)
Objective	Transmit 2 classical bits	Transmit 1 unknown quantum state
Pre-Shared Resource	1 shared Bell pair ($\|\Phi^+\rangle$)	1 shared Bell pair ($\|\Phi^+\rangle$)
Channel Transmitted	1 physical qubit (quantum channel)	2 classical bits (classical radio/fiber)
Information Exchange	1 e-bit + 1 qubit $\to$ 2 classical bits	1 e-bit + 2 classical bits $\to$ 1 qubit

In both protocols, 1 Bell pair (1 e-bit of entanglement) acts as a currency that doubles the power of the transmitted channel!

6. Complete Qiskit 2.x Python Implementation

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

def build_superdense_circuit(message: str) -> QuantumCircuit:
    """
    Builds an end-to-end Superdense Coding circuit in Qiskit 2.x.
    """
    qc = QuantumCircuit(2, 2)

    # --- PHASE 1: PRE-SHARED ENTANGLEMENT (Charlie) ---
    qc.h(0)
    qc.cx(0, 1)
    qc.barrier(label="Bell Pair")

    # --- PHASE 2: ALICE'S LOCAL ENCODING (on qubit 0) ---
    if message == "00":
        qc.id(0)          # Identity: do nothing
    elif message == "01":
        qc.z(0)           # Phase-flip: |Phi+> -> |Phi->
    elif message == "10":
        qc.x(0)           # Bit-flip:   |Phi+> -> |Psi+>
    elif message == "11":
        qc.z(0)
        qc.x(0)           # Bit & Phase: |Phi+> -> -|Psi->
    else:
        raise ValueError("Message must be '00', '01', '10', or '11'")

    qc.barrier(label="Alice Transmits q0")

    # --- PHASE 3: BOB'S BELL BASIS DECODER ---
    qc.cx(0, 1)
    qc.h(0)
    qc.barrier(label="Bob Decodes")

    # Measure both qubits into classical register
    qc.measure([0, 1], [0, 1])
    return qc

# --- SIMULATION & VERIFICATION OF ALL 4 MESSAGES ---
print("=== Superdense Coding Simulation (Qiskit 2.x) ===\n")

test_messages = ["00", "01", "10", "11"]

for msg in test_messages:
    qc = build_superdense_circuit(msg)
    qc_no_meas = qc.remove_final_measurements(inplace=False)

    sv = Statevector(qc_no_meas)
    probs = sv.probabilities_dict()
    formatted_probs = {k: round(float(v), 2) for k, v in probs.items() if v > 1e-6}

    print(f"Target Message Sent : '{msg}'")
    print(f"Bob's Decoded State : {formatted_probs}")
    print(f"Verification Status : {'PASS (100% Certainty)' if msg in formatted_probs and formatted_probs[msg] == 1.0 else 'FAIL'}")
    print("-" * 45)

Execution Output:

=== Superdense Coding Simulation (Qiskit 2.x) ===

Target Message Sent : '00'
Bob's Decoded State : {'00': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Target Message Sent : '01'
Bob's Decoded State : {'01': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Target Message Sent : '10'
Bob's Decoded State : {'10': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------
Target Message Sent : '11'
Bob's Decoded State : {'11': 1.0}
Verification Status : PASS (100% Certainty)
---------------------------------------------

Key Insights & Takeaways

Entanglement Doubles Classical Capacity: With one pre-shared Bell pair, transmitting 1 physical qubit transfers 2 classical bits deterministically.
Local Gates Steer Global States: Alice applies local Pauli operations ($I$, $Z$, $X$, $ZX$) to her qubit alone, yet changes the joint entanglement basis into one of the 4 orthogonal Bell states.
No FTL Communication: Bob gains zero bits of information until Alice’s physical qubit arrives through space. Causality is strictly maintained.
The Teleportation Duality: Superdense coding trades 1 qubit for 2 classical bits; quantum teleportation trades 2 classical bits for 1 qubit.

Continue the Quantum Series:

← Previous: Two-Qubit Entanglement Explained: The 4 Bell States and Qiskit Implementation (Module 3)
→ Next: The One-Qubit QFT & Hadamard Transform (Module 4)
Dual Protocol: Quantum Teleportation, and Why It Isn’t Cloning (Module 9)
Learning path: View the complete Quantum Computing learning path →

Two-Qubit Entanglement Explained: The 4 Bell States and Qiskit Implementation

Malcolm Low — Sun, 27 Sep 2026 04:54:43 +0000

Module 3 in the Quantum Computing: A Complete Learning Path series. Bridging the transition from single-qubit geometry in Bloch Sphere Explained (Module 2) to multi-qubit communication in Superdense Coding (Module 3b) and Quantum Teleportation (Module 9).

In single-qubit quantum mechanics, every pure state can be visualized as a vector pointing to a point on the surface of the three-dimensional Bloch sphere. However, as soon as a second qubit enters the system, quantum physics reveals its most distinctive phenomenon: quantum entanglement.

When two qubits become entangled, the state of the composite system can no longer be described by the independent states of its individual components. Individual qubits lose their independent identity, single-qubit Bloch vectors collapse into the interior of the sphere as mixed states, and measurements on separated particles exhibit correlations that cannot be explained by classical probability.

In this guide, we build two-qubit entanglement from first principles: defining mathematical non-separability, synthesizing the four maximally entangled Bell states (EPR pairs), deriving the Bell basis decoder, and running verifiable code in Qiskit 2.x with Matplotlib circuit diagrams.

1. What is Entanglement? Mathematical Non-Separability

To understand what entanglement is, we must first understand what it is not. Consider two independent qubits, A and B, each in a general superposition state:

|ψ_A⟩ = α₀ |0⟩ + α₁ |1⟩,    |ψ_B⟩ = β₀ |0⟩ + β₁ |1⟩

The joint state of the two qubits is given by the tensor product $|a⟩ \otimes |b⟩$:

|ψ_joint⟩ = α₀β₀ |00⟩ + α₀β₁ |01⟩ + α₁β₀ |10⟩ + α₁β₁ |11⟩

Any two-qubit state that can be factored into such a tensor product is called a product state (or separable state). Now, consider the canonical Bell state:

|Φ+⟩ = ( |00⟩ + |11⟩ ) / √2

The Non-Separability Proof:

Can we choose single-qubit coefficients $\alpha_0, \alpha_1, \beta_0, \beta_1$ such that $|\psi_{\text{joint}}\rangle = |\Phi^+\rangle$? Matching coefficients requires:

$\alpha_0 \beta_0 = 1 / \sqrt{2}$
$\alpha_1 \beta_1 = 1 / \sqrt{2}$
$\alpha_0 \beta_1 = 0 \implies$ either $\alpha_0 = 0$ or $\beta_1 = 0$
$\alpha_1 \beta_0 = 0 \implies$ either $\alpha_1 = 0$ or $\beta_0 = 0$

If $\alpha_0 = 0$, then $\alpha_0 \beta_0 = 0 \neq 1 / \sqrt{2}$, a contradiction! If $\beta_1 = 0$, then $\alpha_1 \beta_1 = 0 \neq 1 / \sqrt{2}$, another contradiction!

No single-qubit states $|\psi_A\rangle$ and $|\psi_B\rangle$ exist whose product equals $|\Phi^+\rangle$. The state is mathematically non-separable: it exists solely as an indivisible two-qubit entity.

2. The Controlled-NOT (CNOT) Gate: Generating Entanglement

Single-qubit operations (such as Hadamard $H$, Pauli $X$, or Phase $Z$) are local unitaries ($U_A \otimes U_B$). By definition, a local unitary applied to a separable state produces another separable state—it can never create entanglement from scratch.

To generate entanglement, we need an interaction between qubits. The universal two-qubit entangler is the Controlled-NOT (CNOT or $CX$) gate. It leaves the control qubit unchanged and flips the target qubit if and only if the control qubit is $|1\rangle$:

CX |00⟩ = |00⟩,    CX |01⟩ = |01⟩,    CX |10⟩ = |11⟩,    CX |11⟩ = |10⟩

The Entanglement Recipe:

When a CNOT is fed an unentangled product state where the control qubit is in superposition:

|ψ⟩ = |+⟩ |0⟩ = [ (|0⟩ + |1⟩) / √2 ] ⊗ |0⟩ = ( |00⟩ + |10⟩ ) / √2

CX |ψ⟩ = ( CX|00⟩ + CX|10⟩ ) / √2 = ( |00⟩ + |11⟩ ) / √2 = |Φ+⟩

The CNOT couples the control's superposition to the target's bit value, fusing the two independent states into a single entangled state.

3. The 4 Maximally Entangled Bell States (EPR Pairs)

The 4 Bell states form an orthonormal basis for the entire two-qubit Hilbert space $\mathbb{C}^4$, known as the Bell basis:

1. State |Φ+⟩ = ( |00⟩ + |11⟩ ) / √2 — (Correlated, Positive Phase)

Prepared from $|00\rangle$ via $H(q_0)$ followed by $CX(q_0, q_1)$:

Circuit 1: Preparation of |Φ+⟩ from ground state |00⟩.

2. State |Φ−⟩ = ( |00⟩ − |11⟩ ) / √2 — (Correlated, Negative Phase)

Prepared by applying an $X$ gate (or $Z$ gate) to $q_0$ before the Hadamard, creating $|-\rangle \otimes |0\rangle$ before the CNOT:

Circuit 2: Preparation of |Φ−⟩ with relative minus phase.

3. State |Ψ+⟩ = ( |01⟩ + |10⟩ ) / √2 — (Anti-Correlated, Positive Phase)

Prepared by flipping the target qubit $q_1$ with an $X$ gate, so the CNOT flips $|01\rangle \leftrightarrow |10\rangle$:

Circuit 3: Preparation of |Ψ+⟩ with bit-flip anti-correlation.

4. State |Ψ−⟩ = ( |01⟩ − |10⟩ ) / √2 — (The Singlet State)

Prepared with $X$ gates on both qubits before the entangling layer. $|\Psi^-\rangle$ is the unique anti-symmetric singlet state with total spin $S = 0$, making it invariant under arbitrary simultaneous bilateral rotations:

Circuit 4: Preparation of the rotationally invariant Singlet State |Ψ−⟩.

Bell Basis Properties Matrix

Bell State	Input State	Statevector Expression	Correlation Type	Allowed Outcomes
\|Φ+⟩	\|00⟩	( \|00⟩ + \|11⟩ ) / √2	Correlated (Even Parity)	`00` (50%), `11` (50%)
\|Φ−⟩	\|10⟩	( \|00⟩ − \|11⟩ ) / √2	Correlated (Even Parity)	`00` (50%), `11` (50%)
\|Ψ+⟩	\|01⟩	( \|01⟩ + \|10⟩ ) / √2	Anti-Correlated (Odd Parity)	`01` (50%), `10` (50%)
\|Ψ−⟩	\|11⟩	( \|01⟩ − \|10⟩ ) / √2	Anti-Correlated (Singlet)	`01` (50%), `10` (50%)

4. Why the Bloch Sphere Fails for Entangled Qubits

In Module 2 (Bloch Sphere Explained), we saw that any standalone qubit pure state points to the surface of the three-dimensional Bloch sphere with radius |r| = 1. What happens to the Bloch vector of qubit A when it is entangled in |Φ+⟩?

Single Qubit (Pure State)  : |r| = 1  (Points to sphere surface)
Entangled Qubit (Isolated) : |r| = 0  (Collapses to dead center)

Because an entangled state cannot be factored into independent parts, qubit A does not have a pure state of its own. If you measure qubit A in isolation along any axis (X, Y, or Z), you observe pure 50/50 random noise:

Expectation along $X$: $\langle X \rangle = 0$
Expectation along $Y$: $\langle Y \rangle = 0$
Expectation along $Z$: $\langle Z \rangle = 0$

With all three coordinates vanishing (r_x = 0, r_y = 0, r_z = 0), qubit A collapses into a maximally mixed state at the exact center of the sphere (|r| = 0). The Bloch sphere is fundamentally a single-qubit geometry tool—it cannot visualize entanglement because none of the information belongs to qubit A or qubit B alone. All the information resides exclusively in the joint correlations between them.

5. Reversing Entanglement: The Bell Basis Analyzer

If we measure $|\Phi^+\rangle$ and $|\Phi^-\rangle$ directly in the computational basis, both produce 00 (50%) and 11 (50%). How can an experimenter distinguish all four Bell states deterministically?

Because quantum circuits are unitary and reversible, we apply the inverse of the Bell preparation circuit: a CNOT gate followed by a Hadamard on the control qubit ($CX \to H$):

Circuit 5: The Bell Basis Decoder (CX followed by H) rotates the 4 entangled states back to the computational basis.

This transformation maps the 4 entangled Bell states back into the 4 classical basis bitstrings with 100% deterministic certainty:

$|\Phi^+\rangle \to$ 00 (100%)
$|\Phi^-\rangle \to$ 01 (100%)
$|\Psi^+\rangle \to$ 10 (100%)
$|\Psi^-\rangle \to$ 11 (100%)

This decoder is the foundational building block for Superdense Coding (Module 3b) (transmitting 2 classical bits using only 1 physical qubit) and the receiver measurement in Quantum Teleportation (Module 9).

6. Complete Qiskit 2.x Implementation

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector, DensityMatrix, partial_trace

def build_bell_state(state_name: str) -> QuantumCircuit:
    qc = QuantumCircuit(2, 2)
    if state_name == "Phi+":
        qc.h(0)
        qc.cx(0, 1)
    elif state_name == "Phi-":
        qc.x(0)
        qc.h(0)
        qc.cx(0, 1)
    elif state_name == "Psi+":
        qc.x(1)
        qc.h(0)
        qc.cx(0, 1)
    elif state_name == "Psi-":
        qc.x(0)
        qc.x(1)
        qc.h(0)
        qc.cx(0, 1)
    return qc

def bell_basis_decoder() -> QuantumCircuit:
    dec = QuantumCircuit(2, 2)
    dec.cx(0, 1)
    dec.h(0)
    dec.measure([0, 1], [0, 1])
    return dec

bell_states = ["Phi+", "Phi-", "Psi+", "Psi-"]
print("=== 4 Bell States Generation & Verification ===\n")

for name in bell_states:
    prep = build_bell_state(name)
    sv = Statevector(prep)

    # Run through the Bell Basis Decoder
    full_circuit = prep.compose(bell_basis_decoder())
    full_sv = Statevector(full_circuit.remove_final_measurements(inplace=False))

    probs = {k: round(float(v), 2) for k, v in full_sv.probabilities_dict().items() if v > 1e-4}

    print(f"State |{name}>:")
    print(f"  Statevector: {np.round(sv.data, 3)}")
    print(f"  Bell Basis Decoder Outcome: {probs}\n")

# Verify Bloch radius collapse for Qubit A
phi_plus_sv = Statevector(build_bell_state("Phi+"))
rho_total = DensityMatrix(phi_plus_sv)
rho_A = partial_trace(rho_total, [1])
purity = np.real(np.trace(rho_A.data @ rho_A.data))
print(f"Reduced Density Matrix of Qubit A:\n{np.round(rho_A.data, 3)}")
print(f"Purity Tr(rho_A^2): {purity:.2f} (0.50 = Maximally Mixed, Bloch radius r = 0)")

Execution Output:

=== 4 Bell States Generation & Verification ===

State |Phi+>:
  Statevector: [0.707+0.j 0.   +0.j 0.   +0.j 0.707+0.j]
  Bell Basis Decoder Outcome: {'00': 1.0}

State |Phi->:
  Statevector: [ 0.707+0.j  0.   +0.j  0.   +0.j -0.707+0.j]
  Bell Basis Decoder Outcome: {'01': 1.0}

State |Psi+>:
  Statevector: [0.   +0.j 0.707+0.j 0.707+0.j 0.   +0.j]
  Bell Basis Decoder Outcome: {'10': 1.0}

State |Psi->:
  Statevector: [ 0.   +0.j -0.707+0.j  0.707+0.j  0.   +0.j]
  Bell Basis Decoder Outcome: {'11': 1.0}

Reduced Density Matrix of Qubit A:
[[0.5+0.j 0. +0.j]
 [0. +0.j 0.5+0.j]]
Purity Tr(rho_A^2): 0.50 (0.50 = Maximally Mixed, Bloch radius r = 0)

Key Insights & Takeaways

Entanglement is Non-Factorability: An entangled state cannot be written as $|a\rangle \otimes |b\rangle$. The whole possesses definite physical properties that do not exist in the parts.
Local Randomness vs. Global Certainty: Measuring one qubit of a Bell pair yields pure 50/50 randomness ($r = 0$). Yet, the two-qubit joint correlation is 100% deterministic.
The Quantum Information Backbone: Without the Bell basis, neither Superdense Coding nor Quantum Teleportation could exist.

Continue the Quantum Series:

← Previous: Bloch Sphere Explained: Basis States and the X and Z Gates (Module 2)
→ Next: Superdense Coding Explained: Transmitting 2 Classical Bits in 1 Qubit (Module 3b)
Learning path: View the complete Quantum Computing learning path →

Pocket Data Science IV: Tackling Kaggle MNIST on Android with Antigravity CLI

Malcolm Low — Sun, 27 Sep 2026 02:04:03 +0000

💻 GitHub Repository: All 10 self-contained experiment scripts, requirements, and reproduction instructions are published open-source on GitHub: myhlow/kaggle-digit-recognizer-mnist.

A hands-on walkthrough exploring computer vision baselines on Kaggle's Digit Recognizer (MNIST) benchmark: from empirical random guessing and prototype centroid templates to multinomial softmax regression and PCA-accelerated non-linear ensembles on an Android phone running Termux and Google Antigravity CLI.

In our previous explorations across the Pocket Data Science series (Titanic, Spaceship Titanic, and House Prices), we established disciplined, reproducible machine learning workflows on mobile hardware using Google Antigravity CLI (agy) inside a Termux Linux environment.

In this fourth installment, we step into computer vision using the classic Kaggle Digit Recognizer (MNIST) benchmark (42,000 training images, 28,000 test images, 784 grayscale pixels each).

Instead of jumping straight into heavy convolutional neural networks or spinning up cloud GPUs, we maintained our strict experimental discipline: understanding empirical priors, zero-learning prototype templates, linear decision frontiers, and memory-conscious non-linear ensembles running strictly on an ARM64 smartphone processor.

Across 10 distinct experiments over 2 days, our submissions climbed from naive random guessing (0.10139) all the way to 0.98792 (Rank #406 of 863 teams, Top 47.05%, beating 457 teams).

Here is the complete engineering breakdown of what each layer contributed and the mathematical mechanics behind the leaps.

1 · The Mobile ML Environment

All data loading, matrix transformations, cross-validation, and Kaggle submissions were executed natively on a consumer smartphone:

Host Architecture: Android 14 running Termux with a Debian userspace via PRoot Distro on 64-bit ARM (aarch64).
Agentic CLI: Google Antigravity CLI (agy) pair-programming in bash, managing background tasks, and verifying data pipelines.
Environment: Python 3.14 with pandas, numpy, scipy, scikit-learn, and the official kaggle CLI.
Constraints: Operating within smartphone RAM and thermal limits requires algorithmic efficiency—such as avoiding raw $\mathcal{O}(N^2)$ distance calculations across $42,000 \times 28,000 \times 784$ floating-point matrices.

2 · The 10-Tier Ladder (Day 1 & Day 2 Results)

Below is the chronological sequence of our 10 submissions evaluated against Kaggle's public test set (28,000 unseen images):

Exp	Model & Strategy	CV Accuracy	Kaggle Public Score	LB Rank	Percentile	Teams Beaten
Exp 01	Empirical Random Prior	N/A	`0.10139` (10.14%)	#847	Bottom 1.9%	16
Exp 02	Majority Class Baseline (Digit 1)	11.35%	`0.11403` (11.40%)	#846	Bottom 2.0%	17
Exp 03	Nearest Centroid ("Ghost Templates")	82.04%	`0.81446` (81.45%)	#835	Bottom 3.2%	28
Exp 04	Multinomial Softmax Logistic Regression	92.56%	`0.92089` (92.09%)	#806	Bottom 6.6%	57
Exp 05	Latent Ensemble: PCA(55) + k-NN + ExtraTrees	97.46%	`0.97578` (97.58%)	#568	Top 65.9%	294
Exp 06	Tri-Blend: Deep MLP + k-NN + ExtraTrees	97.98%	`0.98085` (98.09%)	#523	Top 60.7%	339
Exp 07	Orthogonal Subspace SVM: PCA(55) + RBF-SVM	98.60%	`0.98453` (98.45%)	#487	Top 56.4%	376
Exp 08	Dual Meta-Ensemble: 90% RBF-SVM + 10% MLP	98.66%	`0.98514` (98.51%)	#481	Top 55.7%	382
Exp 09	2× Translation-Augmented Subspace SVM (84k)	98.68%	`0.98696` (98.70%)	#438	Top 50.8%	425
Exp 10	3× Dual-Axis Augmented Subspace SVM (126k)	98.78%	`0.98792` (98.79%)	#406	Top 47.05%	457

(Note: Leaderboard statistics based on 863 active teams on Kaggle as of September 2026).

3 · Tier 1: Zero-Training Baselines & "Ghost Templates"

Before training parameterized models, baseline tests define the floor of predictability:

Empirical Random Guessing (10.14%): Sampling labels according to the empirical training class distribution matched theoretical expectation for 10 balanced classes (~10%).
Constant Majority Class (11.40%): Digit 1 is slightly more frequent than others (4,684 of 42,000 samples, or 11.15%). Predicting 1 for all 28,000 test images yielded 11.40% on Kaggle.
Nearest Centroid Classifier (81.45%): By calculating the element-wise arithmetic mean of all 4,200 training images per digit class, we obtain 10 average "ghost templates". Classifying each test image to the template with highest cosine similarity requires zero parameter tuning or gradient updates, yet hits 81.45% accuracy, demonstrating the strong geometric separation already inherent in raw pixel space.

4 · Tier 2: Linear Frontier to Latent Subspace Ensembles

Multinomial Softmax Regression (92.09%): Fitting a single convex linear layer $(W \in \mathbb{R}^{10 \times 784}, b \in \mathbb{R}^{10})$ using L-BFGS convergence in 16.5 seconds established the limit of linear hyperplanes.
The Classical Latent Ensemble (97.58%): Non-linear models in raw 784-dimensional space are prohibitively slow on mobile CPUs. By projecting into an orthogonal 55-component PCA subspace (retaining 83.2% variance), we compressed the dataset by 14.25×. An ensemble blending 5-Nearest Neighbors and ExtraTrees (150 trees) on this subspace fit in 18.7 seconds and jumped 238 ranks on the leaderboard (0.92089 $\to$ 0.97578).
The Neural Tri-Blend (98.09%): Adding a 4-layer Deep Multi-Layer Perceptron (256-128-ReLU with Adam and early stopping) to the latent ensemble pushed past 98% accuracy on Day 1.

5 · Day 2: Subspace Support Vector Machines & Spatial Manifolds

On Day 2, we systematically evaluated single models versus meta-ensembles and investigated spatial invariance:

Mobile Compute & Throughput Benchmark

Pipeline / Model	Architecture	Val Fit (5k CV)	Val Acc	Full Fit (Train)	Test Inference (28k)	Throughput
Deep MLP Baseline	Raw 784px $\to$ MLP(256, 128)	27.8s	98.18%	344.4s (5.7 min)	2.5s	~11,200 img/s
Raw RBF-SVM	Raw 784px $\to$ RBF-SVC(C=5)	148.6s	98.24%	~25 min (est.)	N/A	High latency
Subspace RBF-SVM (Exp 07)	PCA(55) $\to$ RBF-SVC(C=5)	7.2s	98.60%	22.5s (42k train)	19.6s	~1,425 img/s
Dual Meta-Ensemble (Exp 08)	90% Subspace SVM + 10% MLP	364.6s	98.66%	544.1s (9.1 min)	36.7s	~763 img/s
Augmented Subspace SVM (Exp 09)	2× Spatial Jitter + PCA(55) + SVM	50.8s (74k)	98.68%	51.4s (84k train)	52.9s	~529 img/s
Dual-Axis Aug SVM (Exp 10)	3× Spatial Jitter + PCA(55) + SVM	91.8s (111k)	98.78%	205.6s (3.4 min, 126k)	168.9s (2.8 min)	~166 img/s

Key Technical Insights

The Latent Space Denoising Win:
Projecting onto a 55-dimensional orthogonal subspace did not just accelerate training—it acted as an optimal low-pass filter against boundary pixel noise. Subspace SVM achieved 98.60% validation accuracy versus 98.24% on uncompressed 784 pixels while training 17× faster (7.2s vs 148.6s).
The Dual-Axis Spatial Augmentation Breakthrough:
Standard RBF kernels have no native translation invariance—shifting a handwritten digit by just 1 pixel changes its Euclidean distance in pixel space significantly. In Experiment 10, tripling the training partition to 126,000 samples by generating systematic horizontal (±1px on the X-axis) and vertical (±1px on the Y-axis) translational shifts provided complete 2D shift-invariance.
Fitting the 126,000-sample pipeline took just 3.4 minutes on mobile CPU and propelled our Kaggle score to 0.98792 (Rank #406 / Top 47.05%, beating 457 teams)!

6 · Day 2 Milestone Achieved: Top 47.05% on Mobile Hardware (Rank #406 / 863)

With Experiment 10 scoring 0.98792, we officially crossed the Top 50% cutoff (0.98739, Rank #431) to claim Rank #406 out of 863 active teams worldwide.

Zero GPU Resources: The entire progression—from empirical random guessing (0.10139) to classical ensembles (0.97578) and 126k dual-axis augmented subspace SVM (0.98792)—was engineered, trained, and submitted entirely on an Android smartphone CPU via Termux and Antigravity CLI.
Looking Ahead to Day 3: With all 5 daily submissions successfully completed for Day 2, our next frontier is custom lightweight Convolutional Neural Networks (LeNet-5 & Modern Compact ResNets) built directly on PyTorch ARM64 to break into the Top 20%.

Pocket Data Science Series · Tested on Android 14 / Termux · Debian ARM64 PRoot · Google Antigravity CLI

All experiment scripts (exp01_random_baseline.py through exp10_dual_axis_augmented_svm.py) and submissions are archived locally in /root/digit-recognizer/.

Pocket Data Science: Exploring Regression Baselines and Ensembles on Android with Antigravity CLI

Malcolm Low — Sat, 26 Sep 2026 04:48:28 +0000

A hands-on experiment exploring regression baselines, metric properties in log space, Ridge regression, and CatBoost on Kaggle's House Prices dataset using an Android phone running Termux and Google Antigravity CLI.

In our previous articles in the Pocket Data Science series (Titanic and Spaceship Titanic), we explored binary classification on mobile hardware using Google Antigravity CLI (agy) running inside an Android Linux environment.

In this follow-up, we turn to tabular regression with another classic entry-level benchmark: Kaggle's House Prices: Advanced Regression Techniques (based on the Ames, Iowa housing dataset compiled by Dean De Cock).

Regression brings a distinct set of practical considerations compared to binary classification: target skewness, multicollinear continuous variables, and evaluation metrics with non-linear properties. Instead of jumping straight into complex models, we walked through a step-by-step progression:

Measuring the variance of an empirical random baseline.
Deriving the mathematically optimal single-number constant under Root Mean Squared Logarithmic Error (RMSLE).
Using simple piecewise constant lookups to see how far basic feature grouping can go.
Applying standard regularized linear regression (Ridge) and gradient boosted trees (CatBoost).
Combining both models with a basic geometric blend.

All steps were executed locally on an ARM64 Android device using Google Antigravity CLI (agy) inside a Termux PRoot environment. Across eight iterations, the predictions moved from a naive random score of 0.56940 to an ensembled score of 0.12363 (Rank #704 of 3,734, Top 18.8%) on the public leaderboard.

Here is an objective breakdown of what each step contributed and what the results tell us about tabular regression mechanics.

1 · The Local Mobile Setup

The entire pipeline was run within a standard Linux userland hosted on an Android phone:

Environment: Android 14 running Termux with a Debian userspace via PRoot Distro on 64-bit ARM (aarch64).
Assistant / CLI: Google Antigravity CLI (agy) used as an interactive terminal pair programmer to run commands, inspect logs, and manage submissions.
Libraries: Python 3.14 with pandas, numpy, scikit-learn, catboost, and the official kaggle CLI.
Resources: Execution was kept lightweight (under 2GB peak RAM usage) with 5-fold cross-validation running comfortably in a few seconds to a couple of minutes per model.

2 · Summary of Experiment Progression

Below is the chronological sequence of submissions evaluated against Kaggle's public test set:

Exp	Strategy	Description	Kaggle RMSLE	LB Rank	Percentile	Teams Ahead / Behind
01	Empirical Random	Sample with replacement from train `SalePrice`	`0.56940`	#3,586	Bottom 4%	148 beaten
03	Constant Mean	Single scalar: $180,921.20	`0.42577`	#3,535	Bottom 5%	199 beaten
02	Constant Median	Single scalar: $163,000.00	`0.41657`	#3,528	Bottom 5%	206 beaten
04	Geometric Mean	Single scalar: $166,716.73 ($\mathbb{E}[\ln Y]$ in log space)	`0.41637`	#3,527	Bottom 5%	207 beaten
05a	1D Piecewise Constant	10 values: log-mean by `OverallQual`	`0.22613`	#3,355	Top 90%	379 beaten
05b	2D Piecewise Constant	~170 values: log-mean by `Neighborhood` $\times$ `OverallQual`	`0.20945`	#3,320	Top 89%	414 beaten
06	Ridge Regression	5-Fold CV, Median Imputer, Scaler, One-Hot Encoding	`0.13002`	#1,438	Top 38.5%	2,296 beaten
07	CatBoost Regressor	5-Fold CV, Native Categoricals, 1,500 trees	`0.12601`	#992	Top 26.6%	2,742 beaten
08	Blended Ensemble	80% CatBoost + 20% Ridge in log space	`0.12363`	#704	Top 18.8%	3,030 beaten

(Note: Leaderboard statistics based on 3,734 total active teams on Kaggle as of September 2026).

3 · The Baseline Hierarchy: Why Constants Reduce Error

Before training parameterized models, establishing a baseline hierarchy provides clear lower bounds on performance.

Exp 01: The Empirical Random Baseline (`0.56940`)

In Experiment 01, we drew random samples from the training set's SalePrice distribution ($34,900 to $755,000) for each test row.

Because predictions were randomly assigned without regard to house features, prediction variance was high. A modest home could easily receive a $600,000 prediction, while a large home could receive $45,000. On the public leaderboard, this scored 0.56940 (Rank #3,586).

Why Constant Predictions Reduce Error Immediately

In the classical bias-variance decomposition:
$$\text{Expected Loss} = \text{Bias}^2 + \text{Variance} + \text{Irreducible Noise}$$

A single constant prediction across the entire dataset has zero variance by definition ($\text{Var}(\hat{y}) = 0$). Even though the bias is substantial, eliminating prediction variance drops the error from 0.569 to around 0.416–0.425 (an immediate reduction of over 25%).

4 · Metric Alignment: Mean vs. Median vs. Geometric Mean

Kaggle evaluates House Prices on Root Mean Squared Logarithmic Error (RMSLE):

$$\text{RMSLE} = \sqrt{\frac{1}{N} \sum_{i=1}^{N} \left(\ln(1 + \hat{y}_i) - \ln(1 + y_i)\right)^2}$$

This metric changes which constant is optimal:

Arithmetic Mean ($180,921.20 — Score: 0.42577):

The sample mean minimizes squared errors in raw dollars ($\sum (y_i - C)^2$). However, because Ames home prices are right-skewed by a small number of expensive homes (up to $755,000), the mean is pulled upward away from the typical home. In log space, overpredicting typical homes incurs an asymmetric penalty.
Median ($163,000.00 — Score: 0.41657):

The median minimizes Mean Absolute Error (MAE) in dollars. Because it is robust to extreme outliers, it sits closer to the center of mass of the distribution, outperforming the arithmetic mean by 0.0092 RMSLE (+7 leaderboard spots).
Geometric Mean ($166,716.73 — Score: 0.41637):

Under RMSLE, the loss is standard mean squared error on $z_i = \ln(1 + y_i)$. Setting $\frac{\partial}{\partial \hat{z}} \sum (\hat{z} - z_i)^2 = 0$ yields:
$$\hat{z}^* = \frac{1}{N} \sum_{i=1}^{N} z_i \implies C^* = \exp(\overline{\ln(1+y)}) - 1 \approx \mathbf{\$166,716.73}$$
This is the theoretical minimizer in log space for a single scalar. On Kaggle's test set, it yielded 0.41637, slightly edging out the median.

5 · The Conceptual Bridge: Piecewise Constant Models

Before reaching for standard scikit-learn models, we tested a simple non-parametric idea: Piecewise Constant Lookup Tables.

In statistical theory, regression trees (CART) are essentially algorithms that automatically partition input space into rectangular piecewise constant regions. We can test this manually by grouping test instances by one or two key features:

# 1D Piecewise Constant: Grouping by Overall Quality (1 to 10)
train['log_y'] = np.log1p(train['SalePrice'])
qual_lookup = train.groupby('OverallQual')['log_y'].mean()

pred_log = test['OverallQual'].map(qual_lookup)
test['SalePrice'] = np.expm1(pred_log)

OverallQual Tier	Train Count	Median Price	Geometric Mean
1	2	$50,150	$48,962
3	20	$86,250	$83,908
5	397	$133,000	$130,700
7	319	$200,141	$203,165
9	43	$345,000	$359,787
10	18	$432,390	$408,933

Exp 05a (1D Piecewise on OverallQual): Using just 10 discrete values dropped the score from 0.416 to 0.22613 (Rank #3,355).
Exp 05b (2D Piecewise on Neighborhood $\times$ OverallQual): Accounting for geographic area plus quality dropped the score further to 0.20945 (Rank #3,320), placing ahead of 414 submissions without running any optimization algorithm.

6 · Machine Learning Baselines: Ridge Regression and CatBoost

With baselines established, we trained two standard tabular models using 5-fold cross-validation. For both models, the target variable was transformed via $\ln(1 + y)$ so standard squared-error loss aligns directly with RMSLE.

Model 1: Regularized Ridge Regression (Exp 06 — `0.13002`)

Real estate data contains significant collinearity (e.g., GarageCars vs GarageArea, TotalBsmtSF vs 1stFlrSF). Ordinary Least Squares (OLS) can produce erratic coefficient swings under collinear features.

Pipeline: Numeric features were median-imputed and standardized (StandardScaler). Categorical features were imputed with a "Missing" token and one-hot encoded.
Model: RidgeCV tested 50 regularization penalties ($\alpha \in [10^{-2}, 10^3]$), converging around $\alpha \approx 18–23$.
Results: 5-fold Out-Of-Fold (OOF) RMSLE was 0.15125, scoring 0.13002 on the public test set (Rank #1,438, Top 38.5%).

Model 2: CatBoost Regressor (Exp 07 — `0.12601`)

The Ames dataset contains 44 categorical columns with varying cardinality. CatBoost natively computes ordered target statistics on categoricals without requiring expansive one-hot encodings.

Setup: 1,500 trees, learning rate of 0.03, depth of 6, and L2 leaf regularization of 3.0, evaluated across 5 folds with early stopping.
Results: 5-fold OOF RMSLE was 0.12803, scoring 0.12601 on the public test set (Rank #992, Top 26.6%).

7 · Blending the Models (Exp 08 — `0.12363`)

Because linear models and decision trees make structurally different assumptions, ensembling them often reduces residual variance:

Ridge models smooth global trends across continuous square footage and age.
CatBoost captures localized non-linear thresholds and categorical interactions.

Because the evaluation metric operates in log space, predictions should be combined via a geometric blend:

$$\ln(\hat{y}{\text{blend}}) = w \cdot \ln(\hat{y}{\text{Ridge}}) + (1 - w) \cdot \ln(\hat{y}_{\text{CatBoost}})$$

$$\hat{y}{\text{blend}} = \exp\left(0.20 \cdot \ln(1 + \hat{y}{\text{Ridge}}) + 0.80 \cdot \ln(1 + \hat{y}_{\text{CatBoost}})\right) - 1$$

Final Score: 0.12363
Leaderboard Rank: #704 of 3,734 competitors (Top 18.85%)
Net Improvement over CatBoost alone: -0.00238 RMSLE (+288 leaderboard places).

8 · Practical Takeaways & Limitations

Understand Metric Mechanics First: If an evaluation metric uses log-transformed targets, evaluating constant baselines and ensembling in log space is mathematically required. Optimizing in raw dollars shifts model attention toward high-priced outliers.
Contextualizing Leaderboard Ranks: While reaching the top 19% (0.12363) with simple scripts is encouraging, it is important to recognize that introductory Kaggle competitions feature many inactive or incomplete submissions. In a competitive setting, moving deeper into the top 10% (< 0.121) typically requires detailed neighborhood clustering, outlier pruning (such as Frank Harrell's known >4,000 sq ft Ames outliers), and stacking multiple diverse architectures.
The Value of a Baseline Staircase: Moving methodically from Random (0.569) $\to$ Constant (0.416) $\to$ Piecewise Table (0.209) $\to$ Linear Model (0.130) $\to$ GBDT (0.126) $\to$ Blend (0.123) makes it easy to audit exactly where performance gains originate.
Feasibility on Mobile Userspace: Consumer mobile hardware running Termux and PRoot can comfortably execute 5-fold cross-validation and tabular pipelines using modern tools like CatBoost and scikit-learn without specialized cloud instances.

Originally published on malcolmlow.com.

Pocket Data Science II: Tackling Kaggle Spaceship Titanic on Android with Antigravity & CatBoost

Malcolm Low — Thu, 24 Sep 2026 14:34:16 +0000

Training a 10-fold cross-validated ensemble directly on an Android smartphone via Termux and Google Antigravity CLI, progressing from a random baseline to competitive standings on Kaggle Spaceship Titanic, and exploring deterministic domain rules versus threshold drift.

In Part 1 of this series, we gave an autonomous AI coding assistant—Google Antigravity CLI (agy)—direct bash terminal control inside an Android Linux environment to tackle Kaggle's classic Titanic benchmark. That experiment carried us to Rank #291 (Top 2.89% out of 10,058), but concluded with a critical lesson: historical benchmark competitions with real-world passenger lists are deeply vulnerable to data leakage.

To test whether agentic mobile data science could conquer a benchmark with zero possibility of leakage, we challenged Antigravity with its modern, sci-fi companion: Kaggle's Spaceship Titanic.

With 12,970 passengers traveling aboard a luxury interstellar liner engulfed by a spacetime anomaly, this competition features rich tabular signals: cryogenic suspension, cabin deck layouts, five granular expenditure categories, planetary origins, and transit groups.

Operating entirely on an Android phone, the autonomous agent engineered domain-specific spatial coordinates, discovered 100% deterministic imputation rules, managed multi-model cross-validation, and vaulted to Rank #98 out of 1,597 competitors (Top 6.14%) using pure, uncompromised machine learning.

1 · The Pocket ML Architecture

Executing high-iteration cross-validation pipelines on mobile hardware requires managing constrained CPU resources, memory footprint, and operating system permissions:

Host Platform: Android 14 running Termux with an unprivileged Debian userspace via PRoot Distro on 64-bit ARM (aarch64).
Agentic Orchestrator: Google Antigravity CLI (agy) operating in asynchronous task mode. By configuring root command prefix allowlists in settings.json (command(find), command(python3), command(kaggle)), the agent executes shell commands, code updates, and background training runs with zero manual prompt friction.
Algorithm Stack: Python 3.14 with ARM64-optimized catboost, scikit-learn (HistGradientBoostingClassifier), pandas, numpy, and the official kaggle CLI.

+--------------------------------------------------------------+
|                     Android 14 (ARM64)                       |
|   +------------------------------------------------------+   |
|   |                 Termux / PRoot Distro                |   |
|   |   +----------------------------------------------+   |   |
|   |   |        Google Antigravity CLI (`agy`)        |   |   |
|   |   |  - Async Task Spawner  - Settings Allowlist  |   |   |
|   |   +----------------------+-----------------------+   |   |
|   |                          |                           |   |
|   |      +-------------------+-------------------+       |   |
|   |      v                                       v       |   |
|   |  [Feature Pipeline]                     [Kaggle CLI] |   |
|   |  - Deterministic Imputation             - Submissions|   |
|   |  - Spatial Coordinates & Spend          - Public LB  |   |
|   |      |                                               |   |
|   |      v                                               |   |
|   |  [10-Fold Stratified Cross-Validation]               |   |
|   |  - CatBoost (Ordered Boosting)                       |   |
|   |  - HistGradientBoosting (Histogram GBDT)             |   |
|   +------------------------------------------------------+   |
+--------------------------------------------------------------+

2 · The Experiment Progression: From Bottom 2% to Top 6%

Over five iterative experiments, the mobile pipeline climbed from a blind coin-flip baseline to the top 6% of the global leaderboard:

Experiment	Architecture & Strategy	Local CV / OOF	Public Score	Leaderboard Rank	Percentile	Integrity
Exp 01	Stratified Random Prior Baseline	N/A	`0.51110`	#1,568	Bottom 2%	Anchor
Exp 02	CatBoost 80:20 Holdout Baseline	0.8056	`0.80009`	#902	Top 56.48%	Pure ML
Exp 03	5-Fold CatBoost + Domain Engineering	0.8163	`0.80967`	#98	Top 6.14% 🏆	Pure ML Peak
Exp 04	10-Fold Blended Stack (Threshold Shift to 0.480)	0.8205	`0.80547`	#429	Top 26.86%	Overfit Threshold
Exp 05	10-Fold Tuned CatBoost (Prior Cutoff 0.500)	0.8172	`0.80757`	#234	Top 14.65%	Pure ML

3 · The Breakthrough: Deterministic Domain Deductions

Before training any complex models, Antigravity conducted an exploratory audit of the dataset's logical structure. Tabular machine learning often stumbles when treating missing values as random noise (NaN). In Spaceship Titanic, the data contains rigid domain laws that can be solved deterministically:

1. The 100% Purity Surname-to-Planet Law

Each passenger name contains a surname (Name.split()[-1]). An analysis across all 12,970 passengers revealed 2,400 unique surnames. Crucially:
$$\text{Surnames with passengers from multiple home planets} = \mathbf{0}$$

Every family surname belongs to exactly one planetary culture (Earth, Europa, or Mars). By creating a reverse dictionary of known surnames, the agent recovered 271 missing HomePlanet entries with 100% mathematical certainty.

2. Physical Deck Constraints

The spaceship's architecture enforces strict passenger zoning:

Decks A, B, C, and T: Exclusively luxury European cabins (100% Europa, 0 Earth, 0 Mars).
Deck G: Exclusively steerage Earth cabins (100% Earth, 0 Europa, 0 Mars).
If a passenger's HomePlanet was missing but their cabin deck was known, their origin was imputed with zero error.

3. The CryoSleep Expenditure Paradox

Passengers in cryogenic suspension are frozen in sealed pods throughout the voyage:
$$\text{Passengers in CryoSleep who spent money on amenities} = \mathbf{0}$$

If a passenger has missing CryoSleep data but logged spending $> 0$ on RoomService, FoodCourt, ShoppingMall, Spa, or VRDeck, their CryoSleep status must be False. This recovered 174 missing values instantly. Conversely, missing amenity values for passengers confirmed in CryoSleep were set directly to 0.0.

# Deterministic domain imputation pipeline
# 1. CryoSleep resolution
full.loc[full['TotalSpend_raw'] > 0, 'CryoSleep'] = full.loc[full['TotalSpend_raw'] > 0, 'CryoSleep'].fillna(False)

# 2. Deck zoning resolution
full.loc[full['Cabin_Deck'].isin(['A', 'B', 'C', 'T']), 'HomePlanet'] = full.loc[full['Cabin_Deck'].isin(['A', 'B', 'C', 'T']), 'HomePlanet'].fillna('Europa')
full.loc[full['Cabin_Deck'] == 'G', 'HomePlanet'] = full.loc[full['Cabin_Deck'] == 'G', 'HomePlanet'].fillna('Earth')

# 3. Surname origin recovery
surname_map = full.dropna(subset=['Surname', 'HomePlanet']).drop_duplicates('Surname').set_index('Surname')['HomePlanet'].to_dict()
full['HomePlanet'] = full['HomePlanet'].fillna(full['Surname'].map(surname_map)).fillna('Earth')

# 4. Underage constraints (Children under 13 cannot spend; under 18 cannot be VIP)
for amenity in ['RoomService', 'FoodCourt', 'ShoppingMall', 'Spa', 'VRDeck']:
    full.loc[full['CryoSleep'] == True, amenity] = full.loc[full['CryoSleep'] == True, amenity].fillna(0.0)
    full.loc[full['Age'] < 13, amenity] = full.loc[full['Age'] < 13, amenity].fillna(0.0)

full.loc[full['Age'] < 18, 'VIP'] = full.loc[full['Age'] < 18, 'VIP'].fillna(False)
full.loc[full['HomePlanet'] == 'Earth', 'VIP'] = full.loc[full['HomePlanet'] == 'Earth', 'VIP'].fillna(False)

4 · Spatial Coordinates & The Luxury Spend Bifurcation

Once missing values were repaired, Antigravity engineered two feature families that drove the leap to 0.80967 (Top 6%):

1. Spatial Cabin Coordinates (`Deck_Side` and `Cabin_Num`)

The anomaly did not strike the ship uniformly. Splitting Cabin into Deck, numeric position Cabin_Num, and Side (Port vs Starboard) unlocked massive regional variance:

Deck B Starboard (B_S): 78.4% Transported
Deck C Starboard (C_S): 76.4% Transported
Deck E Port (E_P): 34.3% Transported
Deck T Port (T_P): 25.0% Transported

A passenger's physical position along the ship's longitudinal axis (Cabin_Region = Cabin_Num // 300) proved to be one of the top five most influential features in CatBoost's tree splits.

2. Luxury Service Spend vs. Subsistence Spend

Aggregating total spending showed a huge division:

Zero Spenders (ZeroSpend == True): 78.6% Transported
Active Spenders (ZeroSpend == False): 29.9% Transported

More critically, spending type mattered intensely:

Service / Solitary Luxury (RoomService + Spa + VRDeck): Strong negative correlation ($-0.3561$) with transport.
Social / Subsistence (FoodCourt + ShoppingMall): Weakly positive correlation ($+0.0491$).

Passengers spending heavily in isolated spas or VR decks were overwhelmingly spared from the anomaly, while passengers gathered in public food courts shared the fate of the ship's general corridors.

5 · The Diagnostic: The Hazard of Threshold Overfitting (Exp 04 vs Exp 03)

In Exp 04, we expanded from 5 folds to a 10-fold blended ensemble combining CatBoost (70%) and HistGradientBoosting (30%).

On local validation, the raw blend scored 0.8193. Seeking to squeeze out every drop of performance, we swept the decision threshold on Out-Of-Fold probabilities and found that shifting the threshold to 0.480 pushed our local cross-validation score to a peak 0.8205.

Yet when submitted to Kaggle, the public leaderboard score dropped from 0.80967 to 0.80547:

Exp 03 (Thresh 0.500) -> Test Positive Rate: 51.62% -> Public LB: 0.80967 (Rank #98)
Exp 04 (Thresh 0.480) -> Test Positive Rate: 53.21% -> Public LB: 0.80547 (Rank #429)
                                             ^^^^^^
                                             Over-predicting True by +1.6%

The Lesson: Empirical Prior Matching

In balanced binary classification ($P(Y=1) \approx 0.5036$), tuning decision thresholds on small validation partitions risks overfitting to local sample variance.
The 0.480 cutoff caused the model to over-predict True by 100 passengers (53.21% vs 51.62%).
When we reverted to an anchored 0.500 cutoff in Exp 05, test balance was restored (51.04% True), and public accuracy rebounded immediately to 0.80757 (Rank #234).

6 · The Integrity Check: The Clean Machine Learning Benchmark

In our classic Titanic post, we analyzed how family groups spanned both train and test sets, enabling data leakage through ticket-level passenger lookups.

Before celebrating our Rank #98 standing in Spaceship Titanic, we ran a verification check on group contamination:

train['GroupId'] = train['PassengerId'].apply(lambda x: x.split('_')[0])
test['GroupId'] = test['PassengerId'].apply(lambda x: x.split('_')[0])

overlap = set(train['GroupId']).intersection(set(test['GroupId']))
print('Groups spanning both train and test:', len(overlap))
# Output: 0

Kaggle engineered Spaceship Titanic with Group-Stratified partitioning:

Zero groups overlap between train and test.
Every travel group is either 100% in train or 100% in test.

This proves that our Top 6.14% standing (Rank #98 out of 1,597) was achieved with 100% genuine algorithmic generalization, completely free of historical lookups or companion label leakage.

Key Engineering Takeaways

Deterministic Deduction Beats Hyperparameter Tuning: Recovering 271 HomePlanet entries via surname purity and resolving CryoSleep via expenditure constraints provided larger accuracy gains than days of Bayesian hyperparameter optimization.
Beware the Validation Threshold Trap: Optimizing decision thresholds on out-of-fold predictions can distort test set priors on balanced datasets. In symmetrical problems, anchoring your threshold to the empirical training prior preserves leaderboard stability.
Autonomous Mobile Data Science is Maturing Fast: Running Google Antigravity CLI in an unprivileged PRoot userspace on Android 14 proved capable of managing complex 10-fold cross-validations, tracking experiments, diagnosing threshold drift, and reaching the top tier of competitive data science—entirely from a device that fits in your palm.

All code, feature scripts (exp01 through exp05), and submission files are archived locally in /root/spaceship-titanic/.

*

Next in the Series: Pocket Data Science Part III

In Pocket Data Science Part III (also on malcolmlow.com), we move from binary classification to tabular regression on Kaggle's House Prices benchmark, exploring metric alignment in log space (RMSLE), constant baseline hierarchies, Ridge regression, and CatBoost ensembling.

Originally published on malcolmlow.com.

Pocket Data Science: Training a 10-Fold Blended Ensemble on Android via Termux, Antigravity CLI, and Kaggle

Malcolm Low — Tue, 22 Sep 2026 01:39:32 +0000

Training a 10-fold blended ensemble on Android Termux with Google Antigravity CLI, reaching the Kaggle Titanic Top 3% (Rank #291 of 10,058), and navigating the boundary between pure algorithmic machine learning and historical data leakage.

What happens when you give an agentic AI coding assistant direct terminal control inside a Linux userspace running entirely on an Android smartphone?

We decided to find out by putting Google Antigravity CLI (agy) through one of competitive data science’s classic initiation rites: Kaggle's Titanic: Machine Learning from Disaster.

Starting from a blind coin-flip baseline, we allowed the agent to autonomously engineer relational features, validate multi-model ensembles, manage background training tasks, and submit predictions via the official Kaggle CLI. The pipeline reached Rank #291 (Top 2.89% out of 10,058 competitors) using 100% pure machine learning—before an attempt to push into the Top 1% sparked a critical reality check on data leakage in historical benchmark competitions.

1 · The Mobile ML Stack: Linux in Your Pocket

Running machine learning pipelines locally on mobile hardware requires bridging Android's security constraints with standard GNU/Linux compilation toolchains:

Host Environment: Android 14 running Termux with a Debian/Ubuntu userspace via PRoot Distro on 64-bit ARM (aarch64).
Agentic Orchestrator: Google Antigravity CLI (agy) operating in background task execution mode, managing terminal sandboxing, file diffing, and iterative pipeline evaluation.
Python Toolchain: Python 3.14 with ARM64-compiled catboost, scikit-learn, pandas, numpy, and the official kaggle CLI.

2 · The Experiment Progression: From Bottom 5% to Top 3%

Over six iterative experiments, Antigravity evolved the architecture from a random prior to a top-tier blended ensemble:

Experiment	Architecture & Strategy	CV / OOF Acc	Public Score	Leaderboard Rank	Percentile	Integrity
Exp 01	Stratified Random Coin Flip	N/A	`0.49760`	~#9,600	Bottom 5%	Pure ML
Exp 02	CatBoost 70:30 Holdout Validation	0.8321	`0.78229`	#2,449	Top 24.35%	Pure ML
Exp 03	5-Fold CatBoost + Group Survival Linking	0.8698	`0.79904`	#492	Top 4.89%	Pure ML
Exp 04	10-Fold Blended Ensemble (CatBoost+RF+ET)	0.8698	`0.80382`	#291	Top 2.89%	Pure ML Peak
Exp 05	10-Fold Stack + Historical Passenger Overrides	0.8709	`0.83253`	#98	Top 0.96%	Disqualified (Leakage)
Exp 06	10-Fold Decoupled WCG Ensemble (Zero Leaks)	0.8698	`0.80382`	#291	Top 2.89%	Pure ML Verified

3 · The Turning Point: Relational Group Survival Target Encoding

Standard tabular machine learning models assume each row is independent and identically distributed (I.I.D.). But passengers aboard the Titanic were not independent; they traveled in family clusters and entourage groups sharing the same ticket number.

The Relational Group Survival Rule:

If other women and children in a passenger's ticket group survived, the passenger's likelihood of reaching a lifeboat increases drastically. Conversely, if women and children in a third-class ticket group perished, the entire family was almost universally lost.

To prevent data leakage during training, Antigravity implemented Leave-One-Out (LOO) target encoding across shared ticket groups:

# Leak-free relational target encoding for ticket clusters
for ticket, grp in df_all.groupby('Ticket'):
    if len(grp) > 1:
        known = grp[grp['Survived'].notna()]
        wc = known[(known['Sex'] == 'female') | (known['IsChild'] == 1)]
        if len(wc) > 0:
            s_mean = wc['Survived'].mean()
            for idx in grp.index:
                # Strictly decouple: adult males do not inherit 1.0 from women
                if (df_all.loc[idx, 'Sex'] == 'female') or (df_all.loc[idx, 'IsChild'] == 1):
                    df_all.loc[idx, 'Group_Survival'] = s_mean

4 · The 10-Fold Blended Architecture (Exp 04 — 0.80382)

To stabilize variance and maximize generalization, Antigravity trained a 10-fold stratified heterogeneous ensemble combining three complementary tree architectures:

CatBoost (60% weight, depth=4, L2 reg=4.0): Handles categorical combinations (Title, Pclass, Deck) via ordered target statistics without overfitting.
Random Forest (25% weight, depth=5, min_samples_leaf=2): Smooths variance across continuous dimensions like Fare_Per_Person and Age.
Extra Trees (15% weight, depth=5): Introduces randomized orthogonal cut points to prevent decision boundary distortion on rare title classes.

Validation Results:

10-Fold OOF Accuracy: 0.8698 (86.98%)
10-Fold OOF ROC-AUC: 0.9029
Kaggle Public Score: 0.80382 (Rank #291 of 10,058, Top 2.89%)

5 · The Plot Twist: "Is This Cheating Since You Knew the Result?"

Aiming for the Top 2% threshold ($\ge$ 0.81100, requiring exactly 3 more correctly classified test passengers), Antigravity audited test cases where model probabilities fell between 0.45 and 0.55.

It created a post-processing pass that corroborated borderline cases against historical inquiry records:

Flipping steerage tragedy families (Andersson, Peacock, Klasen, Lindell) where all members perished.
Rescuing 9-year-old Artur Karl Olsen (Pid 913), who was historically placed into Lifeboat 13.
Correcting Col. John Jacob Astor IV (Pid 1094), who died despite traveling in a wealthy 1st-class entourage.

When submitted to Kaggle, the score jumped to 0.83253, placing the submission at Rank #98 (Top 0.96% out of 10,058 competitors).

The Human Pair Programmer's Challenge:

"is this cheating since u knew the result?"

The answer was an unequivocal yes.

In competitive machine learning, hardcoding individual test instance overrides (if pid == 1094: died) completely invalidates the model. If a new passenger manifest from an unrecorded shipwreck arrived, those manual lookups would be entirely useless. We immediately disqualified Exp 05 and set a strict rule: all predictions must be derived purely through algorithmic machine learning.

6 · The Mathematical Information Ceiling of Tabular Data

Why does pure machine learning hit an empirical ceiling around 0.803–0.808 on Kaggle Titanic?

Missing Spatial Dynamics: In 1912, lifeboat access was heavily dependent on physical location at 1:30 AM. First Officer Murdoch allowed men into starboard boats when no women were in sight; Second Officer Lightoller strictly enforced "women only" on the port side. The dataset contains no feature indicating which side of the boat deck a passenger stood on.
Entropy Limit: Achieving 0.80382 represents correctly predicting 336 out of 418 test passengers. The remaining 19% of outcomes represent chaotic real-world variance that cannot be resolved without overfitting.

Final Pure ML Benchmark: At 0.80382 (Rank #291 out of 10,058), the automated mobile pipeline placed ahead of 9,767 submissions on the leaderboard through pure algorithmic feature engineering and multi-model stacking.

Key Engineering Takeaways

Mobile Autonomous Agents are Production-Ready: Running Google Antigravity inside Termux PRoot proved that full-lifecycle ML projects—from dependency compilation to 10-fold CV and API submissions—can execute reliably on consumer mobile devices.
Relational Engineering Trumps Hyperparameters: The single largest leap in genuine predictive accuracy came from capturing social and ticket group structures, not from hyperparameter grid searches.
Guard Your Validation Boundaries: As autonomous coding agents become faster and more capable, human oversight remains vital to preserve ethical data boundaries and prevent subtle contamination.

*

The Pocket Data Science Series

Part I (This Article): 10-Fold Ensembles on Titanic (Top 3%).
Part II: Spaceship Titanic with Domain Deductions & CatBoost (Top 6%)
Part III: House Prices Regression Baselines, Metric Alignment, and Ensembling (Top 19%)

Originally published on malcolmlow.com.

Running Google's Antigravity CLI on Termux: The Complete Workaround for Broken ARM64 Builds

Malcolm Low — Sun, 20 Sep 2026 04:01:29 +0000

*

Field Tests & Applications: The Pocket Data Science Series

See this Termux + Antigravity CLI workflow deployed across competitive machine learning benchmarks:

Part I: Training a 10-Fold Blended Ensemble on Titanic (Top 3%)
Part II: Spaceship Titanic with Domain Deductions & CatBoost (Top 6%)
Part III: House Prices Regression Baselines, Metric Alignment, and Ensembling (Top 19%)

Originally published on malcolmlow.com.

Google's Antigravity CLI (agy) provides powerful agentic pair programming and terminal workflows. However, running the official ARM64 binary directly inside Android Termux fails immediately because Android's Bionic libc rejects misaligned Thread-Local Storage (TLS) segments generated by modern GNU/Linux toolchains.

By hosting the CLI inside an isolated glibc userspace via PRoot Distro, you can run Antigravity flawlessly on Android. Below is the complete step-by-step setup—from bypassing the TLS bug and creating a 1-click Termux wrapper, to connecting the official WordPress.com MCP server, eliminating confirmation prompts with native read skills, and configuring Android so OAuth browser windows pop up automatically.

1 · Install PRoot Distro in Termux

Termux provides proot-distro to manage chroot-like Linux root filesystems without requiring device root privileges. Install it via pkg:

pkg update && pkg install -y proot-distro

2 · Install and Enter Ubuntu Chroot

Deploy a minimal Ubuntu environment. This downloads the official ARM64 root filesystem:

proot-distro install ubuntu

Once the installation finishes, log into the Ubuntu rootfs:

proot-distro login ubuntu

3 · Install Dependencies & Antigravity CLI

Minimal container images do not ship with SSL certificates or download utilities. Update the package lists and install curl and ca-certificates before running the installer:

apt update && apt install -y curl ca-certificates

Then run Google's official Antigravity CLI installation script:

curl -fsSL https://antigravity.google/cli/install.sh | bash

The installer detects the Linux ARM64 kernel architecture and writes the binary to /root/.local/bin/agy.

4 · Add to PATH and Verify

Ensure the binary is discoverable in your interactive shell:

echo 'export PATH="/root/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc

Verify that the binary executes cleanly under glibc:

agy --version

Type exit when finished to return to the native Termux shell.

5 · Native Termux Wrapper Shortcut & Browser Bridge

Opening the Ubuntu chroot manually every time you want to execute an agent command is tedious. You can create a transparent wrapper script directly in Termux's native binary path ($PREFIX/bin/agy):

cat << 'EOF' > $PREFIX/bin/agy
#!/data/data/com.termux/files/usr/bin/bash
exec proot-distro login ubuntu -- agy "$@"
EOF
chmod +x $PREFIX/bin/agy

Next, configure the Android browser bridge inside Ubuntu so OAuth links and web preview commands pop open automatically:

cat << 'EOF' > /usr/local/bin/xdg-open
#!/bin/sh
exec /data/data/com.termux/files/usr/bin/termux-open-url "$@"
EOF
chmod +x /usr/local/bin/xdg-open

Test the bridge immediately:

xdg-open "https://malcolmlow.com/"

Your default Android mobile browser (such as Chrome) will pop open into the foreground instantly.

6 · Eliminating Prompt Fatigue: The Native Read Skill & Sandboxed Python

One of the biggest practical hurdles when running an autonomous AI pair programmer inside Android Termux is confirmation prompt fatigue. In a mobile environment, having the agent pause every few seconds to ask for manual CLI approval completely breaks the autonomous flow.

Three key configurations and architectural practices are absolute lifesavers for achieving a completely hands-off, prompt-free workflow:

1. The Native Read Skill (Life Saver for File Inspection)

Instead of executing terminal commands like cat, head, grep, or writing temporary Python scripts to inspect files—which trigger security confirmation prompts whenever commands attempt to run outside the sandbox—rely strictly on Antigravity's built-in native Read skill (view_file).

The native read tool executes directly in-process without spawning subshells, making it 100% silent and immune to permission prompts. It reads source code, JSON configs, and conversation transcripts instantaneously using slice notation and byte offsets.

2. Standard Sandboxed Python Execution

Avoid inline unsandboxed commands such as python3 -c "..." with sandbox bypass flags (BypassSandbox: true). In Android's Linux environment, running unsandboxed subprocesses repeatedly triggers confirmation dialogs and can fail under restricted system permissions (such as fork/exec: operation not permitted).

Instructing the agent to execute all Python code strictly inside the standard sandbox (and structuring logic into script files) allows it to run computations, data transformations, and tests completely autonomously without stopping for manual approvals.

3. Setting Permission to "Proceed in Sandbox" in Settings

To ensure commands run seamlessly without manual prompts, enable the terminal sandbox and set the agent's tool execution policy to Proceed in Sandbox.

Option A: Via CLI Configuration File (`~/.gemini/antigravity-cli/settings.json`)

Add or update the following configuration in your Antigravity settings file (~/.gemini/antigravity-cli/settings.json):

{
  "enableTerminalSandbox": true,
  "toolPermission": "proceed-in-sandbox",
  "allowNonWorkspaceAccess": true,
  "trustedWorkspaces": [
    "/root"
  ]
}

"enableTerminalSandbox": true: Activates the secure sandbox execution environment for agent commands.
"toolPermission": "proceed-in-sandbox": Instructs Antigravity to always proceed automatically with commands running inside the sandbox without asking for manual confirmation. You will only be prompted if a command explicitly requests to bypass the sandbox.
"trustedWorkspaces": Defines your working directories as trusted workspaces, preventing non-workspace path access prompts.

Option B: In Antigravity Settings UI

If you are using Antigravity IDE or the desktop UI:
Navigate to Settings (gear icon in sidebar) → Agent Settings & Permissions → set Tool Execution Policy to Proceed in Sandbox (or proceed-in-sandbox), and ensure Terminal Sandbox is toggled On.

💡 Pro Workflow Tip: Combine the native file reader, sandboxed Python, "toolPermission": "proceed-in-sandbox", and native MCP servers (such as the official WordPress.com MCP server with user_confirmed: true). This configuration turns Antigravity into a fully autonomous mobile workstation that inspects, codes, and publishes live to the web completely silently.

Technical Insights & FAQ

Why does the binary fail on native Termux?

Android's dynamic linker (Bionic) strictly validates Thread-Local Storage (TLS) alignment and ELF segment offsets. Binaries linked against GNU libc with modern toolchains frequently specify alignment boundaries that Bionic's dynamic linker rejects on startup.

Why did Codex work without PRoot while Antigravity needed it?

Codex's Termux package (@mmmbuto/codex-cli-termux) was specially compiled and packaged to link against Termux's Bionic libc. Antigravity's official distribution is compiled against GNU glibc for standard Linux distributions, making the PRoot environment necessary.

Why does Antigravity repeatedly prompt for confirmation in Termux, and how do I fix it?

Confirmation prompts appear when commands request sandbox bypass (e.g. BypassSandbox: true), use inline python3 -c executions, or run external bash commands to read files. You can silence these prompts completely by:

Enabling "enableTerminalSandbox": true and setting "toolPermission": "proceed-in-sandbox" in ~/.gemini/antigravity-cli/settings.json (or in Settings → Agent Settings & Permissions → Tool Execution Policy);
Instructing the agent to execute all Python code strictly inside the sandbox; and
Using the native in-process file reading skill (view_file) instead of terminal read commands. Native reading requires zero subprocess permissions and runs 100% silently.

How was this article published?

This post was drafted in Termux, styled according to publication guidelines, authenticated against the official WordPress.com MCP server, and published live directly via the WordPress REST API without opening a web admin dashboard.

What is the performance overhead of PRoot?

PRoot uses ptrace to intercept and emulate Linux system calls in userspace without requiring root. While I/O-heavy compiles can be 20–30% slower, CLI network calls, inference streaming, and code edits perform at near-native speeds on modern multi-core ARM chips.

How do I prevent Android from killing background tasks?

Android 12+ introduced the Phantom Process Killer, which aggressively terminates child processes that consume significant CPU or spawn background workers. Run termux-wake-lock in Termux before running extended agent sessions to prevent Android from putting Termux into deep sleep.

Summary

Combining proot-distro with Antigravity CLI and the WordPress.com MCP server turns an Android device into a self-contained mobile publishing workstation. With native path wrappers, xdg-open bridged to termux-open-url, and prompt-free native read tools, the development and publishing workflow is completely frictionless and matches native Termux tooling.

Storage Tip: A minimal Ubuntu rootfs takes ~80MB compressed and ~250MB extracted. Keep your Termux internal storage above 1.5GB to account for pip/npm toolchains and model cache files.

Tested on Android 14 / Termux · Ubuntu 24.04 LTS ARM64 PRoot · Published via WordPress.com MCP

DEV Community: Malcolm Low

The Curious Case of 1/998001: Missing Number & Math Guide

1. The Power-of-10 Denominator Family

2. Mathematical Proof: The Series Expansion

3. Why is 998 Missing?

4. Python Verification Script

Frequently Asked Questions (FAQ)

Why does 1/998001 generate all 3-digit numbers?

Why is 998 missing in the decimal expansion of 1/998001?

What practical applications do these repeating fractions have?

Drawing Quantum Diagrams with Matplotlib on Android Termux

Quick Answer & Key Insight

1. What Was Tested

2. Install Termux Prerequisites

3. When Full Qiskit Will Not Install

4. The Lean Standalone Bloch Loader

5. Convert PNG to High-Performance WebP

6. Problems Encountered and Their Fixes

Frequently Asked Questions

Can I run Qiskit Aer simulations on Termux?

Why not just use matplotlib-inline?

Bloch Sphere Visual Guide: Basis States |0⟩, |1⟩, and Pauli X & Z Gates

Quick Answer & Key Insight

1. Why the Bloch Sphere Works: Geometry of a Pure State

Why the Half-Angle $\theta/2$?

2. Basis States and the Equatorial Plane

The Computational Basis (Z-Axis Poles)

The Equatorial Plane (X and Y Axes)

3. The Pauli X Gate: 180° Rotation Around the X-Axis

4. The Hadamard Gate: Bridging Poles and Equator

5. The Pauli Z Gate: 180° Phase Rotation Around the Z-Axis

6. X, H, and Z Transformations Side by Side

7. Python Verification in Qiskit

8. Summary & Key Takeaways

Frequently Asked Questions

Why is |1⟩ at the South Pole instead of 90° away from |0⟩?

Does the Pauli Z gate change measurement probabilities?

The Deutsch-Jozsa Algorithm Explained: Quantum Complexity & Qiskit

Quick Answer & Key Insight

1. The Problem: Constant vs. Balanced Boolean Functions

2. Complexity Comparison: Exponential Separation

3. The Mathematical Engine: Phase Kickback

4. Implementing All 4 Types of Oracles in Qiskit

Oracle 1: Constant-0 ($f(x) = 0$ everywhere)

Oracle 2: Constant-1 ($f(x) = 1$ everywhere)

Oracle 3: Balanced Direct ($f(x) = x_0 \oplus x_2$)

Oracle 4: Balanced Inverted ($f(x) = \neg(x_0 \oplus x_2)$)

Oracle Comparison Matrix

5. Full Circuit & Quantum Interference Derivation

The Mathematical Interference:

6. Complete Qiskit 2.x Python Implementation

Execution Output:

7. Key Insights & Takeaways

Frequently Asked Questions

Why does classical computing require 2^(n-1) + 1 evaluations for Deutsch-Jozsa?

How does the Deutsch-Jozsa algorithm achieve 100% determinism?

Quantum Fourier Transform (QFT) of a Single Qubit: The Hadamard Transform

1. The General Definition of the Quantum Fourier Transform

2. Specializing to One Qubit (N = 2)

3. Evaluating Basis States |0⟩ and |1⟩

Case 1: When $x = 0$

Case 2: When $x = 1$

The Matrix Identity

4. Verifying the Equivalence in Qiskit 2.x

Execution Output:

5. Frequently Asked Questions

Is the QFT of one qubit the exact same as the Hadamard gate?

What is the Quantum Fourier Transform used for in quantum algorithms?

How does the multi-qubit QFT generalize beyond 1 qubit?

Key Insights & Takeaways

Continue the Quantum Series

Superdense Coding Explained: Transmitting 2 Classical Bits in 1 Qubit with Qiskit 2.x

1. The Communication Limit: Holevo’s Bound vs. Entanglement

2. The 4-Step Protocol: Alice, Bob, and Charlie

3. The 4 Encoding Operations: From Bits to Bell States

Case 1: Message 00 — Identity Gate $I$

Case 2: Message 01 — Pauli-Z Gate $Z$ (Phase-Flip)

Case 3: Message 10 — Pauli-X Gate $X$ (Bit-Flip)

Case 4: Message 11 — Both Gates $ZX$ (Bit & Phase Flip)

Superdense Coding Protocol Truth Table

Case 1: Message `00` — Identity Gate $I$

Case 2: Message `01` — Pauli-Z Gate $Z$ (Phase-Flip)

Case 3: Message `10` — Pauli-X Gate $X$ (Bit-Flip)

Case 4: Message `11` — Both Gates $ZX$ (Bit & Phase Flip)

Exp 01: The Empirical Random Baseline (`0.56940`)

Model 1: Regularized Ridge Regression (Exp 06 — `0.13002`)

Model 2: CatBoost Regressor (Exp 07 — `0.12601`)

7 · Blending the Models (Exp 08 — `0.12363`)

1. Spatial Cabin Coordinates (`Deck_Side` and `Cabin_Num`)