Quantum Sudoku: collapsing, entangling, and sliding through universes

Quantum Sudoku: collapsing, entangling, and sliding through universes

This is a thinking toy. I’m not proving physics with Sudoku; I’m using Sudoku to feel what the math is doing: superposition, collapse, entanglement, GHZ/W-style tripartite structure, Schrödinger’s box, decoherence, Many-Worlds, and “the future creating the past.” In the draft below I’ll put demo parameters instead of illustrations. Later we’ll swap them for live snippets, gifs, or short videos.

Part I — The quantum cell

1) Observation and collapse (certainty first)

Start with a particle that’s already collapsed. In Sudoku-speak: a cell that has exactly one admissible state. When we click, we’re not discovering; we’re confirming.

2) Superposition of two states

Now the cell is {1,2} until we look. Repeated resets + clicks let readers feel probability: same setup, different runs, different outcomes.

3) Two independent particles

Two cells, both in superposition, but not entangled. Each collapses on its own timeline.

Part II — The rules of the universe (why correlations appear)

Sudoku’s laws are local: every row, column, and section must contain each number exactly once. Once we turn those on, cells start “talking” through constraints. That’s our bridge from “two dice” to “two qubits that care about each other.”

4) Turning on the laws

Even a 2×2 world shows how local consistency creates nonlocal consequences.

5) Hidden order behind the chaos

A standard 9×9 Sudoku has a definite solution (a hidden global state). We perceive “superposition” only because we haven’t computed the solution yet. Cognitively, it feels quantum; ontologically, it’s classical determinism hiding in plain sight.

Part III — Entanglement and partial observation

6) Two entangled particles (perfect anticorrelation)

Make a tiny universe where two cells must be different. Click one: the other is forced to the opposite value. This is the “wow” moment—measurement here shapes reality there.

7) Entanglement with more than two states

Let each cell have four possibilities. A measurement on one cell doesn’t finish the job—it just prunes the other’s possibilities. The vibe is partial collapse.

Left allowed: Right allowed:
Partial measure ⇒ choose 2 at random; other cell gets the complement. Same section ⇒ final values must differ.

7.1) Multipartite entanglement (three particles, new phenomena)

Two bodies can correlate; three bodies can do qualitatively new things. With 3×1, one section, hints {1,2,3}, we can show three different “tripartite flavors”:

All-Distinct (Sudoku-native constraint). Any click forces the remaining two to be the two other numbers (still undecided who is who until the next click).

GHZ-like (all-match). Only triplets (1,1,1), (2,2,2), (3,3,3) allowed. Measure one → all three lock.

W-like (single excitation). Only permutations of (3,1,1). If you see a 3 anywhere, the others must be 1s; if you see a 1, the lone 3 is still “somewhere else” (residual uncertainty survives a measurement).

Allowed L: Allowed M: Allowed R: Rule: three different numbers from {1,2,3}. First measurement prunes the others; they remain undecided until clicked.

Allowed L: Allowed M: Allowed R: Rule: only (1,1,1), (2,2,2), (3,3,3). Measure any cell ⇒ all three lock to the same value.

Allowed L: Allowed M: Allowed R: Rule: permutations of (3,1,1). Seeing a 3 fixes the other two to 1; seeing a 1 leaves a single unseen 3 “somewhere else.”

Optional hooks

// GHZ-like: after a value appears in any cell, set the others to the same value.
enforceGHZ(board_7b);

// W-like: enforce permutations of (3,1,1); if a cell becomes 3, set the others to 1.
// If a cell becomes 1, restrict others to {1,3} without fully collapsing them.
enforceW(board_7c);

8) Partial observation and decoherence (weak measurement vibe)

Sometimes you learn just enough to rule out half the story, but not enough to finish it. Clicks remove classes of hints on both sides without fixing a final value. That’s intuition for decoherence: coherence leaks; probabilities get “classical-ish,” yet the system isn’t fully collapsed.

Demo params

initSudoku("#p3_demo8", {
  subRows: 2, subCols: 1, singleSection: true,
  maxHint: 4, clickToSetAnswer: true,
  autoHints: false
});
// click handler: remove two hints here and the complementary two there; keep values unset

Part IV — Multiverse goggles

9) Many-Worlds vs true randomness vs hidden variables

Take an entangled 2×1 pair and put two boards side-by-side. In one, the first click yields 1; in the other, 2. What’s the story?

• Hidden state: deterministic, we just didn’t know.
• True randomness: the universe rolls dice.
• Many-Worlds: both outcomes occur; your experience is a branch.

Demo params

initSudoku("#p4_demo9A", { subRows: 2, subCols: 1, singleSection: true, maxHint: 2, clickToSetAnswer: true });
initSudoku("#p4_demo9B", { subRows: 2, subCols: 1, singleSection: true, maxHint: 2, clickToSetAnswer: true });

10) Schrödinger’s Sudoku (box inside a box)

Wrap a small Sudoku inside a “room.” Until we open the room, the inner board stays unobserved (our outer variables treat it as a single superposed object). Open the box → collapse inside becomes visible. Close/erase records → restore uncertainty (quantum eraser flavor).

Demo params

// outer placeholder
initSudoku("#p4_demo10", { subRows: 1, subCols: 1, singleSection: true });
// on click of the outer cell: dynamically spawn an inner board
initSudoku("#p4_demo10_inner", { subRows: 2, subCols: 2, singleSection: false, clickToSetAnswer: true });

Part V — The tree of futures (and the future that writes the past)

11) Branching futures while solving

An unsolved puzzle is a branching tree. Each reveal is a cut through possibility space. If a valid solution exists, the branches eventually converge. If not, branches proliferate forever—internally consistent local moves, globally inconsistent world.

Demo params

initSudoku("#p5_demo11", {
  subRows: 3, subCols: 3, singleSection: false,
  clickToSetAnswer: true, autoHints: true, autosolver: false
});

12) From future to past: restore superposition from a known finale

Now invert it. Load the final solved state (maximum certainty, call it “intelligence”). Then erase values at random. Certainty decays into structured superposition; order begets new ignorance. Philosophically: once comprehension reaches a fixed point, it can only continue by creating uncertainty—new games to play.

Demo params

initSudoku("#p5_demo12", {
  subRows: 3, subCols: 3, singleSection: false,
  clickToSetAnswer: true, autoHints: true, autosolver: true,
  correctValues: /* fullSolution map injected at runtime */,
});
// UI: Entropy slider => erase N random cells; Step Forward => one-hint fill; Step Back => erase 1

Part VI — Epilogue: sliding between universes; scripts and cycles

13) Sliding between nearby universes

Run three identical boards with the same seed and click in different orders. You’ll feel the slide: tiny input differences → different branches. Not teleportation—just adjacent realities diverging smoothly under your fingers.

Demo params

["#p6_demo13a", "#p6_demo13b", "#p6_demo13c"].forEach(sel =>
  initSudoku(sel, { subRows: 2, subCols: 2, singleSection: false, clickToSetAnswer: true })
);

14) Scripted universes and rebirth

If a unique solution exists, the end is written. The start (maximum uncertainty) and the end (maximum certainty) are a matched pair. You can read time in either direction: solving or erasing. After a full solve, hit “entropy” and start again. Intelligence reaches closure, then—inevitably—bootstraps a fresh unknown.

Demo params

// Chain: demo11 (branching) -> demo12 (final→uncertainty) -> back to Part I (single-cell soup)

Notes on the analogy

• Real quantum theory is math (Hilbert spaces, operators, POVMs, phases). Sudoku gives intuitive hooks: constraints ⇒ correlations; observation ⇒ pruning possibility space; partial information ⇒ decoherence feel.
• Hidden-state Sudoku ≠ quantum indeterminacy. That’s the point: by contrasting the two, we get a handle on interpretations.
• Tripartite cases (All-Distinct vs GHZ-like vs W-like) are especially useful. Pairwise intuition breaks; you need to think globally.

What’s next

• Swap the parameter blocks for live demos driven by sudoku.js.
• Add tiny “state overlays” (counts of hints per cell, entropy meter).
• Record short clips for each concept (15–30s) so the rhythm of collapse/decohere/entangle is obvious even without clicking.

If you want, I’ll stitch this into a single page with Next/Prev buttons and load/unload the appropriate initSudoku(...) per section so the article literally plays like a guided tour.

• ←Previous
• Next→

Baraban & Kun L. (2025). Quantum Sudoku: collapsing, entangling, and sliding through universes.https://KintaroAI.com/blog/2025/10/08/quantum-sudoku-collapsing-entangling-and-sliding-through-universes/ (KintaroAI)

@misc{baraban2025quantumsudokucollapsingentanglingandslidingthroughuniverses,
    author = {Baraban and LLM Kun},
    title = {Quantum Sudoku: collapsing, entangling, and sliding through universes},
    year = {2025},
    url = {https://KintaroAI.com/blog/2025/10/08/quantum-sudoku-collapsing-entangling-and-sliding-through-universes/},
}