The current algorithm for choosing branching variable is as follows: compute scores for all literals, compute scores for each variable based on the score of its two polarities (i.e. positive literal and negative literal) and then choose a variable at random from those with highest scores.

The score for a literal is computed by propagating the literal and checking modified clauses (not including satisfying clauses). For every modified clause of length L and for each literal in that clause the score of the literal is increased with

`α`^{L} if clause is a disjunction of literals or

`β`^{L} if the clause is a XOR gate.

The score for a variable is computed using a formula from

March_eq:

`S(b) = 1024 * S'(b) * S'(-b) + S'(b) + S'(-b)` where

`S(b)` is the score for variable

`b`,

`S'(b)` and

`S'(-b)` are scores for literals

`b` and

`-b`.

The question is: what values should

`α` and

`β` take? To find out this I choose a training set made of a few instances and run the solver for a few hundreds different values of

`α` and

`β`. I got quite a few timeouts, but eventually I got many values to compute a interesting heat map (see below: yellow is bad, blue is good). From this I learned a few things: values for

`α` under

`0.25` are awful,

`β` has little effects on the results (notice the vertical bars).

With the best found values for

`α` and

`β` I ran the solver on a more extensive set of instances too see which instances were negatively affected and extended my initial set. This time I set the possible values for

`α` in interval

`[0.5,1)` though, retrospectively I think I shouldn't have.

Notice a new red vertical band around 0.8 which was dark blue in the previous heat map. Again,

`β` had little effect. Notice that up to now I eliminated two ranges for

`α`:

`[0.00,0.25)` and

`[0.75,1.00)`.

With the new found best values I run the solver on my usual set of instances (a subset of easy and medium instances from SAT09 Competition). The good news is that STRUCTure was able to solve a few more instances with some speedup on others. Many instances were not affected. The bad news is that one instance that was included in my training set timed out. The difference between training and testing was the number of CPU used (16 versus 8) which suggests that the solution was on a branch searched by one of the extra CPUs. Two things to remember: 1) Run the training set on fewer CPUs. 2) first polarity searched is relevant.

In conclusion I think that heat maps are a good way to figured out bad ranges for parameters but it is hard to find exceptional values.

**Update**: Here is another heat map which I used for SAT Competition 2011. This time I included the timeouts and the heatmap seems to provide a more clear picture of interaction of the two coefficients tested. The x-axis is

`α` described above. On y-axis are the values for

`γ` which defines for an implication

`u → v` how much the

`v`'s score influences

`u`'s score. There are 4 regions distinguishable on the heat map from which good values for

`α` and

`γ` can be concluded:

`0 ≤ α < 0.4` and

`0 ≤ γ < 0.3`.