
Cracking Minesweeper with Z3 SMT Solver - iou
https://yurichev.com/blog/minesweeper/
======
dino463
I wrote a language some time ago exploring the use of SAT solvers for these
types of problems, trying to make writing solvers easy to reason about, never
quite took off, but here's what the minesweeper solution looked like:
[http://sabrlang.org/mine/](http://sabrlang.org/mine/).

It basically translates the somewhat more complex rules into the simpler SAT
rules using minisat. However sometimes needed a generator in python to make
the rules :/. But still kinda nice to see it more visually, language looks
like this in the end:
[http://sabrlang.org/code/mine/source.txt](http://sabrlang.org/code/mine/source.txt).
It basically lists the requirements for middle, edge and corner blocks, than
says where those blocks are on the "board."

Kinda fun, though arguably somewhat restrictive. One of the more fun ones I
think is the rubiks cube:
[http://sabrlang.org/rubik/](http://sabrlang.org/rubik/).

~~~
rw
How does this contrast with Answer Set Programming (using e.g. clasp)?

~~~
dino463
They are similar, although SABR tends to be more verbose as it keeps a
polynomial relationship between size of SABR programs and the underlying SAT.
It can in some ways be easier to reason about, but that's sort of in the eye
of the beholder. In the past I've prototyped simple examples in SABR then
written a generator in python for the full program.

Here's a great resource for those interested in constraint programming:
[http://www.hakank.org](http://www.hakank.org)

Sudoku examples: SABR:
[http://www.hakank.org/sabr/sudoku.tb](http://www.hakank.org/sabr/sudoku.tb)

ASP:
[http://www.hakank.org/answer_set_programming/sudoku.lp](http://www.hakank.org/answer_set_programming/sudoku.lp)

There's the built in construct of transitions which isn't in this example that
is preloaded into SABR, but one could easily enough write the restraints
required for this in clasp.

SABR envisions the universe as the "Board" and it has a given size consisting
of elements and each element can have a specific state as defined by
"Symbols". Then you can build on that to say what is legal for a theoretical
set of elements, and how that set can transform over time, then you can define
which of the Board elements correspond to the defined theoretical set.

Its way more opinionated than most other constraint programming languages,
which can be mind bendy.

------
ronilan
Here we go again. Someone says "minesweeper". I shamelessly plug my js
implementation:
[http://www.ronilan.com/bugsweeper/](http://www.ronilan.com/bugsweeper/) Don't
ask me why.

P.S - it's with bugs instead of mines just because fontawesome didn't have
mines. No puns intended.

~~~
tzs
I've got one too [1]. Your's looks much nicer than mine. I'm just an
occasional dabbler in JavaScript, so it is not surprising that mine is crude.

I wrote that after reading this HN discussion [2] where someone was describing
how they interview. They set the candidate up with a good JS development/test
environment that the candidate is comfortable with, and ask them to implement
as much of Minesweeper as they can in one hour. They also said no one has ever
finished in that one hour.

As expected, I did not come anywhere near doing it in an hour. Wall time was
about 7 hours, but I was doing other things during that, so it was about 4
hours working on Minesweeper. About an hour of that was testing and stumbling
around the Mac character viewer trying to find good characters for bombs,
flags, and such.

I'm kind of surprised no one has done it for the interviewer in an hour.

As I said I'm only a JS dabbler. Basically, every couple of years or so I'll
have to do a little bit of basic JavaScript to do some simple DOM manipulation
or form validation. That's just enough to keep me sufficiently aware of JS
that I can at least do some reasonable guessing and googling.

I'd expect an actual JS programmer to be much faster than me.

[1]
[https://github.com/tzs/interview_minesweeper](https://github.com/tzs/interview_minesweeper)

[2]
[https://news.ycombinator.com/item?id=10752564](https://news.ycombinator.com/item?id=10752564)

~~~
voltagex_
I think I'd panic if I got that question in an interview. Where do you start
with that? What are the first steps? How did you know what to Google?

~~~
nitrogen
It sounds like a test of your ability to abstract, componentize, and
prioritize. Here's a possible approach to this sort of problem:

Read a brief summary of whatever you are implementing, even if you are already
familiar. This will help you understand the breadth of the problem.

Try to list in very broad terms the data structures you will need to store the
state of the problem (e.g. for Minesweeper, a grid of tiles, and for each tile
some status). Don't worry about whether you are using a list or a vector/array
or sparse or dense matrices, just be as generic as possible.

List in very broad terms the logic of the problem. What states exist, what are
the beginning/ending conditions (start/playing/win/loss), very roughly how
states transition, etc. Again, avoid detail.

Identify the inputs and outputs of the problem, very broadly (e.g. user input,
display for game board -- no mention of mouse, keyboard, HTML, or whatever).

Cycle through these phases a few times until they seem to agree.

From there, go wherever your brain takes you, progressively filling in details
of your design. You probably still shouldn't start coding.

For a 1hr exercise, let's assume you've used 15 minutes for the design phase.
Now you can begin coding. Start with the very core of the problem, writing
data structures and logic around those data structures. Then get some way of
displaying them and manipulating them so you can debug with feedback.

With a roughly functioning core, start filling in the rest of the design.
Focus on what makes the biggest functional difference with the least effort
first, if at all possible, but again, follow your brain. Try not to pick fonts
before you've got everything running. Go piece by piece, until time is up.

\--

As for what to Google, you'll need to know how to interface with your
problem's input and output systems (like a browser), and maybe how to run
timers or store your particular data structure, but most of the work is
design, not research.

\--

For a personal story, several years ago I failed a similar test in an
interview. They asked, "How would you make an elevator?" I got lost in the
details like what type of screw terminal to use for electrical contacts, and
only later realized the value of prioritizing layers of abstraction. Breadth-
first search, not depth-first, if you think of a problem space as a graph.

------
iaw
This makes me wonder:

Is there a strategy such that it can consistently solve every minesweeper
configuration?

I always assumed that the 50/50 guess was unavoidable on some maps but I don't
know if that's true.

~~~
Pxtl
Consider the basic state - the minesweeper board is built around your first
move. If your first move is not a void, but has one or more adjacent mines,
all you see to start is a single open square with a number. At that point
you're already making a guess. Even if it's a 1, you're guessing about your
next move.

~~~
saghm
Not to mention that the first move itself is a guess. I'm not sure about all
variants, but certainly on the classic Windows minesweeper there were times
that my first click was a bomb.

~~~
M4v3R
That was definitely not possible on Windows XP version of Minesweeper, they
would regenerate the board if you clicked on a bomb in the background and used
that one instead.

~~~
Drdrdrq
It was definitely not like that on Win98.

~~~
saghm
Definitely not like what the parent said, or what I said? Maybe I'm
remembering that rather than XP

------
luckyt
I wrote a Minesweeper solver a while ago, it uses backtracking search with
decent results:
[https://luckytoilet.wordpress.com/2012/12/23/2125/](https://luckytoilet.wordpress.com/2012/12/23/2125/)

Now I wonder how does the performance of this SAT solver compare to
backtracking? Which one deals better with situations where guessing is
required?

~~~
amluto
In Stanford CS221, one of the assignments was to write a Minesweeper solver
using backtracking and various propagation techniques. It was exact and ran
fairly quickly. Once you've enumerated all possible solutions, you can throw
heuristics at guessing.

------
partycoder
The thing is that in minesweeper you cannot win in a deterministic way.
Sometimes you will lose in your first move.

~~~
probablybroken
I always thought it would be fun to make a version that was soluble every time
by making the system reveal extra tiles as required to always allow you to
continue play without guessing. I personally found the situations where half
way through a large game you were forced to guess quite frustrating. Maybe
deep down I just don't like minesweeper ;)

~~~
detaro
Or alternatively one that if you click a tile with the best chance in a
unsolvable situation always solves in your favor, adjusting bomb locations as
necessary.

------
doublec
There's an implementation of a Minesweeper solver in Mozart/Oz too "Playing
the Minesweeper with Constraints":
[https://www.info.ucl.ac.be/~pvr/minesweeper.pdf](https://www.info.ucl.ac.be/~pvr/minesweeper.pdf)

------
kebman
Great project! Made me remember making a Fallout 2 Computer Console cracker in
Perl. Great fun!

~~~
eon1
I don't remember any hacking in FO2 (at least, not minigamed).. Do you mean 3?

