What is BUG+1
BUG stands for Binary Universal Grave: a situation where every unsolved cell in the grid is bivalue (exactly two candidates). A pure BUG state is dangerous because it typically leads to ambiguous or invalid solutions if not handled correctly. BUG+1 is a common and useful refinement: you have a BUG pattern everywhere except for one cell, the exception, which has three or more candidates. That single extra candidate often reveals a forced elimination.
Why BUG+1 matters
When you reach a near-finished grid with many bivalue cells, ordinary techniques (singles, pairs, X-wings, etc.) may stop working. BUG+1 gives you a logical elimination without guessing: some candidates in the exception cell would convert the grid into a pure BUG and therefore must be false. Removing those candidates can unblock the puzzle and lead to concrete placements.
When to look for BUG+1
- At the late stage of solving, when most remaining cells are bivalue. If all unsolved cells except one are bi-valued, check for BUG+1.
- After performing all normal reductions (singles, naked/hidden pairs, basic fish). BUG+1 is a pattern-recognition step, not a routine scan.
- When you have a single cell with 3+ candidates and many other empty cells with exactly two candidates. That single cell is the “+1” part of BUG+1.
How BUG+1 eliminates candidates
The logic is simple: assume one candidate in the exception cell is true. If that candidate forces every other unsolved cell to become bivalue and those bivalue cells form a pure BUG (i.e., they leave an unavoidable parity conflict or multiple solutions), then that candidate is impossible. In practice you check each candidate of the exception cell: if placing it produces a pure BUG state (or immediately yields an unavoidable contradiction), you can eliminate that candidate from the exception cell.
Important note: You are not placing a candidate permanently during this test. You only check whether admitting that candidate would produce the pure BUG pattern; if it does, you remove it. The candidate(s) that remain after all eliminations are the only ones that avoid the BUG contradiction.
Step-by-step detection and use
1. Identify the pattern: confirm every unsolved cell except one is bivalue.
2. Locate the exception cell (the only cell with 3+ candidates).
3. For each candidate in the exception cell, imagine (or pencil) that candidate is fixed and see whether the rest of the unsolved cells become exactly bivalue and form a BUG. Often checking is local: if adopting a candidate causes an immediate bivalue in neighboring cells and no further eliminations break the pure BUG, then it is the kind of candidate you can reject.
4. Eliminate any candidate that would create the pure BUG.
5. After eliminations, continue with standard solving; you should now get singles or new reductions.
Practical tips
- Work carefully with candidates: BUG+1 depends on the candidate lists being complete and accurate. Make sure you've updated candidates after each placement.
- Don’t confuse BUG+1 with uniqueness reasoning. BUG+1 uses the structure of bivalue cells, not the assumption that a puzzle must have a single solution.
- Use pencil marks or a temporary mark if that helps: you’re testing consequences, not committing guesses.
- It is common that more than one candidate in the exception is eliminable, sometimes leaving a single candidate to place and finish the puzzle.
Example
Below is a compact candidate-grid example illustrating a BUG+1 situation. All highlighted empty cells except the focus cell are bivalue (two candidates). The focus cell (the exception) has three candidates. The two-valued cells form the BUG structure; two of the three candidates in the focus cell would convert the grid to a pure BUG if they were accepted, so those candidates can be eliminated.
After you eliminate the candidates that lead to a pure BUG, the remaining candidate(s) in the focus cell should allow standard solving to continue.
Closing advice
BUG+1 is a late-stage, high-value technique: it is not needed for early solving but can save you from guessing when the grid becomes highly reduced. Train yourself to spot grids dominated by bivalue cells and check for a single multi-value exception. With practice, BUG+1 becomes one of the most efficient ways to turn a near-complete candidate grid into a solvable position without trial-and-error.