# taw's blog

## Saturday, November 26, 2016

### Solving Self-Referential Aptitude Test with ruby and Z3

Previously, I wrote how to solve sudoku and nonograms with ruby and Z3.

Let's try something much more devious and complex - the Self-Referential Aptitude Test, a 20-question multiple-choice test where answers depend on other answers.

By the way the test is totally solvable by pen and paper, I'd say it should take about half an hour, and no excessive backtracking.

There's going to be a lot of code, but hopefully with my explanations it will all turn to be straightforward.

### Basic structure

First, let's setup basic structure. Z3.Int("Q1") to Z3.Int("Q20") will be answers to the questions, with A being 1,  B being 2, C being 3, D being 4, and E being 5. I'm going to create a Hash storing question symbols, as we'll be using them a lot.

To make the code read more like DSL than a blob of math, I'm going to define a lot of helpers.

answer(10, "A") is expression stating that answer to question 10 is A.

define(10, "A") { expression } means that answer to question 10 can be A only if expression is true. Note that this is implication, not equality, as multiple answers could be valid - see question 19 for most extreme example.

``````require "z3"
class SelfRefPuzzleSolver
def initialize
@solver = Z3::Solver.new
@q = {}
(1..20).each do |i|
@q[i] = Z3.Int("Q#{i}")
@solver.assert @q[i] >= 1
@solver.assert @q[i] <= 5
end
end

@q[question_number] == " ABCDE".index(a)
end

def define(question_number, a)
end

raise "Something went wrong" unless @solver.satisfiable?
model = @solver.model
(1..20).each do |i|
end
end

def solve!
# Question code goes here
end
end``````

Code below goes inside solve! method, except for helpers which all go inside the class.

Many questions require counting how many times something is true - mainly how many questions have specific answer.

For this we convert Z3 Booleans (which are true or false) into 1s and 0s using statement.ite(if_true, if_false), and then add 1s together with Z3.Add. Z3.Add and friends aren't anything special, and you might just as well use .inject(&:+) etc. if you prefer.

``````  def count(*statements)
end

end``````

### Question 1

The first question whose answer is B is question
(A) 1
(B) 2
(C) 3
(D) 4
(E) 5

It's important to notice that answer like D means not only that "Q4 is B", but also that "Q1, Q2, and Q3 are not B".

``````    define(1, "A"){  answer(1, "B") }

### Question 2

The only two consecutive questions with identical answers are questions
(A) 6 and 7
(B) 7 and 8
(C) 8 and 9
(D) 9 and 10
(E) 10 and 11

There are shorter ways to write this answer, but let's just do it in the most straightforward way.
(1..20).each_cons(2) from ruby standard library generates a list of consecutive pairs. Then answer can be A if the only pair that's equal is 6 and 7, and so on.

``````    question_pairs = (1..20).each_cons(2)
define(2, "A") {
Z3.And(*question_pairs.map{|i,j| (q[i] == q[j]) == (i == 6) })
}
define(2, "B") {
Z3.And(*question_pairs.map{|i,j| (q[i] == q[j]) == (i == 7) })
}
define(2, "C") {
Z3.And(*question_pairs.map{|i,j| (q[i] == q[j]) == (i == 8) })
}
define(2, "D") {
Z3.And(*question_pairs.map{|i,j| (q[i] == q[j]) == (i == 9) })
}
define(2, "E") {
Z3.And(*question_pairs.map{|i,j| (q[i] == q[j]) == (i == 10) })
}``````

### Question 3

The number of questions with the answer E is
(A) 0
(B) 1
(C) 2
(D) 3
(E) 4

Since we have a helper for counting how many of specific answer we've got, it's very straighforward:

``````    define(3, "A") { count_answers("E") == 0 }
define(3, "B") { count_answers("E") == 1 }
define(3, "C") { count_answers("E") == 2 }
define(3, "D") { count_answers("E") == 3 }
define(3, "E") { count_answers("E") == 4 }``````

### Question 4

The number of questions with the answer A is
(A) 4
(B) 5
(C) 6
(D) 7
(E) 8

This is basically the same as previous question.

``````    define(4, "A") { count_answers("A") == 4 }
define(4, "B") { count_answers("A") == 5 }
define(4, "C") { count_answers("A") == 6 }
define(4, "D") { count_answers("A") == 7 }
define(4, "E") { count_answers("A") == 8 }``````

### Question 5

The answer to this question is the same as the answer to question
(A) 1
(B) 2
(C) 3
(D) 4
(E) 5

Nothing complex here. Z3 has no problem with defining Q5 in terms of Q5.

``````    define(5, "A") { q[5] == q[1] }
define(5, "B") { q[5] == q[2] }
define(5, "C") { q[5] == q[3] }
define(5, "D") { q[5] == q[4] }
define(5, "E") { q[5] == q[5] }``````

### Question 6

The answer to question 17 is
(A) C
(B) D
(C) E
(D) none of the above
(E) all of the above

A small trick here is that "none of the above" means "Q17 is A or B", and "all of the above" is nonsensical.

``````    define(6, "A") { answer(17, "C") }
define(6, "B") { answer(17, "D") }
define(6, "C") { answer(17, "E") }
define(6, "E") { false }``````

### Question 7

Alphabetically, the answer to this question and the answer to the following question are
(A) 4 apart
(B) 3 apart
(C) 2 apart
(D) 1 apart
(E) the same

Answers are already encoded as numbers, so just subtracting them will get us alphabetic distance, but it has direction (like 3 or -3) while we want just magnitude (3 in both cases). We could either get absolute value with small helper or just spell out both cases. I'll use abs helper function.

``````  def abs(x)
(x >= 0).ite(x, -x)
end``````

Then the code becomes:

``````    distance_7_8 = abs(q[7] - q[8])
define(7, "A") { distance_7_8 == 4 }
define(7, "B") { distance_7_8 == 3 }
define(7, "C") { distance_7_8 == 2 }
define(7, "D") { distance_7_8 == 1 }
define(7, "E") { distance_7_8 == 0 }``````

But this alternative isn't too bad:

``````    distance_7_8 = q[7] - q[8]
define(7, "A") { (distance_7_8 == 4) | (distance_7_8 == -4) }
define(7, "B") { (distance_7_8 == 3) | (distance_7_8 == -3) }
define(7, "C") { (distance_7_8 == 2) | (distance_7_8 == -2) }
define(7, "D") { (distance_7_8 == 1) | (distance_7_8 == -1) }
define(7, "E") { distance_7_8 == 0 }``````

### Question 8

The number of questions whose answers are vowels is
(A) 4
(B) 5
(C) 6
(D) 7
(E) 8

We could just add A and E answers, or pass custom condition to count helper:

``````    count_vowel_answers = count_answers("A") + count_answers("E")
define(8, "A") { count_vowel_answers == 4 }
define(8, "B") { count_vowel_answers == 5 }
define(8, "C") { count_vowel_answers == 6 }
define(8, "D") { count_vowel_answers == 7 }
define(8, "E") { count_vowel_answers == 8 }``````

### Question 9

The next question with the same answer as this one is question
(A) 10
(B) 11
(C) 12
(D) 13
(E) 14

Just as with question 1, we need 1+2+3+4+5 implications to cover it fully. This has similar structure to question 1, so maybe we could use a helper to DRY it up a bit. Here's we'll use the explicit version.

``````    define(9, "A") { Z3.And(q[9] == q[10]) }
define(9, "B") { Z3.And(q[9] != q[10],
q[9] == q[11]) }
define(9, "C") { Z3.And(q[9] != q[10],
q[9] != q[11],
q[9] == q[12]) }
define(9, "D") { Z3.And(q[9] != q[10],
q[9] != q[11],
q[9] != q[12],
q[9] == q[13]) }
define(9, "E") { Z3.And(q[9] != q[10],
q[9] != q[11],
q[9] != q[12],
q[9] != q[13],
q[9] == q[14]) }``````

### Question 10

The answer to question 16 is
(A) D
(B) A
(C) E
(D) B
(E) C

Completely straightforward.

``````    define(10, "A") { answer(16, "D") }
define(10, "B") { answer(16, "A") }
define(10, "C") { answer(16, "E") }
define(10, "D") { answer(16, "B") }
define(10, "E") { answer(16, "C") }``````

### Question 11

The number of questions preceding this one with the answer B is
(A) 0
(B) 1
(C) 2
(D) 3
(E) 4

This is same as counting E and A, except we limit the count to first 10 questions.

``````    preceding_B_answers = count_answers("B", 1..10)
define(11, "A") { preceding_B_answers == 0 }
define(11, "B") { preceding_B_answers == 1 }
define(11, "C") { preceding_B_answers == 2 }
define(11, "D") { preceding_B_answers == 3 }
define(11, "E") { preceding_B_answers == 4 }``````

### Question 12

The number of questions whose answer is a consonant is
(A) an even number
(B) an odd number
(C) a perfect square
(D) a prime
(E) divisible by 5

This definitely demands a helper, and since we know counts will be between 0 and 20, it's just easier to list possible values instead of trying to come with formulas for "perfect square" or "prime".

``````    consonant_answers = count_answers("B") +
define(12, "A") {
equals_one_of(consonant_answers, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
}
define(12, "B") {
equals_one_of(consonant_answers, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19)
}
define(12, "C") {
equals_one_of(consonant_answers, 0, 1, 4, 9, 16)
}
define(12, "D") {
equals_one_of(consonant_answers, 2, 3, 5, 7, 11, 13, 17, 19)
}
define(12, "E") {
equals_one_of(consonant_answers, 0, 5, 10, 15, 20)
}``````

### Question 13

The only odd-numbered problem with answer A is
(A) 9
(B) 11
(C) 13
(D) 15
(E) 17

This of course means that problems 1, 3, 5, 7, and 19 can't have answer A.
We can use Range#step to generate list of odd numbers, and use similar code to question 2.

``````    odd_questions = 1.step(19, 2)
define(13, "A") {
Z3.And(*odd_questions.map{|i| answer(i, "A") == (i == 9) })
}
define(13, "B") {
Z3.And(*odd_questions.map{|i| answer(i, "A") == (i == 11) })
}
define(13, "C") {
Z3.And(*odd_questions.map{|i| answer(i, "A") == (i == 13) })
}
define(13, "D") {
Z3.And(*odd_questions.map{|i| answer(i, "A") == (i == 15) })
}
define(13, "E") {
Z3.And(*odd_questions.map{|i| answer(i, "A") == (i == 17) })
}``````

The alternative is to reverse definitions and assert that answer(9, "A") is true if and only if answer(13, "A") etc., while all unlisted odd-numbered answers are not A. In this case we need to use ==, not implies.

``````    @solver.assert !answer(1, "A")

### Question 14

The number of questions with answer D is
(A) 6
(B) 7
(C) 8
(D) 9
(E) 10
Same as questions 3 and 4.
``````    define(14, "A") { count_answers("D") == 6 }
define(14, "B") { count_answers("D") == 7 }
define(14, "C") { count_answers("D") == 8 }
define(14, "D") { count_answers("D") == 9 }
define(14, "E") { count_answers("D") == 10 }``````

### Question 15

The answer to question 12 is
(A) A
(B) B
(C) C
(D) D
(E) E
Straightforward:
``````    define(15, "A") { answer(12, "A") }
define(15, "B") { answer(12, "B") }
define(15, "C") { answer(12, "C") }
define(15, "D") { answer(12, "D") }
define(15, "E") { answer(12, "E") }``````

### Question 16

The answer to question 10 is
(A) D
(B) C
(C) B
(D) A
(E) E
Also straightforward:
``````    define(16, "A") { answer(10, "D") }
define(16, "B") { answer(10, "C") }
define(16, "C") { answer(10, "B") }
define(16, "D") { answer(10, "A") }
define(16, "E") { answer(10, "E") }``````

### Question 17

The answer to question 6 is
(A) C
(B) D
(C) E
(D) none of the above
(E) all of the above
Same logic as question 6, and notice how they refer to each other:
``````    define(17, "A") { answer(6, "C") }
define(17, "B") { answer(6, "D") }
define(17, "C") { answer(6, "E") }
define(17, "E") { false }``````

### Question 18

The number of questions with answer A equals the number of questions
(A) B
(B) C
(C) D
(D) E
(E) none of the above
We can use the same helper function, and only last case is different:
``````    define(18, "A") { count_answers("A") == count_answers("B") }
define(18, "E") {
Z3.And(
)
}``````

### Question 19

The answer to this question is:
(A) A
(B) B
(C) C
(D) D
(E) E
This is a bit of a fake question as it's obvious that every answer works.

Of course if you want, you can add this do nothing code anyway:

``````    define(19, "A") { answer(19, "A") }
define(19, "B") { answer(19, "B") }
define(19, "C") { answer(19, "C") }
define(19, "D") { answer(19, "D") }
define(19, "E") { answer(19, "E") }``````

### Question 20

Standardized test is to intelligence as barometer is to
(A) temperature (only)
(B) wind-velocity (only)
(C) latitude (only)
(D) longitude (only)
(E) temperature, wind-velocity, latitude, and longitude
That's the only question that requires outside knowledge and the answer is obviously E.

We could list it the same way as other questions:

``````    define(20, "A") { false }
define(20, "B") { false }
define(20, "C") { false }
define(20, "D") { false }
define(20, "E") { true }``````

Or much more concisely:
``    @solver.assert answer(20, "E")``

### Z3 is the ultimate TDD

If you wanted to write solver for Self-Referential Aptitude Test, you'd need to write something quite close to code above - syntax would be a bit different, and it would be slightly cleaner as you could use ruby values instead of Z3 expressions, but it wouldn't be much more code.

And then you'd need to write the solver itself - but here we don't have to - with fully specified problem Z3 generates the answer. The only thing we wrote were tests and a few lines to print the solution. That's as TDD as it gets.

``````Q 1: D
Q 2: A
Q 3: D
Q 4: B
Q 5: E
Q 6: D
Q 7: D
Q 8: E
Q 9: D
Q10: A
Q11: B
Q12: A
Q13: D
Q14: B
Q15: A
Q16: D
Q17: B
Q18: A
Q19: B
Q20: E``````

### Z3 can do a lot more

I said it before, but I'll repeat it again - Z3 is great for a lot more than just solving puzzles. Puzzles simply make the best tutorial material.

If you're interested, you can find more examples in gem's repository. Or just try it yourself.