"One notable difference is that confirming loops, the almost nice loops yielding a clue, cannot be formed by XY chains. The links between bv cells must function as winks. If you have thought about the possibility of using the internal slink of the bv twice to confirm the starting candidate, as in the diagram below, forget it."
https://sysudoku.com/2012/03/06/xy-loops/
What does that mean in practice?? Does he mean by "confirming loops" discontinuous nice loops that have two strong links at the discontinuity? I'm assuming so. Let's look at an example:
- Code: Select all
.--------------.-----------.-----------.
| 78 2 5 | 78 9 6 | 3 4 1 |
| 479 17 14 | 27 3 5 | 8 6 29 |
| 89 3 6 | 28 4 1 | 29 5 7 |
:--------------+-----------+-----------:
| 2 9 7 | 3 8 4 | 5 1 6 |
| 6 4 3 | 5 1 9 | 7 2 8 |
| 15 15 8 | 6 2 7 | 49 3 49 |
:--------------+-----------+-----------:
| 3 6 14 | 9 7 2 | 14 8 5 |
| 15 158 9 | 4 6 38 | 12 7 23 |
| 47 78 2 | 1 5 38 | 6 9 34 |
'--------------'-----------'-----------'
We're not interested in the obvious UR, or the normal XY-chains available. Instead, I'd like to know what's wrong (if anything) with these kinds of "confirming" XY-loops:
(8=7)r1c1 - (7=8)r1c4 - (8=2)r3c4 - (2=9)r3c7 - (9=4)r6c7 - (4=1)r7c7 - (1=4)r7c3 - (4=1)r2c3 - (1=7)r2c2 - (7=8)r1c1 => r1c1=8
(4=1)r2c3 - (1=7)r2c2 - (7=2)r2c4 - (2=9)r2c9 - (9=2)r3c7 - (2=1)r8c7 - (1=4)r7c7 - (4=1)r7c3 - (1=4)r2c3 => r2c3=4
(5=1)r6c2 - (1=5)r6c1 - (5=1)r8c1 - (1=2)r8c7 - (2=9)r3c7 - (9=2)r2c9 - (2=7)r2c4 - (7=1)r2c2 - (1=5)r6c2 => r6c2=5
They all yield correct results, but is there something fundamentally wrong with the logic (as the article seems to suggest) that I'm missing? I realize that I'm using the same strong link twice but does it matter? Is it just bad form or an actual flaw that might blow up in some other situation? Would it be more correct to write those same loops like this:
(7)r1c1 - (7=8)r1c4 - (8=2)r3c4 - (2=9)r3c6 - (9=4)r6c6 - (4=1)r7c7 - (1=4)r7c3 - (4=1)r2c3 - (1=7)r2c2 - (7)r1c1 => r1c1<>7 (=> r1c1=8)
(1)r2c3 - (1=7)r2c2 - (7=2)r2c4 - (2=9)r2c9 - (9=2)r3c7 - (2=1)r8c7 - (1=4)r7c7 - (4=1)r7c3 - (1)r2c3 => r2c3<>1 (=> r2c3=4)
(1)r6c2 - (1=5)r6c1 - (5=1)r8c1 - (1=2)r8c7 - (2=9)r3c7 - (9=2)r2c9 - (2=7)r2c4 - (7=1)r2c2 - (1)r6c2 => r6c2<>1 (=> r6c2=5)
In other words, are negative-proof discontinuous XY-loops ok (even though the notation partly hides their XY-nature)? I assume they must be per normal discontinuous Nice Loop rules. But, in that case the previous confirming logic must be true also because the discontinuity cell is a bivalue one. Therefore I'm assuming the real problem is just a formality (an illegally formed nice loop, perhaps?). Or, is the article talking about some entirely different situation and I'm missing the point?
More generally, I assume it's "illegal" to walk back in a nice loop, but does it actually break any logic if you do it near the end to return to the starting cell? I've been tempted to do that sometimes when I've started exploring a chain at some cell but the actual loop has formed elsewhere. In those cases I've played it safe and just used the smaller valid loop, but would be it terrible to walk back to the original starting cell using a few starting links backwards (imagine a loop with a tail)? I've never tried it and don't have an example at hand, but if I remember correctly, the inferences I thought I would get have worked out to be correct. Hardly necessary but is it possible if you really want a direct result in the original starting cell? I think the situation in the "confirming" XY-loop is similar, except the walk-back chain is just one link.
The article says: "Fortunately, quantum mechanics does not extend to Sudoku logic, and one candidate cannot be true and false at the same time." I guess I'm asking: why not?