DEV Community: Malcolm Low

Multi-Class Log Loss Explained: Math, MLE & Python Code

Malcolm Low — Mon, 26 Oct 2026 04:33:21 +0000

A comprehensive technical guide to Multi-Class Logarithmic Loss (Log Loss / Categorical Cross-Entropy): why lower loss indicates superior probabilistic calibration, how Maximum Likelihood Estimation requires the negative sign, why logarithms prevent floating-point underflow on large datasets, and how asymmetric penalties punish overconfident mispredictions.

1 · The Mathematical Formula & Variable Definitions

For a dataset containing N samples evaluated across C mutually exclusive classes, Multi-Class Logarithmic Loss is defined as:

$$L = -\frac{1}{N} \sum_{i=1}^N \sum_{c=1}^C y_{i,c} \ln(p_{i,c})$$

Every symbol and variable in this formulation serves a distinct mathematical role:

Symbol / Variable	Domain / Value	Formal Definition & Mathematical Purpose
`N`	Positive integer	Total number of observations or samples in the evaluation dataset.
`C`	Integer $\ge 2$	Total number of discrete candidate classes in the classification task.
`y_{i,c}`	`{0, 1}`	Binary one-hot indicator: equals 1 if observation `i` belongs to class `c`, and 0 otherwise.
`p_{i,c}`	`(0.0, 1.0)`	Model's predicted probability that observation `i` belongs to class `c`, where $\sum_c p_{i,c} = 1.0$.
`\ln`	Mathematical operator	The natural logarithm (base $e \approx 2.71828$). In information theory, base 2 is often used, measuring loss in bits.

2 · Why is Lower Better?

In statistical learning, loss functions quantify the divergence between prediction and reality. Multi-class log loss is strictly lower is better due to two fundamental conventions:

The Target Value (Zero Loss): A theoretically perfect model assigns a probability of exactly 1.0 to the true class and 0.0 to all other classes. Because $\ln(1.0) = 0$, the resulting log loss for a perfect prediction is exactly 0.0. As predictions become less certain or more erroneous, the loss value grows toward positive infinity.
Minimization Convention in Optimization: Machine learning algorithms (such as stochastic gradient descent, Adam, or tree splitting criteria) are designed to minimize an objective cost function. Formulating log loss so that 0 represents perfection allows standard gradient descent algorithms to iteratively step downhill toward minimum error.

3 · Why the Negative Sign? From MLE to Gradient Descent

The negative sign at the front of the formula is required by the mathematical relationship between probabilities and logarithms:

Probabilities are Fractions Less Than or Equal to 1: Valid probabilities p satisfy $0 < p \le 1$. The natural logarithm of any fraction between 0 and 1 is strictly negative (for example, $\ln(0.5) \approx -0.693$, and $\ln(0.1) \approx -2.302$).
Maximum Likelihood Estimation (MLE): In classical statistics, generative and discriminative models are trained by maximizing the likelihood of observing the training data: $\max \prod_i P(y_i \mid x_i)$. Taking the natural logarithm converts this into maximizing the log-likelihood: $\max \sum_i \ln(P(y_i \mid x_i))$.
Flipping Maximization into Minimization: Because log-likelihood is negative, multiplying by -1 flips the sign from negative to positive. Maximizing the positive likelihood of the data is mathematically identical to minimizing the Negative Log-Likelihood (NLL). The negative sign transforms statistical MLE into a convex loss surface that gradient descent can minimize.

4 · Why the Need for a Logarithm?

The logarithm is not an arbitrary mathematical choice; it solves two practical challenges in computation and model calibration:

1. Converting Products into Sums (Preventing Numerical Underflow)

Assuming independent data points, the joint probability of an entire dataset is the product of individual probabilities:

$$P_{\text{joint}} = P_1 \times P_2 \times \dots \times P_N$$

When multiplying thousands of floating-point numbers smaller than 1.0 (such as $0.8^{1000}$), the result approaches zero so quickly that standard 64-bit IEEE floating-point numbers experience arithmetic underflow (the computer rounds the value to absolute zero).

Applying the logarithm exploits the logarithmic identity $\ln(a \cdot b) = \ln(a) + \ln(b)$. This transforms product chains into numerically stable sums of negative numbers that CPUs can accumulate without precision loss.

2. Penalty Amplification for Overconfident Mistakes

The logarithmic curve acts as an asymmetric penalty amplifier. Because $\lim_{p \to 0} \ln(p) = -\infty$, the loss penalty escalates steeply as the predicted probability for the true class approaches zero:

Predicted Probability for True Class `p_{true}`	Instance Log Loss Penalty `-\ln(p_{true})`	Practical Model Diagnosis
`0.99`	`0.01005`	Near-perfect prediction with high confidence.
`0.80`	`0.22314`	Accurate prediction with moderate certainty.
`0.50`	`0.69315`	Uncertain coin-flip assignment.
`0.10`	`2.30259`	Significant error: model favored alternative classes.
`0.01`	`4.60517`	Severe mistake: model was 99% confident in wrong classes.
`0.0001`	`9.21034`	Catastrophic penalty: one such prediction can wreck a batch average.

5 · Worked Numerical Example: 3-Class Animal Classifier

Consider a 3-class image classification model evaluating an image containing a Cat across three possible categories: [Cat, Dog, Bird].

True Ground Truth Label: y = [1, 0, 0] (Class 0 is Cat).
Baseline Model Prediction: p = [0.80, 0.10, 0.10].

Applying the multi-class formula for this single sample:

$$\text{Loss} = - [ 1 \cdot \ln(0.80) + 0 \cdot \ln(0.10) + 0 \cdot \ln(0.10) ]$$
$$\text{Loss} = - [ -0.22314 + 0 + 0 ] = \mathbf{0.22314}$$

Now consider two alternative prediction scenarios on the exact same sample:

Scenario A: High-Confidence Correct Prediction

The model predicts P(Cat) = 0.95, P(Dog) = 0.03, P(Bird) = 0.02:

$$\text{Loss} = -\ln(0.95) \approx \mathbf{0.05129} \quad (\text{Lower is better})$$

Scenario B: Confident Mistake (Misclassified as Dog)

The model erroneously predicts that the animal is a Dog with 90% confidence, leaving only P(Cat) = 0.05:

$$\text{Loss} = -\ln(0.05) \approx \mathbf{2.99573} \quad (\text{Over 13x higher penalty than baseline})$$

Because the logarithm curves sharply toward infinity near zero, a single confident misprediction in Scenario B produces a penalty larger than twenty accurate predictions combined.

6 · Robust Python Implementation (NumPy & PyTorch)

In software engineering, implementing -np.log(p) directly is dangerous: if the model outputs a probability of exactly 0.0, np.log(0.0) produces -inf, poisoning the entire dataset score with NaN. To prevent this, standard implementations clip probabilities by an epsilon threshold (typically 1e-15):

import numpy as np

def multiclass_log_loss(y_true, y_pred, eps=1e-15):
    # Clip probabilities to [eps, 1 - eps]
    y_pred_clipped = np.clip(y_pred, eps, 1.0 - eps)

    # Renormalize rows so probabilities sum strictly to 1.0
    y_pred_clipped = y_pred_clipped / y_pred_clipped.sum(axis=1, keepdims=True)

    # Compute cross-entropy across all elements, normalized by sample count N
    loss = -np.sum(y_true * np.log(y_pred_clipped)) / y_true.shape[0]
    return float(loss)

# Verification with sample data
y_true = np.array([[1, 0, 0], [0, 1, 0]])
y_pred = np.array([[0.80, 0.10, 0.10], [0.05, 0.90, 0.05]])
print(f"Log Loss: {multiclass_log_loss(y_true, y_pred):.5f}")
# Output: 0.16425

PyTorch Equivalent

In deep learning frameworks like PyTorch, nn.CrossEntropyLoss combines LogSoftmax and NLLLoss into a single numerically stable fused kernel, operating directly on unnormalized model logits:

import torch
import torch.nn as nn

# Raw unnormalized model logits for 2 samples across 3 classes
logits = torch.tensor([[2.0, 0.5, 0.1], [-1.0, 3.2, 0.4]])

# Ground truth class indices (Class 0, Class 1)
targets = torch.tensor([0, 1])

criterion = nn.CrossEntropyLoss()
loss = criterion(logits, targets)
print(f"PyTorch Loss: {loss.item():.5f}")

7 · Practical Takeaways for Machine Learning Competitions

When competing on Kaggle or deploying probability models in production (such as our ongoing investigation in Pocket Data Science IX on Chatbot Arena LLM Evaluation), log loss demands distinct strategic behaviors:

Never Predict Absolute Certainty: Unless a physical law guarantees an outcome, never predict 1.0 or 0.0. If an outlier or annotation ambiguity reverses the label, a single zero probability will result in infinite loss.
Prior-Based Initialization: Initializing model biases or baseline logits to the natural logarithm of training class frequencies $\ln(p_c)$ guarantees optimal default calibration, preventing severe penalties on ambiguous queries.
Temperature & Platt Scaling: When ensembling deep learning models or tree-based boosters, apply post-processing probability calibration (such as temperature scaling or isotonic regression) to prevent overconfident softmax peaks.

Po-Shen Loh Quadratic Method: Solve Equations via Symmetry

Malcolm Low — Sun, 11 Oct 2026 07:49:11 +0000

Originally published on malcolmlow.com as part of the Foundational Mathematics & Algorithms series.

For four millennia—spanning Babylonian clay tablets, Renaissance cryptanalysts, and modern classroom algebra—solving quadratic equations has been synonymous with two unappealing extremes: brute-force factor guessing or blind formula memorization.

In December 2019, Professor Po-Shen Loh of Carnegie Mellon University introduced a method that bypasses both. By decomposing the monic quadratic into its parabolic axis of symmetry and computing an offset distance via Vieta's relations, any quadratic equation—whether its roots are integer, irrational, or complex—can be solved intuitively with simple mental arithmetic.

1. The 4,000-Year-Old Algebra Trap: Factoring Guesswork vs. Formula Memorization

Traditional secondary school mathematics approaches quadratic equations ax^2 + bx + c = 0 through two standard techniques, each suffering from pedagogical and practical flaws:

Guess-and-Check Factoring: Students search by mental trial-and-error for two numbers that multiply to c and add to b. When coefficients are large, negative, or fractional, this devolves into frustrating combinatorial guessing. When roots are irrational or complex, factoring fails completely.
Blind Formula Memorization: When factoring fails, students recite the quadratic formula:

x = (-b ± √(b^2 - 4ac)) / (2a)

While algebraically valid, the classical formula functions as an opaque black box. Students plug numbers mechanically into nested signs, radical bars, and denominators. A single misplaced negative sign inside b^2 - 4ac or forgotten 2a in the denominator leads to silent arithmetic errors.

In December 2019, Professor Po-Shen Loh—a mathematics professor at Carnegie Mellon University and national coach of the USA International Mathematical Olympiad (IMO) team—published a paper showing that this dichotomy is unnecessary. Rather than discovering new mathematics, he combined two centuries-old mathematical principles into an algorithm that makes root-finding intuitive and computationally robust.

2. Who Was Vieta? The Royal Cryptanalyst Behind the Root Formulas

To understand how the method works, we turn to the Renaissance thinker who first unlocked the relationships between polynomial roots and their coefficients: François Viète (latinized as Franciscus Vieta, 1540–1603).

Viète was a distinguished French jurist, privy councillor to King Henry III and King Henry IV of France, and a master cryptanalyst. During the French Wars of Religion, King Philip II of Spain utilized a cipher with over 500 characters, believing it unbreakable. Viète cracked the Spanish royal code, allowing France to intercept Spain's military strategies for over two years—to the extent that Philip II complained to the Pope that the French were using black magic.

In mathematics, Viète earned immortality as the "Father of Modern Algebraic Notation" by introducing the systematic use of letters to represent both knowns and unknowns. In his 1591 treatise In artem analyticem isagoge, he discovered the universal relations that bear his name: Vieta's Formulas.

For a monic quadratic equation where the leading coefficient is normalized to 1:

(x - r_1)(x - r_2) = x^2 - (r_1 + r_2)x + r_1 * r_2 = 0

Equating this expansion to x^2 + Bx + C = 0 reveals two exact invariant equations:

Sum of roots: r_1 + r_2 = -B
Product of roots: r_1 * r_2 = C

Vieta's Core Principle: You never need to calculate individual roots beforehand to know their exact sum and product. They are directly encoded into the polynomial's linear and constant terms.

3. The Core Mathematical Breakthrough: Parabolic Symmetry & Root Offsets

Every standard quadratic equation x^2 + Bx + C = 0 graphs as a vertical parabola y = x^2 + Bx + C. A parabola possesses bilateral symmetry across its vertical axis of symmetry passing through its vertex.

Axis of Symmetry (Midpoint): m = -B / 2

Because Vieta's formula proves that the sum of the two roots is -B, their arithmetic mean (midpoint) must be:

Midpoint m = (r_1 + r_2) / 2 = -B / 2

Since the roots are symmetrically spaced around the midpoint m, we can represent them as:

r_1 = m - u = -B/2 - u
r_2 = m + u = -B/2 + u

where u is the horizontal offset distance from the axis of symmetry to each root.

Figure 1: Geometric symmetry of the quadratic curve y = x^2 - 8x + 12. The axis of symmetry sits at m = -(-8)/2 = 4. The roots x = 2 and x = 6 lie symmetrically at 4 - 2 and 4 + 2.

Now comes the breakthrough: Vieta's second relation tells us that the product of the two roots equals C. Substituting our symmetric expressions yields a difference of squares:

(m - u)(m + u) = C
m^2 - u^2 = C
u^2 = m^2 - C
u = √(m^2 - C)

The Symmetry Solution: Once we compute u, the roots are immediately m - u and m + u. No quadratic formula memorization, no cross-multiplication, and no trial-and-error guessing required.

4. The 3-Step Po-Shen Loh Algorithm

Whenever you solve a quadratic equation, execute these three steps:

Normalize to Monic Form: If the equation has a leading coefficient a != 1, divide the entire equation by a:

   x^2 + Bx + C = 0,   where B = b/a, C = c/a

Compute the Midpoint: Calculate m = -B / 2. The roots are m - u and m + u.
Solve for Offset u: Set m^2 - u^2 = C, which gives:

   u^2 = m^2 - C  ==>  u = √(m^2 - C)

The roots are:

   x = m ± u

Why Sign Errors Vanish: In the traditional formula, negative signs interact inside b^2 - 4ac and across division by 2a. In Po-Shen Loh's method, the midpoint m = -B/2 is evaluated independently, and m^2 is always positive. You only perform a clean subtraction m^2 - C.

5. The Three Geometric Realities of the Offset `u^2`

In traditional algebra, students memorize the discriminant Δ = b^2 - 4ac to determine root regimes. In Po-Shen Loh's method, the value of u^2 = m^2 - C directly reveals the geometric relationship between the parabola and the x-axis:

Case 1: Positive Offset (`u^2 > 0`) — Two Distinct Real Roots

When m^2 > C, u^2 is positive. Geometrically, the vertex of the parabola lies below the x-axis (vertex_y < 0). The parabola cuts the x-axis at two distinct real points: m - u and m + u.

Figure 2: Case 1 (u^2 > 0). The parabola y = x^2 - 4x + 3 dips below the x-axis (m = 2, u^2 = 1, u = 1), yielding distinct real roots at x = 1 and x = 3.

Case 2: Zero Offset (`u^2 = 0`) — One Repeated Real Root

When m^2 = C, u^2 = 0 so u = 0. The vertex of the parabola touches the x-axis tangent at y = 0. Both roots collapse to the midpoint x = m.

Figure 3: Case 2 (u^2 = 0). The vertex of y = x^2 - 4x + 4 is tangent to the x-axis at (2, 0). The root is a single repeated value x = 2.

Case 3: Negative Offset (`u^2 < 0`) — Two Complex Conjugate Roots

When m^2 < C, u^2 is negative. The vertex floats entirely above the x-axis (vertex_y > 0), never intersecting it in the real plane. The square root produces an imaginary offset u = i * √(|u^2|), yielding complex conjugate roots m ± i * √(|u^2|).

Figure 4: Case 3 (u^2 < 0). The parabola y = x^2 - 4x + 7 floats above the x-axis (m = 2, u^2 = -3, u = i√3). The roots are complex conjugates 2 - i√3 and 2 + i√3.

6. Step-by-Step Worked Examples

Example 1: Standard Integer Roots (Eliminating Guesswork)

Solve: x^2 - 8x + 12 = 0

Coefficients: Monic equation with B = -8 and C = 12.
Midpoint: m = -(-8) / 2 = 4. The roots are 4 - u and 4 + u.
Offset:

   4^2 - u^2 = 12
   16 - u^2 = 12
   u^2 = 4  ==>  u = 2

Roots: x = 4 - 2 = 2 and x = 4 + 2 = 6.

Example 2: Irrational Roots (Where Factoring Fails)

Solve: x^2 - 4x - 1 = 0

Coefficients: Monic with B = -4 and C = -1. Factoring fails as no rational factors multiply to -1 and add to -4.
Midpoint: m = -(-4) / 2 = 2. The roots are 2 - u and 2 + u.
Offset:

   2^2 - u^2 = -1
   4 - u^2 = -1
   u^2 = 5  ==>  u = √5

Roots: x = 2 - √5 and x = 2 + √5.

Example 3: Complex / Imaginary Roots

Solve: x^2 - 6x + 25 = 0

Coefficients: Monic with B = -6 and C = 25.
Midpoint: m = -(-6) / 2 = 3. Roots are 3 - u and 3 + u.
Offset:

   3^2 - u^2 = 25
   9 - u^2 = 25
   u^2 = -16  ==>  u = √(-16) = 4i

Roots: x = 3 - 4i and x = 3 + 4i.

Example 4: Leading Coefficient `a != 1`

Solve: 2x^2 + 5x - 3 = 0

Normalize to Monic: Divide by 2:

   x^2 + (5/2)x - 3/2 = 0   ==>   B = 5/2, C = -3/2

Midpoint: m = -(5/2) / 2 = -5/4. Roots are -5/4 - u and -5/4 + u.
Offset:

   (-5/4)^2 - u^2 = -3/2
   25/16 - u^2 = -24/16
   u^2 = 49/16  ==>  u = 7/4

Roots:

x = -5/4 - 7/4 = -12/4 = -3
x = -5/4 + 7/4 = 2/4 = 1/2

7. Method Comparison: Traditional Formula vs. Po-Shen Loh

Feature	Traditional Quadratic Formula	Po-Shen Loh Method
Cognitive Load	High memorization (`-b ± √(b^2 - 4ac) / 2a`)	Low (midpoint `m = -B/2` + difference of squares)
Arithmetic Traps	Nested negative signs inside radical & denominator	Separated midpoint; `m^2` is guaranteed non-negative
Geometric Insight	Abstract algebraic manipulation	Directly leverages parabolic axis of symmetry
Complex Numbers	Negative discriminant requires radical refactoring	Negative `u^2` directly yields imaginary offset `i * √(

8. Numerical Computing & Floating-Point Stability Implications

Beyond secondary education, Po-Shen Loh's formulation holds important computational benefits for numerical programmers:

Catastrophic Cancellation Avoidance: In standard IEEE 754 floating-point arithmetic, evaluating {% raw %}-b + √(b^2 - 4ac) when b > 0 and 4ac << b^2 results in catastrophic subtraction of nearly equal numbers, wiping out significant precision digits. Numerical libraries (such as NumPy, LAPACK, and Boost) compute the vertex midpoint m and root offset independently, switching formulas based on the sign of b.
Ray-Sphere Intersections in Computer Graphics: Ray tracers compute ray-sphere collisions via quadratic equations. Expressing the equation via midpoint and offset distance computes the closest approach distance along the ray (m) before evaluating whether the ray pierces the sphere radius (u), allowing early-out branching without computing square roots.

9. Python Implementation & Verifiable Test Suite

Below is a complete, self-contained Python 3 implementation that unifies all three root regimes with robust string formatting:

import math

def solve_po_shen_loh(a: float, b: float, c: float):
    """
    Solves ax^2 + bx + c = 0 using the Po-Shen Loh method.
    Returns (r1, r2, regime)
    """
    if a == 0:
        raise ValueError("Leading coefficient 'a' cannot be zero.")

    # Step 1: Normalize to monic form x^2 + Bx + C = 0
    B = b / a
    C = c / a

    # Step 2: Compute midpoint m = -B / 2
    m = -B / 2.0

    # Step 3: Compute offset squared u^2 = m^2 - C
    u_squared = m**2 - C

    if abs(u_squared) < 1e-12:
        # Case 2: One repeated real root (u = 0)
        return (m, m, "Repeated Real Root")
    elif u_squared > 0:
        # Case 1: Two distinct real roots
        u = math.sqrt(u_squared)
        return (m - u, m + u, "Two Distinct Real Roots")
    else:
        # Case 3: Two complex conjugate roots
        u_imag = math.sqrt(-u_squared)
        return (complex(m, -u_imag), complex(m, u_imag), "Two Complex Conjugate Roots")

def format_root(r):
    if isinstance(r, complex):
        return f"{r.real:.1f}{r.imag:+.1f}j"
    return f"{r:.4f}"

# Run verification test cases
test_cases = [
    (1, -8, 12, "x^2 - 8x + 12 = 0"),
    (1, -4, -1, "x^2 - 4x - 1 = 0"),
    (1, -6, 25, "x^2 - 6x + 25 = 0"),
    (2,  5, -3, "2x^2 + 5x - 3 = 0"),
    (1, -4,  4, "x^2 - 4x + 4 = 0")
]

print("{:20} | {:15} | {:15} | {}".format("Equation", "Root 1", "Root 2", "Regime"))
print("-" * 75)
for a, b, c, label in test_cases:
    r1, r2, regime = solve_po_shen_loh(a, b, c)
    print("{:20} | {:15} | {:15} | {}".format(label, format_root(r1), format_root(r2), regime))

Verifiable Terminal Output

Equation             | Root 1          | Root 2          | Regime
---------------------------------------------------------------------------
x^2 - 8x + 12 = 0    | 2.0000          | 6.0000          | Two Distinct Real Roots
x^2 - 4x - 1 = 0     | -0.2361         | 4.2361          | Two Distinct Real Roots
x^2 - 6x + 25 = 0    | 3.0-4.0j        | 3.0+4.0j        | Two Complex Conjugate Roots
2x^2 + 5x - 3 = 0    | -3.0000         | 0.5000          | Two Distinct Real Roots
x^2 - 4x + 4 = 0     | 2.0000          | 2.0000          | Repeated Real Root

10. Key Takeaways

Symmetry Replaces Factoring: Instead of guessing factor pairs of C that sum to -B, we start at the midpoint m = -B/2 and find the distance u to both roots.
Vieta's Formulas Form the Backbone: The method relies directly on 16th-century relations: r_1 + r_2 = -B and r_1 * r_2 = C.
All Three Root Regimes Unified: Whether roots are distinct real (u^2 > 0), repeated real (u^2 = 0), or complex conjugates (u^2 < 0), the procedure is identical.
Sign Errors Eliminated: Isolating the midpoint calculation m = -B/2 prevents negative sign slip-ups inside radical fractions.

Frequently Asked Questions

Does the Po-Shen Loh method replace the quadratic formula?

Mathematically, the Po-Shen Loh method is equivalent to the quadratic formula—in fact, carrying out the method with general variables a, b, c produces the classical formula. Its advantage lies in mental calculation, intuition, and reducing algebraic manipulation errors.

Who was Vieta and what is his connection to this method?

François Viète (1540–1603), known as Vieta, was a 16th-century French royal cryptanalyst and mathematician who established that the sum of the roots of a monic quadratic equals -B and their product equals C. The Po-Shen Loh method combines Vieta's formulas with parabolic symmetry.

Why was this method only popularized in 2019?

While Babylonian mathematicians utilized related geometric area arguments and Vieta published root relations in 1591, textbook curricula historically converged on memorizing the completed-square formula. Professor Po-Shen Loh synthesized these steps into an accessible algorithmic framework for students and educators in December 2019.

How does the method handle complex or imaginary roots?

When m^2 < C, the offset squared u^2 is negative. Taking the square root directly yields an imaginary offset u = i * √(|u^2|), giving the complex conjugate root pair m ± i * √(|u^2|) without changing the workflow.

Malcolm Low is an Associate Professor at the Singapore Institute of Technology, writing on mathematics, algorithms, and applied computing.

Website: malcolmlow.com

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.

DEV Community: Malcolm Low

Multi-Class Log Loss Explained: Math, MLE & Python Code

1 · The Mathematical Formula & Variable Definitions

2 · Why is Lower Better?

3 · Why the Negative Sign? From MLE to Gradient Descent

4 · Why the Need for a Logarithm?

1. Converting Products into Sums (Preventing Numerical Underflow)

2. Penalty Amplification for Overconfident Mistakes

5 · Worked Numerical Example: 3-Class Animal Classifier

Scenario A: High-Confidence Correct Prediction

Scenario B: Confident Mistake (Misclassified as Dog)

6 · Robust Python Implementation (NumPy & PyTorch)

PyTorch Equivalent

7 · Practical Takeaways for Machine Learning Competitions

Po-Shen Loh Quadratic Method: Solve Equations via Symmetry

1. The 4,000-Year-Old Algebra Trap: Factoring Guesswork vs. Formula Memorization

2. Who Was Vieta? The Royal Cryptanalyst Behind the Root Formulas

3. The Core Mathematical Breakthrough: Parabolic Symmetry & Root Offsets

4. The 3-Step Po-Shen Loh Algorithm

5. The Three Geometric Realities of the Offset u^2

Case 1: Positive Offset (u^2 > 0) — Two Distinct Real Roots

Case 2: Zero Offset (u^2 = 0) — One Repeated Real Root

Case 3: Negative Offset (u^2 < 0) — Two Complex Conjugate Roots

6. Step-by-Step Worked Examples

Example 1: Standard Integer Roots (Eliminating Guesswork)

Example 2: Irrational Roots (Where Factoring Fails)

Example 3: Complex / Imaginary Roots

Example 4: Leading Coefficient a != 1

7. Method Comparison: Traditional Formula vs. Po-Shen Loh

8. Numerical Computing & Floating-Point Stability Implications

9. Python Implementation & Verifiable Test Suite

Verifiable Terminal Output

10. Key Takeaways

Frequently Asked Questions

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)$)

5. The Three Geometric Realities of the Offset `u^2`

Case 1: Positive Offset (`u^2 > 0`) — Two Distinct Real Roots

Case 2: Zero Offset (`u^2 = 0`) — One Repeated Real Root

Case 3: Negative Offset (`u^2 < 0`) — Two Complex Conjugate Roots

Example 4: Leading Coefficient `a != 1`

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`)