BUG (Bivalue Universal Grave)

A BUG (Bivalue Universal Grave) is the puzzle's terminal "deadly" state: every unsolved cell is bi-value and every digit appears exactly twice in every unit it still touches. A valid Sudoku can never actually reach that state — it has multiple solutions. So when you spot a near-BUG, you can use it: the candidate(s) that prevent the grid from collapsing into the deadly pattern are forced. The two practical variants are BUG+1 (one cell off the BUG-base) and BUG+2 (two cells off).

The Deadly Pattern

Imagine a puzzle where every unsolved cell has exactly two candidates, and each candidate appears exactly twice in every row, column, and box it touches. This creates a "switching" pattern:

puzzle: S9B0107040803020509060509030406010207080608020905070U0U01440607050L4A090P0U440109074A03060S050403050L0906080L07030S0106444A070509090S080L07050N060U070506030R090R0802
mode: static
settings:
  showCandidates: true
  coordinateFormat: none
initial:
  annotations:
    - cells: [R4C8]
      label: "BUG+1"
      style: deadly

In this state, you could swap any candidate with its partner throughout the grid and still have a valid solution — meaning multiple solutions exist. This is the "graveyard" — a dead puzzle.

Why It's Deadly

For a BUG pattern to exist:

This creates perfect symmetry — flip any pair, and everything still works. But valid Sudoku puzzles have exactly one solution, so this pattern cannot occur.

BUG+1: One Cell Off

The simplest "near-BUG" pattern: exactly one unsolved cell has three candidates, every other unsolved cell is bi-value. That one cell is the "+1" — it carries the candidate that must be placed to prevent the graveyard.

puzzle: S9B0107040803020509060509030406010207080608020905070U0U01440607050L4A090P0U440109074A03060S050403050L0906080L07030S0106444A070509090S080L07050N060U070506030R090R0802
mode: static
settings:
  showCandidates: true
  coordinateFormat: none
initial:
  selection:
    cells: [R4C8]
  annotations:
    - cells: [R4C8]
      label: "Tri-value"
      style: pattern

The Logic

  1. All unsolved cells except one have exactly 2 candidates.
  2. The exception has 3 candidates (the "BUG+1 cell").
  3. If we removed one specific candidate from it, the grid would be a deadly BUG.
  4. Therefore that candidate must be the solution — anything else dooms the puzzle.

How to Spot It

  1. Count candidates per cell. Most unsolved cells should already be bi-value. Stop here if more than one cell has 3+ candidates.
  2. Check the digit counts. For every digit, in every row/column/box, count how many unsolved cells still hold it as a candidate. In a true BUG+1 state the count is 0 or 2 everywhere — except in the three units that contain the tri-value cell, where exactly one of its candidates appears 3 times.
  3. Pick the lone "3" candidate. That digit is the BUG breaker — place it in the tri-value cell.

If you find another row/column/box where a digit appears 3 times that doesn't go through your tri-value cell, the pattern is not a real BUG+1; the technique can't apply, and trying it will give a wrong answer.

BUG+2: Two Cells Off

Exactly two unsolved cells have three candidates each; every other unsolved cell is bi-value. Now there are two extras instead of one — and you'll get an elimination, not a placement.

The two tri-value cells are interchangeable for the rest of this section: there's no special "A" and "B". The labels exist only so we can refer to one or the other in a single sentence. Call them T₁ and T₂, in either order.

Step 1 — Verify the BUG-base

For every digit, in every row, column, and box, count how many unsolved cells hold it as a candidate (a solved cell contributes nothing). Treat T₁ and T₂ as ordinary cells while counting — they each contribute 1 to each of their three candidates.

You're looking for the following invariant:

If any unit outside this picture has a digit at count 4+, 5+, or otherwise breaks the rule, the pattern is not a BUG+2 and the technique doesn't apply.

Step 2 — Identify each cell's extra

Each tri-value cell has exactly one "extra" candidate — the one that, if you mentally removed it from that cell, would let the bi-value count rule hold in the cell's units.

For each tri-value cell T in turn:

In the unit that contains both T₁ and T₂ (if there is one), do the counting with both cells' contributions: each of T₁'s and T₂'s candidates is in there, and the over-count contributions reveal which candidate belongs to which cell.

By the end of Step 2 you have two specific digits: T₁'s extra (call it x₁) and T₂'s extra (call it x₂).

Step 3 — Apply the elimination

This is the core BUG+2 rule.

If T₁ and T₂ share a unit (row, column, or box), and x₁ ≠ x₂, then:

  • Eliminate x₂ from T₁ (only if x₂ is currently a candidate of T₁).
  • Eliminate x₁ from T₂ (only if x₁ is currently a candidate of T₂).

The elimination targets are the tri-value cells themselves, with each cell losing the other cell's extra. Always work the elimination "across": T₁ loses T₂'s extra; T₂ loses T₁'s extra.

Why: the BUG+2 logic says "T₁ takes x₁ as its placement, OR T₂ takes x₂ as its placement" (otherwise the deadly BUG appears). If both cells also shared the same digit d in a unit, you could have T₁ = d and T₂ = d at the same time — but that's two of d in one unit, illegal. The only consistent picture is that whichever cell doesn't take its own extra cannot take the other's either.

When the cells don't see each other

If T₁ and T₂ are in different rows, different columns, and different boxes, there's no direct elimination. You still have the strong link "T₁ = x₁ or T₂ = x₂", which can be fed into AICs, Forcing Chains, or Simple Colouring — but BUG+2 alone doesn't give you a move.

Worked sketch

Say T₁ = R7C2 with candidates {3, 7, 8} and T₂ = R8C3 with candidates {6, 7, 8}. They share box 7 (R7-9, C1-3).

  1. After counting, you find R7C2's extra is 7 (count of 7 in R7C2's units is 3) and R8C3's extra is 8 (count of 8 in R8C3's units is 3). So x₁ = 7, x₂ = 8.
  2. Apply: eliminate x₂ = 8 from T₁, so R7C2 ≠ 8 → R7C2 is now bi-value {3, 7}. Eliminate x₁ = 7 from T₂, so R8C3 ≠ 7 → R8C3 is now bi-value {6, 8}.
  3. The strong link "R7C2 = 7 OR R8C3 = 8" remains in force as a chain hook.

Example (BUG+1)

puzzle: S9B0107040803020509060509030406010207080608020905070U0U01440607050L4A090P0U440109074A03060S050403050L0906080L07030S0106444A070509090S080L07050N060U070506030R090R0802
mode: guided
settings:
  showCandidates: true
  showControls: true
  showDescription: true
  navigation: numbered
  coordinateFormat: rncn
steps:
  - text: >
      Scan the grid for candidate counts. Notice that almost every unsolved
      cell has exactly two candidates — this is the signature of a BUG pattern.
    technique: BUG
    hint: subtle
    state:
      selection:
        cells: [R1C5, R2C4, R3C6, R4C2, R5C3, R6C7, R7C8, R8C9]
  - text: >
      Find the exception. R4C8 has three candidates {1, 2, 3} — this is the
      BUG+1 cell. All other unsolved cells have exactly two candidates.
    technique: BUG
    hint: obvious
    state:
      selection:
        cells: [R4C8]
      annotations:
        - cells: [R4C8]
          label: "BUG+1"
          style: pattern
  - text: >
      Count occurrences in Row 4. Candidate 1 appears twice (R4C2, R4C8).
      Candidate 3 appears twice (R4C5, R4C8). But candidate 2 appears
      THREE times (R4C2, R4C5, R4C8).
    technique: BUG
    hint: obvious
    state:
      selection:
        cells: [R4C2, R4C5, R4C8]
      annotations:
        - cells: [R4C8]
          label: "BUG+1"
          style: pattern
  - text: >
      The candidate appearing three times (2) breaks the BUG symmetry.
      If R4C8 were 1 or 3, we'd have a deadly pattern where every candidate
      appears exactly twice — allowing multiple solutions.
    technique: BUG
    hint: detailed
    state:
      selection:
        cells: [R4C8]
      annotations:
        - cells: [R4C8]
          label: "BUG+1"
          style: pattern
  - text: >
      Therefore, **R4C8 = 2**. This placement breaks the deadly pattern
      and ensures the puzzle has a unique solution.
    technique: BUG
    hint: detailed
    state:
      selection:
        cells: [R4C8]

Summary Table

Pattern Configuration Action
BUG+1 One tri-value cell, all others bi-value Place the candidate that appears 3× in each of that cell's three units
BUG+2 Two tri-value cells, all others bi-value Strong link between their extras; eliminate each cell's extra from the other when they share a unit
BUG+3+ Three or more tri-value cells Generalises into ALS/chain reasoning; not a standalone technique
BUG-Lite A deadly sub-pattern confined to a few cells (not the whole remaining grid) A different family — see Unique Rectangles and Unique Loops

Detection Tips

  1. Count candidates first. BUG only applies once almost every unsolved cell is bi-value. If you have many cells with 3+ candidates, BUG isn't on the table yet.
  2. Verify the global rule. For every digit, in every row, column, and box, count its candidate occurrences. They must be 0 or 2 everywhere, with the one (BUG+1) or two (BUG+2) controlled exceptions you're looking for.
  3. Don't skip the verification step. A row somewhere else with a digit appearing 3 times — or 4, or 1 — disqualifies the pattern, even if the tri-value cell looks promising. Place a digit anyway and you'll generate a contradiction down the line.
  4. Late-game technique. BUG patterns almost only appear after the puzzle is heavily reduced — usually when there's a handful of unsolved cells left.

Why BUG Works

A true BUG state is perfectly symmetric: every digit appears in exactly two cells per unit, and the puzzle could be solved by picking either side of each pair. That symmetry is what makes it have multiple solutions — and since a valid Sudoku has exactly one solution, the pattern cannot survive.

The "+1" and "+2" patterns are the puzzle's last lines of defence. They show you where the symmetry is about to break and which candidate has to be placed (or eliminated) to break it cleanly. Place anything else and the only way forward is into the graveyard.

More Puzzles

Related Techniques