最早使用cmt的minisat改进版求解器4——vsids-master-1\adaptvsids

知识来源

文章：

　　https://link.springer.com/chapter/10.1007/978-3-319-26287-1_14

代码：

　　https://github.com/ezulkosk/vsids

位置：

　　\VISDS-solvers\vsids-master-1\vsids-master-1\adaptvsids\core

---

 

技术要点：

在冲突分析阶段考察动态增加（新生成）的学习子句的LBD波动情况，设置窗口期（目前采用的是全窗口）计算LBD的移动平均值；当前学习子句的lbd值与移动平均lbd进行比较，决定变元碰撞的增加量的大小。具体算法如下：

 int lbd_val = lbd(learnt_clause);       //计算新增学习子句的lbd值
 lbd_ema = lbd_ema_decay * lbd_ema + (1 - lbd_ema_decay) * lbd_val;//整体LBD的移动平均值
 if (lbd_val >= lbd_ema) {               //第一种情况
     decays++;                           //正常普通衰减模式使用次数计数
     varDecayActivity(var_decay);        //正常模式下var_decay为0.85，变元活跃度碰撞增加较快
 } else {                                //第二种情况：学习子句lbd低于移动平均
     thresh_decays++;                    // 学习子句lbd低于移动平均lbd时，单独计数
     varDecayActivity(var_thresh_decay); //var_thresh_decay为0.95，变元活跃度碰撞增加较慢
 }

 

代码分析

---

 

Solver.h

class Solver {
  ...
    // Statistics: (read-only member variable)
    //
    uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts, backjumps, decays, thresh_decays;
    uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;

107...
    long double         lbd_ema;
    long double         lbd_ema_decay;
...
200     vec<bool>           lbd_seen;
...
    int      lbd(vec<Lit>& c);
...
};

inline int Solver::lbd(vec<Lit>& c) {
    int lbd = 0;
    for (int i = 0; i < c.size(); i++) {
        int lvl = level(var(c[i]));
        if (!lbd_seen[lvl]) {
            lbd_seen[lvl] = true;
            lbd++;
        }
    }
    for (int i = 0; i < c.size(); i++) {
        int lvl = level(var(c[i]));
        lbd_seen[lvl] = false;
    }
    return lbd;
}

Solver.cpp

static DoubleOption  opt_lbd_ema_decay 
(_cat, "lbd-ema-decay",    "The lbd decay factor", 0.95,DoubleRange(0, false, 1, false));

Solver::Solver() :
...50   , lbd_ema            (0)
  , lbd_ema_decay      (opt_lbd_ema_decay)  //取值0.95
{}

lbool Solver::search(int nof_conflicts)
{
    assert(ok);
    int         backtrack_level;
    int         conflictC = 0;
    vec<Lit>    learnt_clause;
    starts++;

    for (;;){
        CRef confl = propagate();
        if (confl != CRef_Undef){
            // CONFLICT
            conflicts++; conflictC++;
            if (decisionLevel() == 0) return l_False;

            learnt_clause.clear();
            analyze(confl, learnt_clause, backtrack_level);
            backjumps += decisionLevel() - backtrack_level;
            cancelUntil(backtrack_level);

            if (learnt_clause.size() == 1){
                uncheckedEnqueue(learnt_clause[0]);
            }else{
                CRef cr = ca.alloc(learnt_clause, true);
                learnts.push(cr);
                attachClause(cr);
                claBumpActivity(ca[cr]);
                uncheckedEnqueue(learnt_clause[0], cr);
            }

            int lbd_val = lbd(learnt_clause);
            lbd_ema = lbd_ema_decay * lbd_ema + (1 - lbd_ema_decay) * lbd_val;
            if (lbd_val >= lbd_ema) {
                decays++;
                varDecayActivity(var_decay);  //超出移动平均值，正常碰撞衰减因子0.85，活跃度增加块。
            } else {
                thresh_decays++;
                varDecayActivity(var_thresh_decay);  //在移动平均值范围内，衰减因子0.99，活跃度增加慢。
            }
            claDecayActivity();

            if (--learntsize_adjust_cnt == 0){
                learntsize_adjust_confl *= learntsize_adjust_inc;
                learntsize_adjust_cnt    = (int)learntsize_adjust_confl;
                max_learnts             *= learntsize_inc;

                if (verbosity >= 1)
                  ...
            }

        }else{
            // NO CONFLICT
            if (nof_conflicts >= 0 && conflictC >= nof_conflicts || !withinBudget()){
                // Reached bound on number of conflicts:
                progress_estimate = progressEstimate();
                cancelUntil(0);
                return l_Undef; }

            // Simplify the set of problem clauses:
            if (decisionLevel() == 0 && !simplify())
                return l_False;

            if (learnts.size()-nAssigns() >= max_learnts)
                // Reduce the set of learnt clauses:
                reduceDB();

            Lit next = lit_Undef;
            while (decisionLevel() < assumptions.size()){
                // Perform user provided assumption:
                Lit p = assumptions[decisionLevel()];
                if (value(p) == l_True){
                    // Dummy decision level:
                    newDecisionLevel();
                }else if (value(p) == l_False){
                    analyzeFinal(~p, conflict);
                    return l_False;
                }else{
                    next = p;
                    break;
                }
            }

            if (next == lit_Undef){
                // New variable decision:
                decisions++;
                next = pickBranchLit();

                if (next == lit_Undef)
                    // Model found:
                    return l_True;
            }

            // Increase decision level and enqueue 'next'
            newDecisionLevel();
            uncheckedEnqueue(next);
        }
    }
}

void Solver::analyze(CRef confl, vec<Lit>& out_learnt, int& out_btlevel)
{
    int pathC = 0;
    Lit p     = lit_Undef;

    // Generate conflict clause:
    //
    out_learnt.push();      // (leave room for the asserting literal)
    int index   = trail.size() - 1;

    do{
        assert(confl != CRef_Undef); // (otherwise should be UIP)
        Clause& c = ca[confl];

        if (c.learnt())
            claBumpActivity(c);

        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
            Lit q = c[j];

            if (!seen[var(q)] && level(var(q)) > 0){
                varBumpActivity(var(q));
                seen[var(q)] = 1;
                if (level(var(q)) >= decisionLevel())
                    pathC++;
                else
                    out_learnt.push(q);
            }
        }
        
        // Select next clause to look at:
        while (!seen[var(trail[index--])]);
        p     = trail[index+1];
        confl = reason(var(p));
        seen[var(p)] = 0;
        pathC--;

    }while (pathC > 0);
    out_learnt[0] = ~p;

    // Simplify conflict clause:
    //
    int i, j;
    out_learnt.copyTo(analyze_toclear);
    if (ccmin_mode == 2){
        uint32_t abstract_level = 0;
        for (i = 1; i < out_learnt.size(); i++)
            abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)

        for (i = j = 1; i < out_learnt.size(); i++)
            if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
                out_learnt[j++] = out_learnt[i];
        
    }else if (ccmin_mode == 1){
        for (i = j = 1; i < out_learnt.size(); i++){
            Var x = var(out_learnt[i]);

            if (reason(x) == CRef_Undef)
                out_learnt[j++] = out_learnt[i];
            else{
                Clause& c = ca[reason(var(out_learnt[i]))];
                for (int k = 1; k < c.size(); k++)
                    if (!seen[var(c[k])] && level(var(c[k])) > 0){
                        out_learnt[j++] = out_learnt[i];
                        break; }
            }
        }
    }else
        i = j = out_learnt.size();

    max_literals += out_learnt.size();
    out_learnt.shrink(i - j);
    tot_literals += out_learnt.size();

    // Find correct backtrack level:
    //
    if (out_learnt.size() == 1)
        out_btlevel = 0;
    else{
        int max_i = 1;
        // Find the first literal assigned at the next-highest level:
        for (int i = 2; i < out_learnt.size(); i++)
            if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
                max_i = i;
        // Swap-in this literal at index 1:
        Lit p             = out_learnt[max_i];
        out_learnt[max_i] = out_learnt[1];
        out_learnt[1]     = p;
        out_btlevel       = level(var(p));
    }
    
    for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;    // ('seen[]' is now cleared)
}

    对变元碰撞增量的的动态调整，只会对下一次冲突分析时起作用（见此代码段的第22行）。届时参与新的学习子句的变元碰撞会使用调整后的增量值。

    个人理解：

        （1）调整值使用是滞后的；

        （2）原学习子句lbd考察时的子句变元与参与碰撞的此时的变元可能已经不同了，这种调整是泛泛调整，没有具体针对性。