The New Sudoku Players' Forum

[StrmCkr]

The Remote Pair ensures, that any cell within the chain has the opposite value of the cell before it. Any cell outside the Remote Pair that sees two cells with different values cannot have one of the Remote Pair digits set.

Remote Pairs can be replicated by one or two Simple Color moves, (noted fourther down in the page remote pair is also an xy chain)

Quoted from . Hodoku.

What I was demonstrating was the out come of start and end was identical 1 & 8 was true regardless of start or finish direction.

What you where showing was that either a side was 1 or the other side was 1. In a single stream fashion. meaning that any cell that sees both "1"s is false.

What I said is also truth for AIC in some circumstances.

Yes reading chain streams left to right or right to left proves the same single digit as noted above that a cell = 1 or b cell = 1 , again my point is also noting that repeating digits in the chain are also true
that a = 8 or b = 8 {a=1 then b = 8, b = 1 then a =8}

In the case of remote pairs the end and start are a fixed pair of cells. that solve A = B or B = A
So that a & b are true, any cell that sees both a & b cannot hold a&b. (common digits of start and end cannot appear in peer cells of start and end)

Which is a construct rule for eliminations for xy, AIC, nls. Etc.
It is Just a question if people fully implemented them.

Hope. You manage to decipher my point.
When I have time, I'll dig up more info on it.

[SpAce]

Hope. You manage to decipher my point.

Nope, but that's ok. I'm done with this discussion.

When I have time, I'll dig up more info on it.

Not really necessary. I'm already exhausted, and I don't think we'll ever understand each other. You've said yourself that you don't think in terms of chains and can't even write them. It's pretty obvious too. How do you expect to have a rational discussion about them if that's the case? What makes you so sure you still know them better than someone who's proven many times over that his chaining skills are second to none, both in practice and in theory? How do you justify that sort of zero-doubts self-confidence? For all I know, you may well have genius level solving skills, and I respect your long and glorious sudoku history and innovations, but this topic is clearly not your strong suit.

[StrmCkr]

(1 or 8) = (8 or 1)

In terms of chain writing, the cells Are all bivalve. Then they. Are weakly linked twice. (1 per digit) which makes them strong links)

(1|8)R2c5 = (8|1) r2c7 = (1|8) R3C9 = (8|1) R7C9 >> R7C5 <>1,8

| = or in coding.
Follow the chain of ors. By reading the same side of the |

1 =8=1=8
Or
8=1=8=1

Any cell that can see both a 1&8 are eliminated

Are you seriously saying that you think AICs can produce different results depending on whether read from left-to-right or right-to-left? I hope you don't really mean that, so what exactly do you mean?

the outcome of 1 digit existing either at the start or the end A or B will not change, what i was saying is that other digits also occur multiple times as a result of the chains progression when followed. {in remote pairs 2 digits alternate.}

this same even can be seen in xy - chains when start and end cells use the opposite ending digit but contain the same candidates.

(1=2) = (2=3) = (3=5) = (5=4) = (4 = 2) = (2=1)

solved

1,2,3,5,4,2
2,3,5,4,2,1

all cells that see first and last cant = 1,2

Code: Select all

+---------------+------------+------------+
| .  .     .    | .  .     . | .  .     . |
| .  (12)  .    | .  .     . | .  -1    . |
| .  .     (23) | .  .     . | .  .     . |
+---------------+------------+------------+
| .  -12   .    | .  .     . | .  (12)  . |
| .  .     (35) | .  (45)  . | .  (24)  . |
| .  .     .    | .  .     . | .  .     . |
+---------------+------------+------------+
| .  .     .    | .  .     . | .  .     . |
| .  .     .    | .  .     . | .  .     . |
| .  .     .    | .  .     . | .  .     . |
+---------------+------------+------------+


take that grid and make it legible for hodoku for all the strong links

Code: Select all

.--------------------------------.---------------------------------.--------------------------------.
| 13456789   13456789   1456789  | 123456789  123456789  123456789 | 123456789  13456789  123456789 |
| 13456789   12         1456789  | 123456789  123456789  123456789 | 123456789  13456789  123456789 |
| 13456789   13456789   23       | 123456789  123456789  123456789 | 123456789  13456789  123456789 |
:--------------------------------+---------------------------------+--------------------------------:
| 123456789  123456789  12456789 | 123456789  123456789  123456789 | 13456789   12        13456789  |
| 1236789    1236789    35       | 1236789    45         1236789   | 136789     24        136789    |
| 123456789  123456789  12456789 | 123456789  123456789  123456789 | 13456789   13456789  13456789  |
:--------------------------------+---------------------------------+--------------------------------:
| 123456789  123456789  12456789 | 123456789  123456789  123456789 | 123456789  13456789  123456789 |
| 123456789  123456789  12456789 | 123456789  123456789  123456789 | 123456789  13456789  123456789 |
| 123456789  123456789  12456789 | 123456789  123456789  123456789 | 123456789  13456789  123456789 |
'--------------------------------'---------------------------------'--------------------------------'

XY -Chain: 1 1- r2c2 -2- r3c3 -3- r5c3 -5- r5c5 -4- r5c8 -2- r4c8 -1 => r2c8,r4c2<>1
is the only chain it can find, it completely misses the propagation for the strong links showing that the first and last are remote pairs (1 & 2 )

because it only propagates the starting cell as 1 or not 1.
when not 1, it follows the chain to the last cell, which = 1

when it is 1, then chain still propagates and the last cell is now = 2

and not 1 on the first cell means it = 2

this rule seems to be missing in everything except remote pairs.

[SpAce]

Thank you. For the first time I got your point. You're still wrong.

XY -Chain: 1 1- r2c2 -2- r3c3 -3- r5c3 -5- r5c5 -4- r5c8 -2- r4c8 -1 => r2c8,r4c2<>1
is the only chain it can find, it completely misses the propagation for the strong links showing that the first and last are remote pairs (1 & 2 )

No, it doesn't miss anything. It just sees two different chains, which is all that makes sense. One is an XY-Chain and the other is an AIC (which Hodoku, being stupid in that particular area, reports as a DNL) that just happens to use the same cells.

1. XY-Chain: (1=2)r2c2 - (2=3)r3c3 - (3=5)r5c3 - (5=4)r5c5 - (4=2)r5c8 - (2=1)r4c8 => -1 r2c8, r4c2
2. AIC: (2)r2c2 = (2-3)r3c3 = (3-5)r5c3 = (5-4)r5c5 = (4-2)r5c8 = (2)r4c8 => -2 r4c2

Together they get both eliminations, but there's no sensible way to see them as a single chain getting both at the same time. Yes, they can be combined into a complex split-node chain or a backpedaling loop with subchains, just like a Remote Pair, but how much sense does it make? Close to zero (unless it's needed for a one-trick-pony challenge). Unlike a normal Remote Pair, those two chains use completely different logic, which makes it unlikely that a player would see them at the same time and apply them together. Even in that case, notating that combo chain would be difficult and hard for anyone to understand.

It would be a ridiculous requirement to have either a player or a software solver recognize every possible situation where two chains happen to coincide like that. Neither of them has to be an XY-Chain anyway, or to use the same cells (except for the end-cells), for that to happen. Basically, what you demonstrated was just an extension to Keith's "General Remote Pair", the very possibility I already mentioned earlier:

I guess in the most general form the two X-Chains could even take completely different routes as long as they join in the same end point cells. An even more general form could use more complicated chain pairs as well. A new can of worms. Fun.

In other words, the possibilities to form such "remote pairs" are endless. If someone wants to call them Remote Pairs and use them as a unit, fine, but then they should come up with valid notations for such combo chains as well. Few people can understand them if written as correct AICs, and even fewer can write them.

this rule seems to be missing in everything except remote pairs.

Of course it is. Only the normal Remote Pair deserves to be a special case because everyone knows it and its dual logic is easy to see with a glance. In reality it still contains two chains, just like your example. They just happen to be almost identical, which makes them (deceptively) easy to see as a unit. That is not the case with your example where the two chains are completely different despite using the same cells. It could be even worse if the chains followed different paths.

It would be truly horrible if players had to remember such special rules for every possible situation where two chains with different eliminations happen to coincide. It's much simpler to see them as two different chains, which is the reality anyway. You may call them <prefix> Remote Pairs if you want, but please don't tell me you can write them as a single XY-Chain and eliminate two different digits. You can't. End of story.

PS. These are not AICs:

(1|8)R2c5 = (8|1) r2c7 = (1|8) R3C9 = (8|1) R7C9 >> R7C5 <>1,8

(1=2) = (2=3) = (3=5) = (5=4) = (4 = 2) = (2=1)

Those "chains" don't propagate anywhere and can't prove anything because there are no weak inferences. As you must know, "AIC" stands for Alternating Inference Chain. It means that strong and weak inferences must alternate throughout the chain. It doesn't matter one bit if all of the links between the nodes happen to be strong in the grid. Every other one of them must still be used and notated as a weak inference. (As a side note, the first one with the '|'s wouldn't work anyway -- that's why I suggested using '/' to specifically avoid that trap and make sure it's not confused with 'OR' and real AIC logic.) Of course this is all covered in Chaining 101, but I guess you've never bothered to take that class. It makes chaining-related discussions exceedingly difficult and frustrating with you.

[StrmCkr]

(1|8)R2c5 = (8|1) r2c7 = (1|8) R3C9 = (8|1) R7C9 >> R7C5 <>1,8

(1=2) = (2=3) = (3=5) = (5=4) = (4 = 2) = (2=1)

The = in the first chain between cells is. Double weaklinks
Not a standard strong link but Derived one. it can alternate interface. By the digits not link type
But if you insist

(1=8) - (8=1) - (1=8) - (8=1)
And
(8=1) - (1=8) - (8=1) - (1=8) => <>1,8

I was pretty that the "|" rePresented or for a group of digits .
So I combined the two replacing the (8=1) with (8|1)
Joining the 2 - => = as that's how they function.

The 2nd chain is indeed messed sorta.
Strongly linked between digits, and strongly linked internal
Alternative interface between digits not link types.

As fair as I understood from long ago history AIC could alternate between digits, not nessesarily link types. From really old threads where aics could be constructed with pure strong links on digits(bilocal) . And pure internal via bivavle.
For what ever reason aics now a days don't use the bilocal and write out the weak inference between the cells even if its a bilocal

Send a link I have some refreshers on chaining terminology.
And I'll attempt a history search for those types of aics.

[SpAce]

As fair as I understood from long ago history AIC could alternate between digits, not nessesarily link types. From really old threads where aics could be constructed with pure strong links on digits(bilocal) . And pure internal via bivavle.
For what ever reason aics now a days don't use the bilocal and write out the weak inference between the cells even if its a bilocal

Forget all that ancient crap (which you've probably misunderstood anyway), and learn what AICs mean today (which you've apparently misunderstood as well). It makes life much simpler. Modern AICs can be used to prove pretty much anything, and they have zero ambiguity if the simple rules are followed.

The most important thing to understand about AICs is that they're actually chain-like interfaces to boolean logic. Once you understand that, then you can always check if an AIC is correct or not, if you know how boolean logic works. The links are actually logic gates:

= OR
- NAND

(They're not just that, though, so you can't simply replace the link symbols with those gates. What makes the links different from normal gates is that there's always an implied AND between any two linked pairs.)

Additionally, these gates are used in advanced chains to connect multiple elements in a single node:

& AND
| OR (when not a link)
, (ordered AND)

The (usual) goal of an AIC is to construct a logical connection between distant grid elements, so that it proves a derived strong link (OR) between the end points (proving that at least one of them must be true). For example:

(1=8)r2c5 - (8=1)r2c7

...actually means this:

(1r2c5 OR 8r2c5) AND (8r2c5 NAND 8r2c7) AND (8r2c7 OR 1r2c7)

If you work it out, it should simplify to this:

1r2c5 OR 1r2c7

...which is the same as this (- used for NOT, -> for implication):

(-1r2c5 -> 1r2c7) AND (-1r2c7 -> 1r2c5)

In other words, it now proves that at least one of those two must be true, from which we can easily deduce => -1 r2c1234689

If you understand all that, then you should see why a chain with just strong links (ORs) doesn't (usually) prove anything useful. It just states the obvious: that at least one node in each strongly linked node pair must be true.

To me it seems that instead of building a useful logic construct, you're just trying to describe a grid pattern using chaining symbols. Such modeling, even if otherwise correct, doesn't contain logic that would prove anything. For example:

(1|8)R2c5 = (8|1) r2c7 = (1|8) R3C9 = (8|1) R7C9

In other words:

(1r2c5 | 8r2c5 | 1r2c7 | 8r2c7) AND (1r2c7 | 8r2c7 | 1r3c9 | 8r3c9) AND (1r3c9 | 8r3c9 | 1r7c9 | 8r7c9)

What exactly does that prove? Answer: that at least one of those ORed elements within each of the three brackets must be true. That piece of trivia doesn't doesn't give us any eliminations or even new insights. The same knowledge can be obtained just by looking at the grid.

It really needs those weak links (NANDs) to build a logical connection between the end points, to prove a derived strong link (OR) between them. However, using ORed content (1|8) at all nodes and end points prevents building a working chain anyway, so that fix is far from enough. As I've tried to say all along, building a correct AIC with a double-digit elimination is much more complicated than it may at first seem.

Send a link I have some refreshers on chaining terminology.

David's AIC Primer
Hodoku chaining
Eureka notation

I think those should get you started.

And I'll attempt a history search for those types of aics.

That would be interesting for sure, but I really hope you don't use them as a defense for using obsolete ideas as if they were still valid and useful.

As I said at the beginning, I'm actually pretty sure you've misunderstood the ancient stuff too, but we'll see. 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.

Make no mistake, the inferences are still there. They're just hidden. That's one reason why the the Nice Loop notation is crap. Move on to Eureka. It doesn't hide essential details, and it's much more readable and flexible too. While at it, forget about Discontinuous Nice Loops too. They're ancient crap as well (though possibly helpful for beginners). All anyone needs is AICs.

[StrmCkr]

actually logic gates:

Welp that clears up alot.

To me it seems that instead of building a useful logic construct, you're just trying to describe a grid pattern using chaining symbols. Such modeling, even if otherwise correct, doesn't contain logic that would prove anything. For example:

Pretty much, chaining was built using the info off a grid... ... (or so I thought who knows at this point) but it doesat least it makes it easy to follow it graphically on the grid.....)

= strong link (a or b)
- weaklink. (a not b) (conditional false)
(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)

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.[/quote]

As I said at the beginning, I'm actually pretty sure you've misunderstood the ancient stuff too, but we'll see. 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.

[SpAce]

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

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)

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:

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

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.

[StrmCkr]

Retracted for now, will post later once I've thought about it some More.

And = true when a & b = true
Nand = false when a & b = true (and inversion)

A chain has 2 conditions which alternate through the links (on or off) booleen logic evaluates both conditions

1010
0101

What we can desern from that is 2 truths
If start and end are identicall digit.
Any cell that sees both the start and ending cells <> that digit
And the inversion is also true
If the start and end share the same digit when its off ie not 1.
Then any cells that see the start and end cant <> that digit.

If start and end are peers to themselves they cannot contain the digit from the opposite side.
If start and end are peers and contain same digits but opposite is always active then we have a loop
And all weak links now act as strong links.

Problem for AIC chains logic constructs do not exactly check the invserion. The equations prove both the above 01 data tables have the same result. Thus the start and end for the tested digit is true in a or b and potentially both. Meaning it has one directional logic limitations. It can only test 1 digit at a time the way they are written/constructed.

[SpAce]

(1=8) R2c5 [-(8 =1) or - (1=8)] R2C7 [- (1=8) or - (8=1)] R3C9 [-( 8=1) or - (1=8)]R7C9

Not a valid AIC. Btw, I suggest you start writing the cell coordinates in lowercase. An easy first step towards Eureka! More readable anyway.

Problem with AIC logic is that it can't walk links for the not portions when first condition passes true.

There's no NOT symbol in AICs, nor is it ever needed. You have to change your thinking to avoid that trap. They're not chains where you have to make an initial assumption to get somewhere. Besides, the gates available to AICs are more than enough to express any logic. The Apollo Guidance Computer that got us to the moon had only NOR gates! AICs have NAND which is a similarly universal gate. In other words, we don't really need even the OR

Before you try to invent more non-standard ways to express the logic in question, how about looking at my original suggestion with a fresh eye:

Remote Pair: (1/8)r2c5 = r2c7 - r3c9 = (1/8)r7c9 => -18 r7c5 (not a real AIC of any kind!)

What's wrong with that? It's very simple and understandable, if correctly interpreted -- i.e. so that the same chain applies to both 1 and 8 (separately) leading to both eliminations. In other words it depicts two parallel X-Chains packed into one expression. The '/' is used instead of '|' to warn that it should not be viewed as a single AIC, because it wouldn't be correct that way.

If you really want to express it as a real AIC, then you should probably first try to understand what this does:

AIC: (1,8)r2c5,r7c9 = r2c5|r3c9 - (8=1)r2c7 - r2c5|r3c9 = (1,8)r7c9,r2c5 => -18 r7c5

It's a valid AIC, and possibly the simplest possible for this purpose. It proves that we have either (1r2c5 AND 8r7c9) or (1r7c9 AND 8r2c5). It could be written more explicitly like this:

(1)r2c5&(8)r7c9 = (8)r2c5|(8)r3c9 - (8=1)r2c7 - (1)r2c5|(1)r3c9 = (1)r7c9&(8)r2c5 => -18 r7c5

See what it does? The two parallel chains start at the opposite cells (r2c5 and r7c9), touch each other at r2c7 (important), and end up at the opposite cells again. That's how we get the ANDed result for both end points. It's perhaps unintuitive and difficult to follow (the unfortunate nature of split-nodes) but as far as I know, it's the only way to write it correctly without the (even more) horrible subchain kludge.

Note that the weak link (1)r2c7 - (1)r2c5|(1)r3c9 can be considered NOR logic:

1r2c7 NAND (1r2c5 OR 1r3c9)
<->
NOT (1r2c7 AND (1r2c5 OR 1r3c9))
<->
NOT ((1r2c7 AND 1r2c6) OR (1r2c7 AND 1r3c9))
<->
(1r2c7 AND 1r2c6) NOR (1r2c7 AND 1r3c9)

(The same is true with (8)r2c5|(8)r3c9 - (8)r2c7, but the above is easier to see when read from left to right.)

See now? AICs could get us back to the moon easily, and maybe even to Mars

PS. I don't really have anything new to say about your rewritten post. I have no idea what you want to achieve. A new AIC spec? With what exactly? I can't see how it could be extended to support what you seem to want, though I'm still not sure what it is anyway. AICs are simple and elegant the way the are, but if you start adding features their paradigm can't natively support, it all breaks into a complicated mess. It's happened to many programming languages too. Things are much simpler if you only have a few fundamental rules to worry about, even if it limits your expressive power in some special case situations. A good AIC writer, just like a good programmer, can always find workarounds in those situations.

That being said, if you have an idea that actually fits with the existing paradigm, that's different. For example, my comma notation for ordered tuples (1,8)r2c5,r7c9 isn't exactly standard (though I originally thought I'd seen it somewhere, but I've never found it since). It does fit, however, because it's a boolean (either those digits are in that order in those cells or they're not). It also adds missing expressive power which shortens and simplifies many situations, imho.

[StrmCkr]

What do I want to achieve.

That the construction rules already prove the 1&8 elimination with the basic written xy chain without the need for mutiple chains
As an AIC without changing any of its context or the need for a complex chain.

Nand (off if the two cells are true)

This section shows what digit is the inversion digit ie (not 1 in the first cell) and not 1 in the last.
as mentioned in my re written post. The inversion digit is identical at the start and end, can also be excluded by the same rules that prove the location of first digit.

Clear as mud?
Invert the chain digits and the logic construct stays the same
(swap order)

[SpAce]

What do I want to achieve.

That the construction rules already prove the 1&8 elimination with the basic written xy chain without the need for mutiple chains
As an AIC without changing any of its context or the need for a complex chain.

Ok. I've already told you that it's not possible without radically changing AIC semantics.

One more time. Here's an XY-Chain pair corresponding with a Remote Pair eliminating -12 r5c1:

Code: Select all

(1=2)r1c1 - (2=1)r1c5 - (1=2)r3c6 - (2=1)r5c6 => -1 r5c1
(2=1)r1c1 - (1=2)r1c5 - (2=1)r3c6 - (1=2)r5c6 => -2 r5c1

So, you want to see them as one and the same, to get both eliminations at once using just one or the other? For that to work, their logic gate translations should be equal and agree to the combined result. Ok, let's try that.

The first chain expressed as logic gates:

Code: Select all

(1r1c1|2r1c1) & ~(2r1c1&2r1c5) & (2r1c5|1r1c5) & ~(1r1c5&1r3c6) & (1r3c6|2r3c6) & ~(2r3c6&2r5c6) & (2r5c6|1r5c6)
<->
1r1c1|1r5c6 => -1 r5c1

The second chain as well:

Code: Select all

(2r1c1|1r1c1) & ~(1r1c1&1r1c5) & (1r1c5|2r1c5) & ~(2r1c5&2r3c6) & (2r3c6|1r3c6) & ~(1r3c6&1r5c6) & (1r5c6|2r5c6)
<->
2r1c1|2r5c6 => -2 r5c1

In other words, they "compile into different binaries" and have different results. The strong link parts are the same but the weak links are not. To make them agree on a combined result you should make some radical changes to the AIC compiler rules. Is it worth it for a special case? I don't think so. How would you even do it? Can you show your suggested translation rules and logic gates for this:

Code: Select all

(1=2)r1c1 - (2=1)r1c5 - (1=2)r3c6 - (2=1)r5c6
<-translation rules?->
Logic gates? (*)
<->
1r1c1&2r5c6 | 2r1c1&1r5c6 => -12 r5c1

No? Either way, can we drop it already? I think it's more worthwhile to consider options that are doable and good fits with the existing architecture. The nice thing about AICs is that they're very straightforward to translate into logic gates. What you're suggesting is not. It would just complicate things a lot for a very small upside.

(*) The logic gates part is probably easy. Just add the NAND terms for both digits, I think. That, however, is not in line with the AIC which depicts only a single weak link between the cells. So, the real show-stopper is the translation rules. In theory, we could add a special rule that says identical bivalue cells are implicitly weakly linked on both digits. Or we could add a special symbol for a dual weak link (but not '=', obviously). However, either way would add complexity for very little gain, because there's only a single special case where it would help: the (classic) Remote Pair. It still wouldn't cover even the more generic variants of it.

[StrmCkr]

What I was suggesting Is inline with logic gates properties
For the gates :
A l B
A & B

Order can be swapped
B | A
B & A

And the structure of the gates remain identical, the digit at the start and finish for outcome changes

1=8 - 8=1 - 1=8 - 8=1
Becomes
8=1 - 1=8 - 8=1 - 1=8

sure I'll drop it for now, till I can easily identify a way of noting when that property is applicable.

Tinkering with the above as a w wing

1=8 - 8=8 - 8=1
1|8 & ~(8&8) & 8|8 & ~(8&8) & 8|1

Swaping gate order then the nand gate changes

8=1 - 8=8- 1=8
8|1 & ~(1&8) & 8|8 & ~(8&1) & 1|8

Which proves noting.

(*) The logic gates part is probably easy. Just add the NAND terms for both digits, I think. That, however, is not in line with the AIC which depicts only a single weak link between the cells. So, the real show-stopper is the translation rules. In theory, we could add a special rule that says identical bivalue cells are implicitly weakly linked on both digits. Or we could add a special symbol for a dual weak link (but not '=', obviously). However, either way would add complexity for very little gain, because there's only a single special case where it would help: the (classic) Remote Pair. It still wouldn't cover even the more generic variants of it

¦ (suggestion for double weak link)

[SpAce]

What I was suggesting Is inline with logic gates properties

Yes, but it's not in line with chaining fundamentals.

For the gates :
A l B
A & B

Order can be swapped
B | A
B & A

True so far.

And the structure of the gates remain identical, the digit at the start and finish for outcome changes

1=8 - 8=1 - 1=8 - 8=1
Becomes
8=1 - 1=8 - 8=1 - 1=8

That still doesn't work, because the whole idea violates fundamental AIC principles. While (1=8) is the same as (8=1) in the logic form (as ORs) by itself, it's not the same in a chain with oriented links to other nodes. If you have (1=8) you simply can't weak-link the 1 to the right or the 8 to the left. "Chain" implies order, so you can't change the order of elements and say it's the same chain. Even though any AIC can be represented with logic gates, it doesn't mean that any valid set of logic gates can or should be expressed as an AIC.

sure I'll drop it for now, till I can easily identify a way of noting when that property is applicable.

You should still consider whether it's worth it. Any new rules and symbols add complexity and things to remember. Such extensions should have a high payoff. I don't see it for this at all, being limited to a single special case. Even more importantly, it violates AIC fundamentals.

~8&8

You should write that ~(8&8) if you mean NAND. Without the parentheses it's very different. (Of course it doesn't make much sense without the cell coordinates anyway, but that's ok; I know what you mean.)

¦ (suggestion for double weak link)

Not good. Any chaining symbol should be easily found on a normal keyboard. It's not very intuitive either, having a different orientation from the normal links. I don't think there's a good option for this at all anyway, for the above mentioned reasons, so pursuing it is probably pointless.

You still haven't commented my original suggestion at all. What's wrong with it? It's the simplest and the shortest, requiring no extra symbols or rules added to the AIC spec (because it doesn't even pretend to be an AIC). Whether it's perfect or not, I think it's the right principle anyway. A Remote Pair is a double-chain similar to a siamese fish being a double-fish. There's no way around it. I have no interest in bending AICs to do something they natively can't, like representing double-chains without split-nodes. It's like adding both sets of covers (of a siamese fish) to a single fish and saying it should work despite the non-functioning rank. It might be convenient, but it's still nonsense.

PS. Here's one more way to write a Remote Pair as a valid AIC:

Code: Select all

(1=2)r1c1 - (2=1)r1c5 - (1=2)r3c6 - (2=1)r5c6 => -1 r5c1
(2=1)r1c1 - (1=2)r1c5 - (2=1)r3c6 - (1=2)r5c6 => -2 r5c1

<->

Code: Select all

(1)r1c1&(2)r1c5&(1)r3c6&(2)r5c6 = (2)r1c1&(1)r1c5&(2)r3c6&(1)r5c6 => -12 r5c1

No, I'm not seriously suggesting that.

PPS. You should put my quoted text in quotes. It looks weird otherwise.

[StrmCkr]

¦ is found on the backslash key above enter on a normal keyboard..