BUG Type 1 (also called BUG+1) is an advanced "uniqueness" strategy that detects when the puzzle is about to enter an impossible state. Unlike logic-based strategies that prove what must be true, BUG uses the fundamental Sudoku rule that every valid puzzle has exactly one unique solution.
This strategy is surprisingly powerful once you understand it—and it can instantly solve a cell that would otherwise require complex chains!
Interactive Example
Click "Apply Logic" to see the strategy in action.
Real Example Walkthrough
In the example puzzle above, the solver identifies a BUG+1 state:
The Grid State: - Almost every unsolved cell has exactly 2 candidates - One cell (R8C4) has 3 candidates: {4, 6, 9}
The Analysis:
- Count candidate appearances: In R8C4's row, column, and box:
- Candidates 4 and 6 each appear exactly 2 times in their respective regions
-
Candidate 9 appears 3 times in at least one region (this is the "extra")
-
Apply BUG logic: If R8C4 were 4 or 6, the grid would become a BUG (all cells bivalue, all candidates appearing exactly twice)—meaning two valid solutions!
-
Eliminate: R8C4 must be 9 to avoid the deadly BUG state. Remove 4 and 6.
Result: R8C4 = 9, instantly solving this cell!
What Is a BUG (Bivalue Universal Grave)?
A BUG (Bivalue Universal Grave) is a grid state where:
- Every unsolved cell has exactly 2 candidates
- Every candidate appears exactly 2 times in each row, column, and box it belongs to
This creates a deadly pattern—you could swap candidates throughout the grid and both arrangements would be valid. Since a proper Sudoku cannot have two solutions, this state is impossible.
Why "Bivalue Universal Grave"?
| Term | Meaning |
|---|---|
| Bivalue | Each cell has exactly 2 candidates |
| Universal | This applies to ALL unsolved cells |
| Grave | The puzzle is "dead"—it has no unique solution |
BUG Type 1: The "+1" Rule
BUG Type 1 (BUG+1) applies when:
- All unsolved cells have exactly 2 candidates except one
- That one cell has exactly 3 candidates
- One of those 3 candidates is the "extra"—it appears 3 times (not 2) in its row, column, or box
The Logic
The grid is almost a BUG. Only the "+1" cell (with 3 candidates) prevents the deadly pattern.
- If the +1 cell becomes any of its 2 "normal" candidates, the grid becomes a BUG → impossible
- Therefore, the +1 cell must be the extra candidate
- We can eliminate the other candidates from this cell
How to Identify the Extra Candidate
The extra candidate is the one that appears an odd number of times (usually 3) in the cell's row, column, or box, while the others appear exactly twice.
Example from our puzzle:
| Candidate | Appearances in Row 8 | Appearances in Column 4 | Extra? |
|---|---|---|---|
| 4 | 2 | 2 | No |
| 6 | 2 | 2 | No |
| 9 | 3 | 2 | Yes! |
Since 9 appears 3 times in Row 8, it's the extra candidate. R8C4 must be 9.
Step-by-Step: How to Spot BUG+1
- Check cell candidate counts: Are almost all unsolved cells bivalue (2 candidates)?
- Find the outlier: Is there exactly ONE cell with 3 candidates?
- Count appearances: For each candidate in that cell, count how many times it appears in its row, column, and box
- Identify the extra: Which candidate appears an odd number of times (not 2)?
- Solve the cell: The cell must be the extra candidate; eliminate the others
Visual Recognition
BUG+1 has a distinctive "feel" when you're solving:
- The puzzle is nearly finished
- Most remaining cells show only 2 candidates each
- One cell stubbornly has 3 candidates
- You can't seem to reduce it with normal techniques
When you see this pattern, check for BUG+1!
Common Misconceptions
"BUG requires ALL cells to be bivalue"
Incorrect. BUG+1 specifically handles the case where ONE cell has 3 candidates. That's the "+1" in the name!
"I need to count all 81 cells"
No. Only check the unsolved cells. Filled cells don't participate in BUG analysis.
"The extra candidate appears 3 times everywhere"
Not necessarily. It only needs to appear an odd number of times in at least one region (row, column, or box). Other regions may have 2.
Why This Strategy Works
The uniqueness principle guarantees that a valid Sudoku has one and only one solution.
If a BUG state could exist: - Every bivalue cell could swap its two candidates - The entire grid could be "flipped" to create another valid solution - This violates the single-solution rule
By detecting the "+1" cell that prevents the BUG, we know its extra candidate must be the answer—otherwise, eliminating it would create the impossible BUG state.
Comparison with Related Strategies
| Strategy | Pattern | Cell Count | Action |
|---|---|---|---|
| BUG Type 1 | Almost BUG + 1 cell with 3 candidates | 1 | Solve the +1 cell |
| BUG Type 2 | Almost BUG + multiple cells share same extra | 2+ | Eliminate extra from common peers |
| BUG Type 3 | Almost BUG + extras form naked subset | 2+ | Eliminate via naked subset |
| BUG Type 4 | Almost BUG + one value locked | 2 | Eliminate the locked value |
BUG vs Unique Rectangle
| Feature | BUG | Unique Rectangle |
|---|---|---|
| Scope | Entire grid | 4 cells only |
| Cell state | All cells bivalue | Specific rectangle pattern |
| Candidate count | 2 per cell, 2 per region | Same pair in 4 corners |
| Complexity | Easier to spot late-game | Can appear mid-game |
Tips for Beginners
- Look late in the solve: BUG+1 typically appears when few cells remain
- Use candidate notation: Mark all candidates—bivalue cells will be obvious
- Trust the pattern: If you find a valid BUG+1, the elimination is guaranteed correct
- Don't overthink: One cell with 3 candidates + all others with 2 = check for BUG!
- Practice counting: The extra candidate count becomes automatic with practice
When BUG+1 Doesn't Apply
- Multiple cells with 3+ candidates: Try BUG Type 2, Type 3, or Type 4
- Some cells have 4+ candidates: The grid isn't close enough to BUG state
- Candidate counts are all even: No extra exists; pattern doesn't apply
Related Strategies
BUG Family
- BUG Type 2 — Multiple BUG cells share the same extra candidate
- BUG Type 3 — BUG cells' extras form a Naked Subset
- BUG Type 4 — One value is locked to BUG cells
Unique Rectangle Family
- Unique Rectangle (Type 1) — 4-cell deadly pattern avoidance
- Unique Rectangle (Type 2) — Shared extra in roof cells
- Unique Rectangle (Type 3) — Extras form Naked Subset
- Unique Rectangle (Type 4) — Locked value in rectangle
Unique Loop Family
- Unique Loop Type 1 — Extended deadly pattern with 6+ cells