The Chaos Computer Club (CCC) is having its yearly conference starting today. It’s a madhouse here, which is great for ideas, so I have been having this rush of ideas implemented. First off, it seems that complex problems with few variables are way too difficult to solve even with distributed solving. I have been trying to solve some difficult problems, but no matter how much computer power I throw at them (and I have been throwing >2 years’ worth, with >300 CPU cores running), not much progress is being made. I have lately been attributing this “failure” to one prime problem: lack of expressiveness.

Basically, I feel like the SAT solver is trying to express some complex functions with learnt clauses. For instance, an adder. However, the only thing it can do, is describe this function using a Karnaugh Map. Anybody who has tried to express an adder without introducing new variables is well aware that that’s a *difficult* task. So, we need new variables. This is the point where some collaboration I have lately been doing with some researchers (Laurent Simon and George Katsirelos) comes into play. Following their footsteps, I realised we could introduce new definitions, using a new targeting method we developed. So, I did just that, and here is a nice result for a very difficult problem:

`num: 7750 lit1: 741 lit2: 4641`

num: 2339 lit1: 1396 lit2: 1670

num: 2172 lit1: -719 lit2: 741

num: 2169 lit1: -719 lit2: 4641

num: 2061 lit1: 1669 lit2: 1670

num: 2010 lit1: 1670 lit2: 1734

num: 1973 lit1: 1670 lit2: 1882

...

time: 2.53 seconds

Where literals `lit1`

and `lit2`

are both present in `num`

number of clauses. So, for example literals `741`

and `4641`

are both present in 7750 clauses. Which means that if we introduce a definition with a new variable `10000`

:

`10000 = 741 OR 4641`

(which requires 2 binary clauses and one 3-long clause) we can remove 7750 literals from the problem, while *increasing* the propagation potential. For example, if there was a clause

`741 OR 4641 OR 2 OR 3 = TRUE`

we can make it into

`10000 OR 2 OR 3 = TRUE`

What I have just described is a (dumb) version of extended resolution, the holy grail that many have tried and only few have succeeded at. It is a holy grail because it is provably more powerful than normal resolution, but heuristics of when and how to introduce the new variables have been difficult to come up with. What I have just described at least would reduce the problem size: removing e.g. ~7700 literals while only introducing 3 short clauses seems to worth the effort. It might not simulate extended resolution (ER), but it should speed up the solving, while giving a (lowly) shot at ER.

PS: If all of this sounds mad, that may be attributed to the ~500 people around me loudly developing and discussing issues ranging from peer-to-peer routing to FPGA programming