How Sudoku Difficulty Is Rated

Sudoku difficulty looks simple on the surface.

A publisher might label puzzles:

Easy
Medium
Hard
Expert

But there is no universal formula that turns a grid into one official difficulty label.

Two rating systems can disagree without either being mathematically broken, because they may model different things:

• different solving techniques;
• different technique weights;
• different search priorities;
• different ideas of human effort;
• different player populations.

A useful Sudoku difficulty rating is therefore not merely a property of the starting clue count.

It is a model of the work a solver is expected to perform.

Difficulty is not just clue count

The number of givens is easy to measure, so it is tempting to use it as a shortcut:

fewer clues = harder puzzle.

That is not reliable.

Clue count tells us how much information is explicitly visible at the start.

It does not directly tell us:

• which deductions are available;
• how difficult those deductions are to recognize;
• whether one advanced step is required;
• how many non-trivial steps occur;
• how deeply later deductions depend on earlier ones.

A sparse puzzle can collapse through Singles.

A puzzle with more clues can contain a difficult logical bottleneck.

Clue count is therefore useful metadata, but not a sufficient difficulty metric.

Difficulty starts with a solving model

Before a system can rate logical difficulty, it needs to define what counts as a supported human-style deduction.

A solver might know:

Singles
Locked Candidates
Pairs and Triples
X-Wing
Wings
Coloring
Chains
...

Another solver might support a different set or order them differently.

That matters because a puzzle's apparent difficulty depends on the tools the model is allowed to use.

A rating should therefore answer an implicit question:

How difficult is this puzzle under this solving model?

not:

What is the one objectively correct difficulty number for all humans?

Human-style solving paths are more informative

Once a technique model exists, an analyzer can produce a logical solve path.

For example:

Hidden Single
Hidden Single
Locked Candidates
Naked Pair
Hidden Single
X-Wing
Naked Single
...

Now we have something much richer than clue count.

The path allows a rating system to inspect:

• hardest required technique;
• number of uses of each technique;
• total path length;
• dependencies between steps;
• number of difficult bottlenecks;
• how many alternative productive moves exist;
• how visually demanding candidate states become.

Research on human Sudoku solving has found that two broad sources are especially important: the complexity of individual logical steps and the dependency structure connecting those steps.

That gives us a useful foundation for thinking about difficulty.

Factor 1 — Hardest required technique

One of the clearest rating features is:

What is the most advanced technique the selected solve path actually requires?

A simple conceptual ladder might look like:

Singles
↓
Locked Candidates / Subsets
↓
Fish / Wings
↓
Coloring / Chains
↓
selected expert methods

The exact categories are not universal.

But the principle is intuitive: if a puzzle cannot be completed without a technique that the target audience considers advanced, that strongly affects the puzzle's rating.

The hardest technique is useful, but not enough

Imagine two puzzles that both require one X-Wing.

Puzzle A

The X-Wing appears after a short sequence of obvious Singles. Once it is used, the puzzle collapses quickly.

Puzzle B

The X-Wing appears only after many candidate eliminations, sits inside a dense board state, and is followed by several other non-trivial deductions.

If a rating uses only:

hardest technique = X-Wing

both puzzles may receive the same score.

A human may experience them very differently.

Factor 2 — Total solving work

A rating can therefore count more than the single hardest step.

Possible workload features include:

• total deduction count;
• number of eliminations;
• number of placements;
• count of non-trivial techniques;
• accumulated technique weights;
• repeated use of the same advanced technique;
• length of the candidate-maintenance process.

This captures the difference between:

one hard moment in an otherwise easy puzzle

and

sustained difficult work across the whole solve.

Factor 3 — Dependency between steps

Two puzzles can use the same techniques the same number of times and still differ in difficulty.

The reason is dependency.

Suppose an advanced deduction becomes available only after several earlier deductions have been made in a specific sequence.

That creates a deeper dependency chain than a puzzle where the same advanced pattern is visible immediately.

A conceptual dependency structure might look like:

Single A
   ↓
Locked Candidate
   ↓
Pair elimination
   ↓
X-Wing
   ↓
new Single

The X-Wing is not difficult only because of what it is.

It is also buried behind previous progress.

Bottlenecks matter

A useful way to think about dependency is the bottleneck.

At some board states there may be many easy productive moves.

At others, almost everything is exhausted and one specific deduction is needed to continue.

A narrow bottleneck tends to increase human difficulty because the solver has fewer obvious directions to explore.

This can matter even when the required technique itself is not extremely advanced.

Factor 4 — Recognition burden

Logical proof and visual recognition are related but not identical.

Two valid X-Wings may have the same formal proof.

One may be obvious because:

• the Fish digit has few candidates;
• the relevant rows are sparse;
• the target candidates stand out.

Another may be buried in dense notation.

The second one can take much longer to find even though the underlying deduction belongs to the same named technique.

Difficulty models that try to approximate humans may therefore consider features related to candidate density, clutter, or pattern visibility.

Factor 5 — Which move the analyzer chooses

A board can contain multiple valid deductions simultaneously.

Suppose both are available:

• a Hidden Single;
• an X-Wing.

If the analyzer chooses the X-Wing first, a naive rating may conclude that the puzzle requires X-Wing.

But if the Hidden Single changes the board and removes the need for that Fish, the advanced step was never required.

That is why the solver's step-selection policy affects difficulty.

A common stable policy is:

Use the simplest productive supported deduction first.

This does not claim that every human searches in exactly that order.

It gives the rating system a repeatable baseline.

Required techniques vs merely visible techniques

This distinction deserves special attention.

A technique can be:

• visible in a board state;
• productive because it makes an elimination;
• required because no easier supported path can avoid needing comparable logic.

Difficulty should be based much more strongly on what the chosen solution model genuinely needs than on every advanced pattern that happens to exist somewhere in the puzzle.

Otherwise a puzzle can be overrated simply because the analyzer noticed a sophisticated but unnecessary pattern.

Factor 6 — Number of productive options

Another human-facing feature is how many reasonable moves are available.

Compare:

Open board state

Several Singles and Locked Candidates are available in different parts of the grid.

Narrow board state

Only one productive candidate pattern moves the puzzle forward.

The second position can feel much harder because the solver has to discover a much smaller target.

A mature rating model may therefore consider features such as:

• number of currently available simple moves;
• number of productive units or digits;
• time spent between breakthroughs;
• branching among reasonable human search choices.

These are refinements rather than requirements for a first rating system, but they help explain why technique labels alone are incomplete.

From features to a score

Once the analyzer has a solve path, a rating model can combine features into a score.

A conceptual feature record might look like:

hardest_technique: x-wing
total_steps: 51
nontrivial_steps: 8
advanced_steps: 1
max_dependency_depth: 5
candidate_density_peak: high

A simple model might map the hardest technique to a base score and add workload penalties.

A more sophisticated model might learn weights from real human solve times or success rates.

Neither approach creates a universal truth. It creates a consistent rating system whose behavior can be tested and calibrated.

From a continuous score to labels

Player-facing labels are usually buckets over a more detailed score or rule set.

For example:

score range A → Easy
score range B → Medium
score range C → Hard
score range D → Expert

Another system may use:

Easy
Medium
Hard
Unfair
Extreme

HoDoKu, for example, uses configurable technique levels and scores and explicitly notes that its system is not an absolute universal measure of Sudoku difficulty.

The label names matter less than internal consistency.

Why two Sudoku apps can disagree

Two products can rate the same puzzle differently because they may differ in:

• supported techniques;
• technique hierarchy;
• technique weights;
• step-selection order;
• whether unnecessary advanced steps are ignored;
• dependency scoring;
• thresholds between labels;
• calibration population.

So:

Site A: Medium
Site B: Hard

does not automatically indicate a bug.

It indicates that difficulty labels are model-dependent.

Human data can calibrate the model

A rating system can be compared against real solving behavior.

Useful aggregate signals include:

• completion rate;
• solve time;
• hint usage;
• error rate;
• abandonment rate;
• performance after controlling for player skill.

If puzzles predicted as Medium consistently behave like Hard puzzles for the intended audience, the model can be recalibrated.

Human data is especially useful for tuning thresholds and weights.

It should not replace logical validation: the puzzle still needs to be valid, unique when required, and correctly analyzed.

Player skill must be separated from puzzle difficulty

Raw solve time alone is noisy.

A 20-minute solve can mean very different things for:

• a beginner;
• an experienced daily player;
• an expert chain solver.

A good empirical difficulty model therefore benefits from accounting for solver ability rather than mixing every player into one undifferentiated average.

The goal is to estimate something closer to:

How much difficulty does this puzzle add for players of comparable skill?

Puzzle difficulty and personal difficulty are different

A catalog rating describes the puzzle relative to a chosen model or population.

A particular player may experience it differently.

Someone who has just learned X-Wing may find one puzzle extremely difficult. A player who recognizes Fish immediately may find the same puzzle routine.

That is not a contradiction.

Difficulty labels are guidance, not universal facts about every human solver.

Technique difficulty and recognition difficulty are different

The same formal technique can appear in easier or harder contexts.

A clean teaching example might:

• highlight the target digit;
• show only relevant candidates;
• isolate the important houses.

A real puzzle may present the same logic among dozens of distracting candidates.

The deduction has not changed, but the recognition burden has.

This distinction matters both for puzzle rating and for designing exercises.

Difficulty can change when the solver changes

A rating is partly a property of the rating engine.

If a new version adds:

• a previously unsupported technique;
• a better search order;
• a new dependency metric;
• revised technique weights;

then the same puzzle may receive a different rating.

That is why robust systems benefit from versioning their rating model and keeping the puzzle identity separate from its current computed score.

A practical rating architecture

A transparent Sudoku rating pipeline can be organized as:

validate puzzle
↓
solve with human-style analyzer
↓
record logical path
↓
extract difficulty features
↓
calculate score
↓
map score to player-facing label
↓
calibrate against human data

Each stage answers a different question.

That separation makes the final difficulty label easier to explain, test, and improve.

FAQ

Is there an official Sudoku difficulty scale?

No. Easy, Medium, Hard, Expert, and similar labels are defined by publishers, apps, or rating systems rather than by one universal standard.

Does fewer clues mean a harder Sudoku?

Not reliably. Clue count can influence the starting information, but the logical solve path is much more informative.

Is the hardest required technique enough to rate a puzzle?

It is a strong feature, but total work, dependency depth, recognition burden, and bottlenecks can make two puzzles with the same hardest technique feel very different.

Why can another app call my Hard puzzle Medium?

Its solver may support different techniques, choose steps in a different order, use different weights, or place its label thresholds elsewhere.

Can player data improve Sudoku ratings?

Yes. Solve times, completion rates, hints, errors, and abandonment can help calibrate a model when player skill is taken into account.

Can the same technique appear in puzzles of different difficulty?

Yes. The same technique may be obvious in one puzzle and deeply buried in another, and the rest of each solve path may differ substantially.

Can a difficulty rating change later?

Yes. If the analyzer or rating model changes, the computed rating can change even though the puzzle itself has not.

Is brute-force search a difficulty level?

Not in a human-style logical scale by default. A complete search solver answers whether a solution exists; a human-style rating model asks what logical work a person is expected to perform. A product can choose how to label puzzles outside its supported technique set.

What to learn next

Read [Sudoku Difficulty Levels](/guides/sudoku/difficulty-levels/) for the player-facing meaning of Easy, Medium, Hard, and Expert, or [How Sudoku Puzzles Are Generated](/guides/sudoku/theory/how-sudoku-is-generated/) to see where rating fits inside a complete generation pipeline.