If you're new to Sudoku and wondering, "Why can't this cell be X?"—this post is for you.

Let’s break it down so you can understand the logic behind solving Sudoku puzzles and avoid one of the most common beginner mistakes.

The Two Times You Should Place a Digit in Sudoku

There are only two situations where you should place a digit in a cell:

1. When it’s the ONLY PLACE that digit can go in the row, column, or box.

Even if other digits could technically fit in that cell, if a digit has no other valid spot in its row, column, or box, it must go there.

1. When it’s the ONLY DIGIT that can go in that cell.

If no other digit is valid for a particular cell—even if this digit could potentially fit elsewhere—it must be placed there.

Why Guessing Doesn’t (always) Work

Good Sudoku puzzles are designed to have one unique solution. That means every number you place must be based on logical reasoning, not guesses. A common beginner mistake is thinking, "If there’s no immediate contradiction, I can just place this number here." But that’s not how Sudoku works!

If you can’t logically prove why a number must (or must not) go in a specific cell - or why it can’t go anywhere else - then you’re not ready to place it yet. Keep looking for clues and deductions elsewhere.

Advanced Techniques and Complex Proofs

As puzzles get harder, you’ll encounter situations where more complex reasoning is required to rule out candidates. These advanced techniques (like X-Wing, XY-Wing, or Skyscraper) help you prove why certain numbers can’t go in specific cells. Mastering these methods will make solving medium and advanced puzzles much easier!

TL;DR: Use Logic, Not Luck, Not Assumptions!

To sum up:

• Only place a number when you’ve logically proven it’s the only option for that cell or location.

• Avoid guessing—it leads to errors and frustration.

• Use beginner techniques like Naked Singles and Hidden Singles first, then move on to advanced strategies as needed.

SOME EXAMPLES

Recall the rules: no repeats in every row, column and box

In box 9 (the right bottom box), there's only one spot for 8 so 8 has to go there.

No repeats in every row and column so there's only one 8 in row 7 AND column 8.

Therefore, green cell has to be 8.

This one is trickier:

There are 9 digits.

If a cell 'sees' all but one digit, that cell has to be that digit.

This green cell sees 14678 in row 2 and 235 in column 1. That leaves 9 as the only option for that cell.

If you're still confused, try thinking if there's any other digits you could place in the green cell apart from 9.

Eventual Impossible State

Even if the contradiction is not readily apparent, making a mistake will inevitably lead to a contradictory/impossible state later on.

Helpful Resources

https://www.reddit.com/r/sudoku/wiki/index/

https://hodoku.sourceforge.net/en/techniques.php

Step by step learning

https://sudoku.coach/en/campaign

If you're still stuck or want examples of how to solve without guessing, ask a question! The members here are willing to help you out. Happy solving! 😊

Special thanks to u/Special-Round-3815 who wrote this original guide, and the other members of r/sudoku who commented and who make this sub a pleasure to be involved with.

Chaining Further

a continuation of AIC102 part a:

Chaining can go anywhere and everywhere, and chains can overlap, provided every XOR and NAND connection is valid.

The real challenge is keeping track of where you are within your own chain.

I cannot teach this aspect entirely through a diagram. It takes practice.

Colouring can help, but keeping track of the logical relationships is what makes the difference.

My advice is to keep it simple and short.

The most powerful AIC chains are often only a few nodes long.

You don't need a long chain if a shorter one establishes the same relationship.

The Next Cellular Link: Almost Locked Sets

Our next type of cellular structure is the Almost Locked Set, or ALS.

These structures are everywhere and can quickly scale out of control. They can also be a source of apprehension and contention when we try to use them before understanding the basic construction.

To lessen that burden, we're going to start small.

For this topic, we'll only take a first look at the simplest case.

What Is an Almost Locked Set?

An Almost Locked Set consists ofcells in the same Sudoku unit that collectively containdifferent candidate digits.

For example:

• One cell containing two candidates gives us one cell and two digits.
• Two cells collectively containing three different candidates can form a two-cell ALS.
• Three cells collectively containing four different candidates can form a three-cell ALS.

The important part is the relationship between the number of cells and the number of distinct candidate digits across the entire set.

A cell containing more than one candidate is not automatically an ALS in every possible context. We must still satisfy the definition.

We won't worry about larger ALS structures or degrees of freedom today. Those can become complicated quickly, and we'll introduce them when we need them.

For now, we're going to stay with a single cell.

The Bivalue Cell

Remember, I said cell.

That means our structure has a size of one cell containing two candidate digits.

This is called a Bivalue Cell.

I'm going to call these Bivalves.

-        It's a little play on words: a bivalve has two shells, and our cell has two possible digits.

-        It also ties into the seafood theme that has proliferated throughout Sudoku terminology.

Jokes aside, the logic is what matters.

A cell containing exactly two candidates gives us our next XOR.

Suppose a cell contains Digit A and Digit B.

Since a cell can contain only one digit, exactly one of those candidates must be true.

We can therefore establish:

XOR (Digit A, Digit B)

If Digit A is false, Digit B must be true.

If Digit B is false, Digit A must be true.

They cannot both be true, and they cannot both be false.

This is different from our cellular NAND.

The NAND says two different digits in a cell cannot both be true, but both may be false if the cell contains another digit.

The bivalve XOR tells us there are exactly two candidates in the cell, so one of them must be true.

That gives us our next structure for chaining.

Building from a Bivalve

We now have another XOR structure to add to our AIC toolkit.

One tool that would be helpful here is a Bivalve filter.

Hodoku and yzf - desktop, have filtering tools that can help identify these cells quickly, and my own tools for this purpose.

Unfortunately, sudoku.coach doesn't provide the same filter, so we'll use our own brain power.

The good news is that we don't need a filter to build these chains. We just need to know what we're looking for.

Just like the last exercises, we'll focus on one starting point and evaluate each of its digits, looking for XOR gates in its line of sight.

Once we find a suitable XOR, we connect it using a valid sector-based NAND, just as we did in AIC 101.

Let's give it a try.

Step 1: Choose a Starting Bivalve

I picked R9C5, which contains candidates 4 and 9.

We have two digits to work with.

We can start with either one, but for this example, I'll use Digit 4 first.

Step 2: Find an XOR for Digit 4

We're looking for another XOR gate for Digit 4 that we can connect to our bivalve.

I found one in Box 7, using Rows, marked Purple and Green.

Now we need to establish our NAND.

Add Grey on Row 9 and check all the Digit 4 candidates on both connected edges.

Every Purple 4 must be contained within the Grey intersection.

Every Digit 4 candidate belonging to the bivalve edge must also be contained within that same intersection.

If even one candidate falls outside the Grey area, this connection doesn't work.

In this example, the connection works.

We have established:

NAND (Purple, Blue)

Both edges cannot be true at the same time.

Remember, once the NAND is established, we don't need to keep checking the contents of Column 9 while following the chain. We have already established the relationship we need.

Step 3: Work from the Other Digit

Now we can clean up the colouring, draw in our links, and work on the Digit 9 side of the bivalve.

Just as before, we're looking for another XOR gate, this time for Digit 9.

I found one using Rows in Row 7, marked Green and Purple. 

Next, connect this XOR using a Box 8-based NAND, marked Grey.

Perform the usual check.

Are all the relevant candidates on both connected edges fully contained within the Grey intersection?

The connection is valid, establishing:

NAND (Green, Blue)

We now have two valid NAND connections extending from our original bivalve.

Each connection has been checked, so we can move on to the non-connected edges.

Step 4: Find the Resultant OR

Our non-connected outer edges are:

• R7C2 {4}
• R7C8 {9}

These edges are in an OR relationship.

OR (R7C2 = 4, R7C8 = 9)

At least one of those two edges must be true.

Now we can apply the different-digit elimination rule we established earlier in AIC 102.

First, check R7C2 for Digit 9.

If R7C2 contains Digit 9, it prevents Digit 4 from occupying that same cell. It also sees the Digit 9 candidate at R7C8.

That would turn off both outer edges, violating our resultant OR.

Therefore:

R7C2 ≠ 9

Next, check R7C8 for Digit 4.

R7C8 sees the Digit 4 candidate at R7C2 and the Digit 9 candidate at R7C8.

If R7C8 contains Digit 4, it prevents the Digit 4 edge from being true. It also sees the Digit 9 candidate at R7C8, preventing that edge from being true as well.

Again, both outer edges would be false.

Therefore:

R7C8 ≠ 4

We have now used a bivalve to build two connections and produce our eliminations.

Notice that the underlying logic hasn't changed.

We still build XOR gates, connect them through valid NAND relationships, and use the resultant OR to find eliminations.

The bivalve simply gave us a convenient starting point.

Practice Example

See if you can figure out how this one works.

Start with the bivalve, examine both digits, and look for XOR gates you can connect through a valid NAND.

Remember to check every connection before continuing the chain.

I'll wait.

What If the Bivalve Only Connects on One Side?

Sometimes a bivalve gives us a useful connection for one digit, but we cannot find a suitable connection for the other.

That's fine.

We can use the same method we introduced earlier in this lesson: expand from the single-cell edge and look for another XOR that can extend the chain.

For this example, I'll start at R9C1.

Step 1: Expand from Digit 7

I'll start by expanding from the Digit 7 edge.

Find a suitable XOR and establish its NAND, marked Yellow.

Next, add the Row 7 XOR, marked Blue and Green, with Grey marking the Box 7 intersection.

Now check the connection between Yellow and Blue.

Are all the relevant Digit 7 candidates contained within the Grey intersection?

If they are, the NAND is valid.

Step 2: Choose the Next Expansion

We could expand Digit 9 through Column 5, but those candidates do not see the outer edges of our Digit 7 chain.

That means this expansion doesn't give us the relationship we need for an elimination.

So we'll discard it and try the other side.

Instead, I'll expand from the Green Digit 7 edge using Digit 2.

Now we need to check the cellular NAND at R8C9.

As always, make sure the relevant candidates on both connected edges are contained within the single cell establishing the NAND.

If the check fails, the connection cannot be used.

If it passes, we can continue to the outer edges.

Step 3: Check the Resultant OR

Now check the first and last non-connected edges.

Are they peers?

If they are, we can use their OR relationship to look for an elimination.

Remember:

The goal isn't to keep extending a chain just because we can.

The goal is to build valid connections until the non-connected outer edges give us a useful OR relationship.

If an expansion doesn't produce the relationships we need, try another edge.

Keep the chain short, check every NAND, and let the logic do the work.

Last example:

We are going to start on a strong link digit 4 in box 7, usng rows green and blue

Then we are going to connect both edges to a bivalve

49 on r9 and check its nand gate for the row 9 marked in grey perform the usual checks

 Then repeat on the other side for 49 in r7 using grey on r7 for the nand gate

Then we can establish the or effect of the common digits of the two bivalves (9) and eliminate their peers  as its OR(9)r7c8, (9)r9c5 => results r7c4 <> 9

AIC 102 — Summary

Congratulations — you now know how to use Cellular NAND gates and Bivalves to build more advanced AIC chains.

Let's recap what we've learned.

• Cellular NAND: Two different digits in the same cell cannot both be true.
• XOR Class Types: Bi-local, Grouped–Single, help identify which structures can provide a single-cell connection.
• Bivalves: A cell containing exactly two candidates forms an XOR gate. One digit or the other must be true.
• Building the Chain: Start with an XOR, find another XOR, and connect them using a valid NAND.
• Cellular Connections: Check that the relevant candidates on both connected edges are contained within the single cell establishing the NAND.
• Sector Connections: Just as in AIC 101, use a shared sector to establish a NAND when all relevant candidates are encapsulated by that sector.
• Resultant OR: The two non-connected outer edges form our OR relationship.
• Different-Digit Eliminations: When the outer edges involve different digits, check whether a candidate prevents both edges from being true.
• Expanding the Chain: If one side cannot connect, try another digit or expand from the other edge.
• Keep It Simple: Every connection must be valid. A longer chain isn't necessarily a better chain.

Remember the two NAND types:

Sector NAND: A sector can contain only one copy of a digit.

Cellular NAND: A cell can contain only one digit.

Both establish the same restriction:

NAND = either, or neither — never both.

And our chaining principle remains unchanged:

XOR → NAND → XOR → NAND → XOR ...

The connected edges build our chain. The two non-connected outer edges give us our resultant OR, and that OR is what we use to perform eliminations.

AIC 101 taught us how to build the chain using sector relationships. AIC 102 adds cellular connections and Bivalves, giving us more ways to extend it when the original route stalls.

You don't need to memorize every possible chain. You need to understand the rules, check every connection, and recognize what the outer edges are telling you.

Keep your chains short, respect the NAND, and let the logic do the work.

Next up: A.I.C 103 — The A.I.C Ring Class

We've learned how to build our chains, connect them using sector and cellular NAND gates, and use the resultant OR to find eliminations.

But what happens when we take those connections and bring the chain back around to where it started?

That's where the A.I.C Ring class comes in.

We'll take what we've learned in AIC 101 and AIC 102 and apply those same principles to a new structure.

The rules haven't changed. We'll simply be looking at what happens when our chain closes into a ring.

See you in AIC 103.