StrmCkr wrote:actually logic gates:

Welp that clears up alot.

I'm glad if that helped! I kind of thought it might work for your mathematical mind. Most people would probably find the logic gate POV too complicated and get just more confused and repulsed. Not you. I know it helped me as well when I realized the connection. Somewhere here should be a post where I actually translated some AICs into logic gates, but I can't find it now. Even though it's not necessary at all for the normal use of AICs, that exercise did provide a deeper understanding of chaining logic.

(skyscraper example)

R1C2 = R1C7 - R6C7 = R6C3

(R1c2 or r1c7) and (r1c7 nand r6c7) and (r6c7 or r6c3)

If I wrote that correct it should reduce to

(R1c2 or R6c3)

Exactly! In Eureka, I would write that (using digit 1):

(1)r1c2 = r1c7 - r6c7 = (1)r6c3 => -1 r123c3,r456c2

<-> 1r1c2 OR 1r6c3

David P Bird wrote:A large number of inferences used in logic chains are 'conjugate' where the linked Booleans must contain one truth. Typical cases are a 'bivalue' cell holding two digits and a 'bilocal' digit that can only occupy two cells in a house. Conjugate inferences are therefore both weak and strong, but within AICs, they can only be used in one way or the other and must be notated accordingly using the standard '-' and '=" symbols.

alright this is the part that muddled most of my chains as I leave bivavle.s, conjgates listed as strong links graphically as they are depicted on a grid.

Good catch, then! Yes, it's very important to understand that a native bivalue/bilocation link is actually XOR, so it can work as both a strong (OR) and a weak inference (NAND) -- but not at the same time. When writing a chain it's always one or the other. However, the same link can be revisited in a chain and used in the opposite role then, but that's rarely needed.

Another important thing to notice is that even though bivalue/bilocation links are natively XOR types, we never use that type as a logic gate in regular AICs. It's always just OR (when used as a strong inference), because it's all that's needed, and it makes it much simpler to prove the derived OR between the end nodes.

However, if you can prove an XOR relationship (both OR and NAND) between the end nodes, you have a (continuous) loop which turns every weak link into XOR as well. For example, if we turn your Skyscraper into an X-Wing we get a loop, because the end nodes now see each other (and thus have a native NAND relationship in addition to the derived OR):

(1)r1c2 = r1c7 - r6c7 = (1)r6c2 - loop => -1 r2345789c27

<-> 1r1c2 XOR 1r6c2 ( => 1r1c7 XOR 1r6c7)

SpAce wrote:One source of confusion is that the old Nice Loop notation, which you (and unfortunately Hodoku) insist on using, omits displaying cell internal links and only shows links between cells. It makes it look like the inferences aren't alternating, which is really misleading.

combination of both.

Where were you years ago, you made that easy.. the first thing I posted cleared alot and the above note.

Thank you! I'm really happy if I could actually help.

Btw, I just happened to walk into an

old thread by hobiwan. It has an example of a chain where the same cells can be used for two different chains with two different eliminations. For some reason, hobiwan couldn't figure out how they could be eliminated at the same time, even though it's relatively easy with an AIC (Grouped X-Chain in this case). I think it was mostly because of his fixation with Discontinuous Nice Loops (although it's possible with one of those too, as aran demonstrates).

That kind of explains why Hodoku still uses DNLs for lone eliminations, even though it knows AICs and could use them just as well. It also explains why Hodoku doesn't really have Grouped X-Chains, which is another thing I've wondered about. On the second page hobiwan also makes a comment about notations, from which it's possible to deduce that he wasn't a fan of Eureka. That's probably why Hodoku uses the Nice Loop notation, unfortunately.

Anyway, here's one way to answer hobiwan's question with a single Grouped X-Chain:

- Code: Select all
`.-----------------------.--------------.----------------------.`

| 4678 h(1)678 9 | 18 5 2 | 4678 e1478 3 |

| 4678 2 g678-1 | 9 3 148 | f14678 5 f1678 |

| 5 h(1)8 3 | 6 7 148 | 9 e148 2 |

:-----------------------+--------------+----------------------:

| 678 678 5 | 2 168 9 | 167 3 4 |

| 9 3 678 | 18 4 5 | 1678 2 1678 |

| 1 4 2 | 7 68 3 | 5 9 68 |

:-----------------------+--------------+----------------------:

| 368 5 a[1]468 | 34 18 7 | 2 d148 9 |

| 378 9 a[1]478 | 34 2 18 | 478 6 5 |

| 2 b78-1 a[1]478 | 5 9 6 | 3 d1478 c178 |

'-----------------------'--------------'----------------------'

(1)r789c3 = r9c2 - r9c9 = r79c8 - r13c8 = r2c79 - r2c3 = (1)r13c2 => -1 r2c3,r9c2

Not hard at all. Of course the whole question has limited relevance, as either elimination is enough alone. We get the other one immediately after with a pointing or a claiming operation, so in reality I would cut the first two nodes out and just eliminate r9c2. Still, it's easy to get them both with a single chain too (note that they're both cannibalistic eliminations, from which we can deduce that simpler options probably exist). Hodoku still can't do that. For some reason it can't use grouped nodes as end points in AICs, so it has to use DNLs.

Here's hobiwan's two DNLs translated into AICs and Eureka:

hobiwan wrote:r9c2 -1- r9c9 =1= r79c8 -1- r13c8 =1= r2c79 -1- r2c3 =1= r13c2 -1- r9c2 => r9c2<>1

(1)r9c9 = r79c8 - r13c8 = r2c79 - r2c3 = (1)r13c2 => -1 r9c2

hobiwan wrote:r2c3 -1- r13c2 =1= r9c2 -1- r9c9 =1= r79c8 -1- r13c8 =1= r2c79 -1- r2c3 => r2c3<>1

(1)r13c2 = r9c2 - r9c9 = r79c8 - r13c8 = (1)r2c79 => -1 r2c3

As you can (hopefully) see, AICs written in Eureka are much shorter and clearer than DNLs written in the Nice Loop notation. I started writing chains as Discontinuous Nice Loops, because it was all I knew, but I immediately switched to AICs and Eureka when I learned about them. It's not just the shorter notation I prefer. DNLs are contradiction proofs while AICs are verity proofs. A subtle but meaningful difference, at least in principle.