Part One: Two Key Principles
This article is part one of a series of articles on advanced play for the game Turing Machine. You can find all the articles along with some important disclaimers here.
We’re going to start off this series with a fairly simple puzzle, using four verifiers and Easy difficulty. As we look at this example, we’re going to see two very important principles which are going to help us to solve this puzzle quickly.
Here’s a picture of the four verifiers we’ll be using, and if you want to play along at home, use game code #A4B IA3 on the Turing Machine website.
Average Play
I’ll start by giving an example of how an average Turing Machine player might approach this setup.
Typically, most players start with a random code before narrowing down their options after testing some verifiers. We’ll do that too.
Maybe in the first round you randomly pick code 532, and you test against verifiers 5, 8 and 17. You find out that blue is odd, that there is at least one 1 and that there isn’t exactly one even. We don’t have lots of information and we would have liked more ticks, but we keep going.
At this point you might think more carefully about the next code; we decide to include at least one 1 so we can try and find out how many 1s there are, and we don’t use exactly one even since we know that isn’t true. If we can show that yellow is equal to purple that’ll really help us, so we settle on code 311, and we test against verifier 17 and get another cross. At this point we pause; we now know there are at least two evens, and blue is odd, so those evens are yellow and purple. We also have at least one 1, and since 1 is odd, it has to be blue. So blue is 1 and we’ve got our first number solved. We test against verifier 13, but we get a cross, so our plan to show that yellow is equal to purple has failed. Now we know that yellow and purple are a 2 and a 4, but we’ll need to go another round with a different code to test verifier 13 and find out which is which.
For the third and final round, we just need a code with yellow and purple being different. We use code 124 (since we know blue is 1 and yellow and purple are both even), we test against verifier 13, and we get a true. So yellow is less than purple, and we used the correct code for this round anyway. We save our last two tests and finish out the round, getting the code correct in six tests.
Now, you might be thinking, “That wasn’t so bad. Six tests is pretty good (and was the machine score), and if you’d been a bit luckier you might have got it in four, which I’d always be happy with.”
But here’s the rub: What if I told you that I could solve this puzzle in one guaranteed test? And then what if I told you that you could too?
Advanced Play
Okay, that was a bit of a #HumbleBrag, and if I’m going to make such a bold claim, I need to be able to prove it.
So, we’re going to work through the example again. Obviously you know the code now, and so do I, but none of the logical steps that we take are going to rely on that knowledge. We’re essentially pretending that we don’t know the code.
And the first thing we’re going to do is look at the verifiers. For advanced Turing Machine players, a lot of the work is done before we even make our first test.
We start by looking at verifier 17 and thinking about the number of evens. And as we do so, we’re going to need the first of our two important principles:
PRINCIPLE 1: NO VERIFIER CAN BE REDUNDANT
This is a very important rule which underpins advanced Turing Machine play. It’s so important, in fact, that they included it in the rulebook not once but twice, on pages 4 and 6.
This principle is essentially telling us that every verifier must be needed, and there’s an important implication: no verifier is allowed to tell us all the information that another verifier would.
So, let’s look at verifier 17 again, and consider if there are three evens. If that’s the case, blue must be even, since all of the numbers are, and there would also be no 1s. So this would make both verifiers 5 and 8 redundant. So we can remove this as a possibility. Similarly, if there are zero evens, blue would have to be odd and verifier 5 would be made redundant, so we must have exactly 1 or 2 evens.
We can actually do the same with verifier 8 and the option of three 1s; this is something most Turing Machine players are sort of able to intuit by themselves without really understanding why, but it’s harder for verifiers that are not based on the number of occurrences of a specific digit.
Right now, the only information this principle can give us is that we don’t have three 1s and we don’t have three evens or zero evens. But remember the principle, because it’s going to be very important as we continue.
Some players like to mark off options as they’re removed, which you could do on your notesheet if you add lines to match the number of options. But I’ll do it here by super-imposing some crosses onto our pictures.
However, it’s now time to look at our second principle:
PRINCIPLE 2: THE CORRECT CODE WILL BE UNIQUE
This important principle only appears once in the rulebook (on page 6) because it is probably obvious to most players; Turing Machine wouldn’t be a very good deduction game if it wasn’t.
But while the principle itself may seem obvious, this principle again has an important implication: each colour must be uniquely definable.
For example, let’s think about the blue number. What information will we be able to determine about blue from each verifier?
Verifier 5 can tell us the parity (evenness/oddness) of blue. Verifier 17 can tell us the same thing, although by principle 1 verifier 17 won’t tell us about the parity of blue and only the parity of the other colours. Verifier 13 is unable to ever tell us anything about blue. So we will need to use verifier 8 to help us define blue.
Let’s assume that verifier 5 tells us blue is even. The only information we can then get from verifier 8 is that blue is not 1, and we’ll be left with two options: either blue is 2 or blue is 4, and no verifier will ever be able to tell us which. In other words, the code will not be unique. This isn’t allowed by the rules of the game. All of this is true only if blue is even, which means this is an impossible situation, and blue must be odd.
Now, this puts us in a good position given that we haven’t made a single test yet. But we’re not done. We know that blue is odd, but Turing Machine by its very construction has 2 possible even numbers and 3 possible odd numbers. This is no coincidence. If verifier 8 tells us that blue is not equal to 1, we’ll still have two possibilities: blue could be a 3 or a 5, with no way to uniquely define it.
So this means blue must be equal to 1.
Now, we should pause here, because we need to make sure we’re being clear about what we are and aren’t saying. You might be thinking to yourself, “Hang on, you said before that no verifier could be redundant. But if verifier 8 tells us that blue is 1, doesn’t that make verifier 5 redundant?” And the answer is no. You see, verifier 8 can only tell us about the number of 1s which occur, and not which colours are a 1. By combining it with verifier 5, we were able to logically deduce that blue is one of those 1s. But verifier 8 might be telling us there are more 1s, and even if there is only 1, we would still need verifier 5 to determine that blue was an odd and therefore could be the 1.
When we use Principle 1 to narrow down the options and therefore deduce what a verifier could be, our deductions do not necessarily make verifiers redundant. Principle 1 only applies when a verifier makes another verifier redundant, and this is an important distinction.
While we’re talking about verifier 8, let’s continue down that line of thinking. We already know we have at least one 1 (blue), and there can’t be three 1s, so there are exactly one 1 or two 1s. Let’s assume that there are two 1s. Since blue is one of them, yellow or purple will be the other, with yellow and purple not equal, and we could use verifier 13 to work out which. But the remaining colour will still need to be uniquely defined, and how could we do that? Verifier 5 certainly won’t help us, verifier 8 tells us it’s greater than 1 which we already know, and the same is true of verifier 13. So we only have verifier 17 left to us. But of the numbers greater than 1, there are two even options and two odd options. So we won’t be able to uniquely define this colour.
So two 1s leads to a logical impossibility, meaning we can’t have exactly two 1s. The only option left to us is one 1, which is blue. So we have a blue 1 with yellow and purple both greater than 1. We’re almost ready to actually make a test, I think.
But before we do that, look again at verifier 17.
We already know there are not zero evens or three evens. Let’s assume that there is exactly one even. Since blue is odd, this means yellow and purple are of a different parity, i.e. one of them is even and one of them is odd. Obviously this means they can’t be equal, so verifier 13 can tell us which is larger.
But of the possible numbers 2, 3, 4, and 5, knowing which one is larger will not help us uniquely define either number. If yellow is larger, we could have yellow 3 and purple 2, or yellow 4 and purple 3, or yellow 5 and purple 2, or just to make sure we’ve caught all the options, yellow 5 and purple 4. There won’t be any remaining verifiers to help us narrow this down, so this is definitely impossible.
With exactly one even removed as an option, we know there are two evens and they are yellow and purple. Now if verifier 13 tells us they are equal, we won’t be able to define them between 2 and 4. So they are different even numbers, and we can use verifier 13 to work out which is which.
So now we really are ready to make a test. We pick a code with yellow and purple not equal, and we may as well pick blue as 1 since we know this is true. Maybe this time we use the code 142 (since we’re pretending we don’t actually know the code), we test verifier 13, and we get a false. This means yellow is not greater than purple, so the code must be 124.
Now, remember Disclaimer 4; I’m not expecting you to sit down to a real-time game of Turing Machine and ask your friends to wait ten minutes while you just make a few notes. But if you’re playing online, you’ll get a bit of time to do this, and even if you’re not, these kind of exercises will train your brain to spot at least some of these patterns in a real-time game.
Next week, we’ll look at another puzzle in classic mode, but we’ll make it harder by using six verifiers and the Standard difficulty. If you’d like to get a head start on trying out these advanced principles, the code for the setup we’ll be using is #B63 YQ1 N.
