BUG+1 is a Sudoku uniqueness technique used in a very specific late-game candidate state.
BUG stands for Bivalue Universal Grave.
A pure BUG has two defining properties:
- every unsolved cell has exactly two candidates;
- every remaining candidate digit appears exactly twice in every row, column and box in which it is unresolved.
That perfectly balanced state is deadly for a puzzle that is supposed to have one solution: the remaining candidate assignments can be exchanged to produce another valid completion.
A properly constructed unique Sudoku therefore cannot end in a pure BUG.
BUG+1 is the useful near-state:
- every unsolved cell is bivalue except one;
- that one cell has three candidates;
- one of those three candidates is the extra value preventing the grid from collapsing into the BUG pattern.
That extra candidate must be true.
In a verified BUG+1, place the extra candidate in the lone trivalue cell.
The word verified matters. A grid is not automatically BUG+1 merely because only one cell has three candidates.
What is a Bivalue Universal Grave?
A bivalue cell contains exactly two candidates.
If every unsolved cell in the whole grid is bivalue, that is not yet enough to prove a BUG.
You must also verify the candidate-frequency condition:
each unresolved digit appears exactly twice in every row, column and box where that digit is still present.
This creates a globally balanced network of candidate pairs.
In a pure BUG, the remaining assignments can be flipped through that network to produce another completion.
That conflicts with the uniqueness assumption of a standard well-formed puzzle.
Why BUG+1 forces one candidate
Suppose every unsolved cell is bivalue except one cell:
r5c6 = {2, 7, 9}Call it the +1 cell.
Two of its candidates fit the balanced BUG structure.
The third is the extra candidate.
If that extra candidate were removed, the whole remaining grid would become a pure BUG.
A pure BUG would permit multiple completions.
But the puzzle is assumed to have exactly one solution.
Therefore the extra candidate cannot be removed.
It must be the solution of the +1 cell.
The parity clue
In a standard BUG+1, the extra candidate often reveals itself because it appears an odd number of times — usually three — in the +1 cell's row, column and box, while the other candidates preserve the exactly-twice balance.
This makes candidate counting a practical detection tool.
However, do not reduce the technique to:
“find the digit that appears three times in one box.”
The full-grid BUG conditions still matter.
You must verify that the rest of the unsolved grid is actually in the required bivalue/even-balance structure.
Step-by-step BUG+1 example
How to identify the +1 candidate
When the grid looks close to a BUG:
1. Confirm every other unsolved cell is bivalue
There should be exactly one non-bivalue unsolved cell.
For the standard BUG+1 pattern, that cell normally has three candidates.
2. Inspect the three candidates in the +1 cell
For each digit, count its unresolved appearances in:
- the row;
- the column;
- the box.
3. Find the candidate that breaks the even balance
The extra candidate is the one whose presence keeps the grid from satisfying the pure BUG condition.
Frequently it appears three times in each of the three houses containing the +1 cell, while the other two candidates appear twice.
4. Verify the rest of the grid
Check that every other unresolved candidate participates in the required twice-per-house structure.
5. Place the extra candidate
Once the BUG+1 state is verified, the extra candidate is forced.
BUG+1 is a whole-grid technique
This is one of the easiest details to miss.
A Unique Rectangle is local: four cells form the dangerous structure.
BUG+1 is universal.
The relevant pattern covers the entire remaining unsolved candidate network.
That is why a small cluster of bivalue cells plus one trivalue cell is not enough.
You must inspect the whole unresolved grid.
Why “all cells but one are bivalue” is not sufficient
Consider a grid where:
- every unsolved cell except one has two candidates;
- one cell has three candidates.
It still may not be BUG+1.
For example, one candidate digit might appear:
- three times in a row unrelated to the +1 balance;
- four times in a column;
- or otherwise fail the exactly-twice structure.
Then removing one candidate from the trivalue cell would not create a pure BUG.
The uniqueness proof does not follow.
So the safe rule is:
bivalue everywhere + one trivalue cell is a recognition cue, not the complete proof.
BUG+1 and uniqueness
BUG+1 relies on the same broad premise as Unique Rectangle:
the puzzle is known to have one solution.
This premise is not one of the local row/column/box rules.
It is a property of the puzzle construction.
If you apply BUG+1 to a grid that genuinely has multiple solutions, the uniqueness argument is not valid.
For that reason, some solvers prefer not to use uniqueness techniques at all.
That is a legitimate solving-style choice.
VeyraPlay treats BUG+1 as an optional expert uniqueness technique and states the assumption explicitly.
BUG+1 vs Unique Rectangle
Both prevent a candidate structure that would permit multiple solutions.
Unique Rectangle
- local four-cell geometry;
- two rows, two columns and exactly two boxes;
- usually based on two deadly rectangle digits.
BUG+1
- global remaining-grid structure;
- almost every unsolved cell is bivalue;
- candidate frequencies across every unresolved house matter.
BUG+1 can be thought of as a more universal deadly-pattern argument.
BUG+1 vs a Naked Single
Once BUG+1 is recognized, placing the extra digit may leave the +1 cell effectively solved.
But the proof is not a Naked Single.
A Naked Single has only one legal candidate before the deduction.
A BUG+1 cell can still display three legal candidates under ordinary row/column/box constraints.
The uniqueness structure is what proves which candidate must be true.
BUG+1 vs XY-Chain
A BUG+1 state contains a large network of bivalue relationships.
That network often supports other chain-based deductions, including XY-Chain-style reasoning.
So the same forced result may sometimes be obtainable without explicitly using the uniqueness premise.
BUG+1 remains useful because, when the pattern is obvious, it compresses a potentially long chain argument into one recognizable whole-grid structure.
Is a pure BUG ever a valid solving state?
Not in a puzzle that is known to have exactly one solution.
A verified pure BUG means the remaining grid has multiple valid completions.
If you encounter one while solving a supposedly unique puzzle, possible explanations include:
- the puzzle was not uniquely constructed;
- a previous candidate elimination or placement was wrong;
- the candidate lists are incomplete or inaccurate.
Treat a pure BUG as a diagnostic warning, not as a normal endpoint.
How to find BUG+1 efficiently
BUG+1 is not something to search for early.
It is a late-stage recognition pattern.
1. Wait until the unsolved grid is mostly bivalue
If many cells still have four or five candidates, BUG+1 is not a sensible target.
2. Notice a lone trivalue cell
A grid where every other unsolved cell is bivalue should immediately trigger the BUG+1 check.
3. Count candidate occurrences
Start with the three candidates in the trivalue cell.
Check their frequencies through its row, column and box.
4. Verify globally
Do not stop after one house.
Confirm the universal BUG balance across the remaining grid.
5. Prefer easier deductions if available
Even if BUG+1 exists, a Single or simpler chain may also solve the position.
Use the clearest proof for the context.
Common BUG+1 mistakes
Mistake 1: checking only one box
BUG means Universal Grave.
The structure concerns the entire unresolved grid.
Mistake 2: assuming one trivalue cell is enough
It is necessary for the standard BUG+1 pattern, but not sufficient.
The twice-per-house candidate condition must also hold.
Mistake 3: choosing any candidate that appears three times somewhere
The extra candidate must be the one whose removal would complete the full BUG structure.
Mistake 4: using BUG+1 without a uniqueness assumption
The proof depends on rejecting a multi-solution state.
Mistake 5: confusing BUG+1 with an ordinary parity trick
Candidate counts help reveal the pattern, but the reason the move is valid is the uniqueness contradiction created by a pure BUG.
Mistake 6: forgetting to update candidates before checking
BUG+1 is extremely sensitive to candidate accuracy.
One stale candidate can create a false pattern.
When should you use BUG+1?
BUG+1 is most useful:
- late in a difficult solve;
- when nearly every remaining cell is bivalue;
- when one cell has exactly three candidates;
- when you are comfortable using uniqueness-based logic.
It is not part of the normal beginner/intermediate search order.
FAQ
What does BUG stand for in Sudoku?
BUG stands for Bivalue Universal Grave: a deadly remaining-grid state in which every unsolved cell is bivalue and every unresolved candidate occurs exactly twice per house.
What does the “+1” mean in BUG+1?
It means the grid is one candidate away from the pure BUG structure. One cell contains an extra candidate that prevents the deadly balanced state.
Does the BUG+1 cell always have three candidates?
The standard BUG+1 pattern is recognized as one trivalue cell among otherwise bivalue unsolved cells. More complicated BUG+n extensions exist, but they are outside the scope of this core Guide.
How do I know which candidate is the extra one?
It is the candidate whose removal would restore the pure BUG balance. In common examples it is the candidate that appears three times rather than twice in the row, column and box containing the +1 cell.
Does BUG+1 require a unique Sudoku?
Yes. It is a uniqueness technique. If the puzzle is not known to have one solution, the deduction is unsafe.
Can BUG+1 be solved another way?
Often yes. The dense bivalue network may support XY-Chains or other deductions. BUG+1 is valuable because it recognizes the whole-grid uniqueness structure directly.
What to learn next
BUG+1 completes the first VeyraPlay uniqueness layer after Unique Rectangle. Later expansion can go deeper into Unique Rectangle Types 2–6, Hidden Rectangle and Avoidable Rectangle.