Sudoku Logic

Sudoku is often described as a logic puzzle, but “use logic” can sound vague until the deductions are broken into smaller pieces.

At every point in a solve, the grid contains information about what is:

• already true;
• still possible;
• impossible;
• reserved for particular cells or houses;
• conditionally true if another candidate is false.

A Sudoku technique is useful because it converts that information into a proof.

The proof normally produces one of two practical results:

placement — a digit must go in a cell;

or:

elimination — a digit cannot go in a cell.

Everything from a Naked Single to an advanced Chain can be understood as a more specific way of proving one of those statements.

What does “logical” mean in Sudoku?

In these Guides, a deduction is logical when its conclusion follows from clearly stated constraints and premises rather than from random choice.

The basic classic-Sudoku constraints are:

• one of each digit in every row;
• one of each digit in every column;
• one of each digit in every box.

Some advanced techniques may use an additional explicitly stated premise, such as:

this puzzle is verified to have exactly one solution.

What matters is that the premise is known and the conclusion follows from it.

Logical solving is therefore not defined by whether a step looks simple. A long chain can be logical. A very confident unsupported placement is still a guess.

Four recurring kinds of Sudoku information

Many techniques can be understood through four information types.

1. Forced value

A digit is proved to occupy one cell.

Examples:

• Full House / Last Digit;
• Naked Single;
• Hidden Single;
• a placement produced after an advanced elimination.

2. Forbidden value

A candidate is proved impossible in one cell.

Examples:

• a peer already contains the digit;
• Locked Candidates removes the digit;
• an X-Wing eliminates the digit;
• a Chain proves the candidate false.

3. Reservation

A set of digits is confined to a set of cells, or a digit is confined to a set of positions.

Examples:

• Naked Pair reserves two digits for two cells;
• Hidden Triple reserves three digits for three cells;
• a conjugate pair reserves one digit for one of two positions;
• a Fish reserves candidate positions across base/cover houses.

4. Implication

One candidate state forces another state.

Examples:

• if A is true, B must be false;
• if A is false, B must be true;
• following those implications through several nodes creates a Chain.

Advanced Sudoku becomes much easier when you stop seeing techniques as unrelated names and start seeing them as combinations of these four information types.

Candidates are a model of uncertainty

An unsolved cell may have several candidates:

{2,5,7}

That notation does not say that the three possibilities are equally likely.

Sudoku is not a probability game at that stage. The candidate set means only:

Based on the deductions made so far, 2, 5, and 7 have not yet been ruled out here.

A new deduction can then transform the state:

{2,5,7} → {2,7}

and later:

{2,7} → {7}

The last step creates a Naked Single.

This is why candidate elimination is real progress even when the board does not immediately gain a large solved digit.

Legal is weaker than solved

One of the most important beginner-to-advanced transitions is learning the difference between:

“This digit could legally go here.”

and:

“This digit must go here.”

A candidate can be locally legal because no solved peer currently blocks it.

That does not prove it is the solution.

A placement needs a stronger statement—for example:

• every other digit is impossible in the cell;
• every other position for the digit is impossible in the house;
• a chain of implications forces the candidate true.

A legal move is a possibility. A solved move is a proof.

Cell-first reasoning

Cell-first reasoning asks:

What can happen inside this cell or small set of cells?

Typical structures include:

• Naked Single;
• bivalue cells;
• Naked Pairs/Triples;
• XY-Wing;
• W-Wing;
• XY-Chain.

The important object is often the candidate set inside the cell.

For example, a bivalue cell {3,8} gives a strong internal relationship:

if it is not 3, it must be 8; if it is not 8, it must be 3.

That relationship later becomes useful in Wings and Chains.

Digit-first reasoning

Digit-first reasoning asks:

Where can this one digit still go?

Typical structures include:

• Hidden Single;
• Locked Candidates;
• conjugate pairs;
• Skyscraper;
• Two-String Kite;
• X-Wing and other Fish;
• Simple Coloring;
• X-Chains.

Here the important object is not one cell's full candidate set. It is the distribution of one digit across several houses.

Moving deliberately between cell-first and digit-first views is one of the most powerful general solving habits.

Unit-first reasoning

A third useful lens starts from a row, column, or box:

What obligations exist inside this house?

A unit-first scan can reveal:

• a missing final digit;
• a Hidden Single;
• a subset;
• a Locked Candidates intersection;
• a conjugate pair.

Unit-first reasoning is often the bridge between basic scanning and more formal candidate analysis.

Local logic and distributed logic

Sudoku deductions differ partly in how far their proof travels.

Local deductions

The proof is concentrated in one cell or a small number of directly related houses.

Examples:

• Singles;
• Locked Candidates;
• Pairs and Triples.

Distributed deductions

The proof spans multiple separated parts of the grid.

Examples:

• Fish;
• W-Wing;
• Coloring;
• X-Chains;
• XY-Chains;
• later AIC and forcing structures.

Distributed does not mean “less logical”. It simply means that the relevant constraint network is larger.

Counting is one of Sudoku's deepest recurring ideas

Many apparently different techniques are consequences of matching a number of objects to the same number of available places.

Subset counting

If two cells in a house can contain only two digits between them, those digits are reserved for the two cells.

General form:

N cells ↔ N digits

Hidden subset counting

If N digits can appear only in N cells of a house, those cells are reserved for those digits.

Same reservation, discovered from the opposite direction.

Fish counting

A basic Fish applies a related idea across houses.

For one digit:

N base houses → candidate positions contained in N cover houses

The covers must accommodate the required occurrences from the bases, so certain outside candidates in those cover houses become impossible.

Recognizing the shared counting idea makes Pairs, Triples, X-Wing, Swordfish, and Jellyfish feel less like unrelated tricks.

Strong and Weak Links are implication language

Advanced candidate reasoning often uses two basic link types.

Weak Link

Two states cannot both be true.

For candidates A and B:

if A is true, B must be false.

Both can still be false.

Strong Link

Two states cannot both be false.

For candidates A and B:

if A is false, B must be true.

For simple candidates, conjugate pairs and bivalue-cell relationships are common sources of Strong Links.

An important advanced detail is that a simple Strong Link can also be used in the weak direction when the two candidates cannot both be true.

That flexibility is what lets Chains alternate inference types across the grid.

Chains turn implications into proof

A chain connects implications so that the truth state of one endpoint constrains the other.

A simplified structure might read conceptually:

A false
→ B true
→ C false
→ D true

If the chain proves that at least one of two endpoints must be true, a candidate that conflicts with both endpoints can be eliminated.

The exact candidate nodes and link types vary by chain family, but the logic is not magic:

each step must be justified by the immediately connected relationship.

That is the difference between tracing a valid implication chain and inventing a story around candidates that merely look connected.

Contradiction is a proof method

A contradiction argument has the form:

1. assume a clearly defined candidate/state;
2. follow logical consequences;
3. reach an impossible state;
4. conclude that the original assumption is false.

Common impossible states include:

• a cell with no candidate;
• the same solved digit twice in one house;
• a required digit with no possible position in a house;
• one candidate forced both true and false.

Contradiction is therefore not automatically “guessing”.

The difference is what you do with the assumption:

• guessing chooses a branch because you hope it is correct;
• proof by contradiction temporarily assumes a state specifically to prove that the state is impossible.

Direct proof and contradiction proof can describe the same logic

Some Sudoku deductions can be explained in more than one logically equivalent way.

A pattern may have:

• a direct counting proof;
• an implication proof;
• a contradiction proof.

For teaching, the best explanation is usually the one that exposes the reusable structure most clearly.

For example, X-Wing is normally easier to understand as Fish/base-cover logic than as a long hypothetical branch, even though alternative proofs may exist.

The goal is not to use the most dramatic proof. It is to use the clearest one.

A valid pattern is not always a useful move

A solver can identify a technically valid pattern that produces no eliminations.

For example:

• an X-Wing may exist but have no target candidates in its cover columns;
• a chain may be valid but end in a relationship that eliminates nothing;
• a Naked Pair may already have no extra pair digits elsewhere in the house.

Pattern recognition and useful deduction are therefore separate checks:

1. Does the structure satisfy the technique definition?
2. Does the structure produce a new placement or elimination?

That distinction prevents “pattern spotting” from replacing actual solving.

The dependency cascade

A Sudoku solve is not a flat sequence of isolated tricks.

One elimination can change candidate state elsewhere, which can reveal something much simpler.

For example:

Swordfish elimination
→ candidate removed
→ Hidden Single appears
→ placement made
→ Locked Candidates appears
→ two more candidates removed
→ Naked Single appears

The advanced pattern may be the breakthrough, but most of the resulting progress can return immediately to simpler logic.

That is why a strong solving strategy always re-scans after a meaningful elimination.

Correctness solvers and human-style solvers answer different questions

Software can solve Sudoku in several fundamentally different ways.

Complete solver / solution counter

Its job is to answer questions such as:

• Does a solution exist?
• How many solutions exist?
• What is the completed grid?

Search, exact cover, constraint propagation, and backtracking are useful here.

Human-style analyzer

Its job is different:

• Which explainable deduction is available?
• Which technique describes it?
• What candidate is eliminated?
• What difficulty should the step receive?
• What hint should a player see?

A complete solver can prove a puzzle correct without producing a human-like learning path.

A human-style solver can describe an elegant path without being the fastest possible way for a computer to find the answer.

Both are useful because they solve different product and mathematical problems.

Uniqueness is an additional premise

Most of the corpus relies only on the ordinary Sudoku constraints.

Uniqueness techniques add another premise:

this puzzle is verified to have exactly one solution.

That premise allows deductions such as Unique Rectangle and BUG+1.

It must remain explicit because a candidate can be locally compatible with every row/column/box rule yet still be forbidden if it would create another valid completion.

This is why Unique Solution and Unique Rectangle are linked but not the same topic:

• one explains the puzzle-level property;
• the other uses that property as a solving premise.

Logic does not require one universal technique order

Two competent solvers can make different next moves.

One may find:

• a Hidden Single;

while another first finds:

• a Locked Candidates elimination;

and a third notices:

• a subset that eventually leads to the same progress.

Sudoku logic often has multiple valid proof paths.

A human-style solver therefore needs both:

• correctness — every step is justified;
• policy — which valid step it prefers to present first.

That policy affects difficulty ratings, hints, and the apparent elegance of the solve path.

A compact logical-solving model

When you are unsure what “proof” you are looking for, reduce the situation to these questions:

1. What is currently possible? — candidates.
2. What is reserved? — Singles/subsets/Fish/position restrictions.
3. What cannot coexist? — Weak relationships.
4. What cannot both be false? — Strong relationships.
5. What follows if this state changes? — implications/chains.
6. Does an assumption create impossibility? — contradiction.
7. Am I using any extra premise? — uniqueness, variant constraints, etc.
8. What exact placement or elimination follows? — the useful move.

That framework scales from beginner reasoning to advanced Sudoku without changing the basic definition of proof.

FAQ

Is candidate elimination a real Sudoku move?

Yes. Removing a candidate is progress whenever the deduction proves that candidate impossible.

Are advanced techniques based on different Sudoku rules?

Usually no. Most are deeper consequences of the same row, column, and box constraints. Uniqueness techniques are a notable case because they explicitly use an additional unique-solution premise.

Is contradiction the same as guessing?

No. A contradiction proof assumes a state in order to prove that it is impossible. Random guessing chooses a state without proof and continues as though it were correct.

Why can two solvers find different next moves?

Several valid deductions can exist at the same time, and solvers use different search priorities and technique libraries.

Does every valid pattern produce an elimination?

No. A structure can satisfy the pattern definition but have no useful target in the current grid.

Is Sudoku logic just elimination?

No. Sudoku reasoning includes placements, eliminations, reservations, implications, and contradiction. Eliminations become increasingly important as puzzle difficulty rises.

Is using a computer solver still “logic”?

It depends on the solver. A complete search solver can find answers without producing human-style deductions. A human-style analyzer is deliberately designed to output explainable logical steps.

What to learn next

Read Sudoku Chains to turn implication language into concrete chain deductions, Do You Have to Guess in Sudoku? for the boundary between proof and search, and Sudoku and Mathematics for the algorithmic view of the puzzle.