# Bivalue Universal Grave

A Bivalue Universal Grave or BUG is a state of the grid in which every unsolved cell has 2 candidates, without the presence of Hidden Singles.

This is one of the Deadly Patterns that do not occur in a valid Sudoku.

For some people, it is also a solving technique. The aim of this technique is to avoid a BUG pattern, by avoiding moves that would cause it to appear. As with other techniques that depend on the assumption that the Sudoku has a unique solution, it is the subject of debate. See Uniqueness Controversy.

## Proof of non-uniqueness

In a BUG, each unsolved cell has two candidates, and in each row, column and box constraint, each candidate value occurs exactly twice. If we can find a valid solution using half the number of remaining candidates, all the eliminated candidates would also satisfy each constraint exactly once. This other half will also give us a solution to the puzzle. There is also the possibility that the puzzle does not have a solution at all. In that case, the puzzle is also invalid. The existence of the BUG pattern allows us to conclude that the puzzle is invalid. It has either no solution or 2 solutions.

## Assuming uniqueness

When your aim is to prove that the Sudoku has a unique solution, finding a BUG means that you can stop trying. For you, there is no other use for the BUG pattern.

When you trust the maker of the puzzle, who has guaranteed that it has a unique solution, you can use techniques that will prevent the pattern from being formed. Note, however, that since the BUG pattern cannot occur in a well-formed puzzle, such a configuration can also be solved using other techniques without having to exploit the solution's uniqueness.

## How it works

The whole idea of this solving technique is that if we have a grid that is formed by a BUG grid plus extra candidates, then at least one of the extra candidates must be placed. The term BUG+n is used to denote a BUG grid with n cells with one or more extra candidates. The simplest form is BUG+1, where two BUG candidates may be immediately eliminated from the one cell with extra candidates. If there is only one extra candidate, the result is a placement.

### BUG+1 example

This example shows a BUG+1, where the extra candidate is the digit 9 in r1c5. If r1c5 is not 9, then we obtain the BUG pattern. Therefore, 9 can be placed in that cell, and the Sudoku can be solved easily using singles.

The same deduction can be reached without assuming uniqueness using this conjugate chain where either all the candidates tagged 0' are true or all those tagged 0" are.

```(5')r1c5 ~ (5"~9')r1c4 ~ (9")r2c1~ (9'~7")r2c5 ~ (7')r1c5 => r1c5 <> 57, r1c4,r2c5 <> 9
```

This shows that 5 & 7 are equvalent in r1c5 and they are true or false together. As they both can't be true in the same cell, they must be false.

Yet again an AIC that solves the pattern without relying on showing a contradiction if one truth state is assumed is:

```(5=9)r1c4 - (9=1)r1c3 - (1)r7c3 = (1)r7c5 - (1=5)r8c5 => r1c3 <> 5, r8c4 <> 5
```

### BUG+2 example

The following example is taken from the Sudoku Players' forum:

Checking the candidates in the two cells with triples, if (7)r7c2 and (8)r8c3 were both false a deadly pattern would be created with each of its digits repeating twice in every house. Consequently at least one one of these candidates must be true. As these cells see each other, this eliminates (8)r7c2 & (7)r8c3 which produces a cascade of singles to solve the puzzle.

Again, without assuming uniqueness, these conjugate chains show that two candidates in these cells are equivalent and so must be false.

```(9')r7c2 ~ (9")r6c2 ~ (9'~7")r6c8 ~ (7'~2")r4c8 ~ (2'~8")r7c8 ~ (8')r7c2
=> r7c2 <> 89, r6c8 <> 9, r4c8 <>7, r7c8 <> 2

(7')r8c3 ~ (7")r1c3 ~ (7'~1")r1c4 ~ (1')r9c4 ~ (1")r9c3 ~ (1')r8c3
=> r8c3 <> 17, r1c4 <> 7, r9c4 <> 1
```

Or using an AIC:

```(9)r7c2 = (9)r6c2 - (9=7)r4c1 - (7=2)r4c8 - (2=8)r7c8  => r7c2 <> 8
```

## Practice puzzles

The following two puzzles are practice puzzles for BUG+1.

```007000200000850010060002005900030140208001000004000000000500700402000000000017008
920000000080000400000100853008000000073040060090000070040500001009004630000260000
```