Пример #1
0
propt::resultt qbf_skizzo_coret::prop_solve()
{
  // sKizzo crashes on empty instances
  if(no_clauses()==0)
    return P_SATISFIABLE;

  {
    std::string msg=
      "Skizzo: "+
      i2string(no_variables())+" variables, "+
      i2string(no_clauses())+" clauses";
    messaget::status(msg);
  }

  std::string result_tmp_file="sKizzo.out";

  {
    std::ofstream out(qbf_tmp_file.c_str());

    // write it
    break_lines=false;
    write_qdimacs_cnf(out);
  }

  std::string options="";

  // solve it
  system(("sKizzo -log "+qbf_tmp_file+
         options+
         " > "+result_tmp_file).c_str());

  bool result=false;

  // read result
  {
    std::ifstream in(result_tmp_file.c_str());

    bool result_found=false;
    while(in)
    {
      std::string line;

      std::getline(in, line);

      if(line!="" && line[line.size()-1]=='\r')
        line.resize(line.size()-1);

      if(line=="The instance evaluates to TRUE.")
      {
        result=true;
        result_found=true;
        break;
      }
      else if(line=="The instance evaluates to FALSE.")
      {
        result=false;
        result_found=true;
        break;
      }
    }

    if(!result_found)
    {
      messaget::error("Skizzo failed: unknown result");
      return P_ERROR;
    }
  }

  remove(result_tmp_file.c_str());
  remove(qbf_tmp_file.c_str());

  if(result)
  {
    messaget::status("Skizzo: TRUE");

    if(get_certificate())
      return P_ERROR;

    return P_SATISFIABLE;
  }
  else
  {
    messaget::status("Skizzo: FALSE");
    return P_UNSATISFIABLE;
  }
}
Пример #2
0
propt::resultt qbf_qubet::prop_solve()
{
  // sKizzo crashes on empty instances
  if(no_clauses()==0)
    return P_SATISFIABLE;

  {
    messaget::status() << 
      "QuBE: " <<
      no_variables() << " variables, " <<
      no_clauses() << " clauses" << eom;
  }

  std::string qbf_tmp_file="qube.qdimacs";
  std::string result_tmp_file="qube.out";

  {
    std::ofstream out(qbf_tmp_file.c_str());

    // write it
    write_qdimacs_cnf(out);
  }

  //std::string options=" --equivalences=0";
  std::string options="";

  // solve it
  int res=system(("QuBE "+qbf_tmp_file+
         options+
         " > "+result_tmp_file).c_str());
  assert(0 == res);

  bool result=false;

  // read result
  {
    std::ifstream in(result_tmp_file.c_str());

    bool result_found=false;
    while(in)
    {
      std::string line;

      std::getline(in, line);

      if(line!="" && line[line.size()-1]=='\r')
        line.resize(line.size()-1);

      if(line=="s cnf 0")
      {
        result=true;
        result_found=true;
        break;
      }
      else if(line=="s cnf 1")
      {
        result=false;
        result_found=true;
        break;
      }
    }

    if(!result_found)
    {
      messaget::error() << "QuBE failed: unknown result" << eom;
      return P_ERROR;
    }
  }

  if(result)
  {
    messaget::status() << "QuBE: TRUE" << eom;
    return P_SATISFIABLE;
  }
  else
  {
    messaget::status() << "QuBE: FALSE" << eom;
    return P_UNSATISFIABLE;
  }

  return P_ERROR;
}
Пример #3
0
propt::resultt qbf_qube_coret::prop_solve()
{
  if(no_clauses()==0)
    return resultt::P_SATISFIABLE;

  {
    messaget::status() << "QuBE: "
      << no_variables() << " variables, "
      << no_clauses() << " clauses" << eom;
  }

  std::string result_tmp_file="qube.out";

  {
    std::ofstream out(qbf_tmp_file.c_str());

    // write it
    break_lines=false;
    write_qdimacs_cnf(out);
  }

  std::string options="";

  // solve it
  int res=system((
    "QuBE "+options+" "+qbf_tmp_file+" > "+result_tmp_file).c_str());
  assert(0==res);

  bool result=false;

  // read result
  {
    std::ifstream in(result_tmp_file.c_str());

    bool result_found=false;
    while(in)
    {
      std::string line;

      std::getline(in, line);

      if(line!="" && line[line.size()-1]=='\r')
        line.resize(line.size()-1);

      if(line[0]=='V')
      {
        mp_integer b(line.substr(2).c_str());
        if(b<0)
          assignment[integer2unsigned(b.negate())]=false;
        else
          assignment[integer2unsigned(b)]=true;
      }
      else if(line=="s cnf 1")
      {
        result=true;
        result_found=true;
        break;
      }
      else if(line=="s cnf 0")
      {
        result=false;
        result_found=true;
        break;
      }
    }

    if(!result_found)
    {
      messaget::error() << "QuBE failed: unknown result" << eom;
      return resultt::P_ERROR;
    }
  }

  int remove_result=remove(result_tmp_file.c_str());
  if(remove_result!=0)
  {
    messaget::error() << "Remove failed: " << std::strerror(errno) << eom;
    return resultt::P_ERROR;
  }

  remove_result=remove(qbf_tmp_file.c_str());
  if(remove_result!=0)
  {
    messaget::error() << "Remove failed: " << std::strerror(errno) << eom;
    return resultt::P_ERROR;
  }

  if(result)
  {
    messaget::status() << "QuBE: TRUE" << eom;
    return resultt::P_SATISFIABLE;
  }
  else
  {
    messaget::status() << "QuBE: FALSE" << eom;
    return resultt::P_UNSATISFIABLE;
  }
}
Пример #4
0
propt::resultt qbf_quantort::prop_solve()
{
  {
    std::string msg=
      "Quantor: "+
      i2string(no_variables())+" variables, "+
      i2string(no_clauses())+" clauses";
    messaget::status(msg);
  }

  std::string qbf_tmp_file="quantor.qdimacs";
  std::string result_tmp_file="quantor.out";

  {
    std::ofstream out(qbf_tmp_file.c_str());

    // write it
    write_qdimacs_cnf(out);
  }
  
  //std::string options=" --equivalences=0";
  std::string options="";

  // solve it
  system(("quantor "+qbf_tmp_file+
         options+
         " -o "+result_tmp_file).c_str());

  bool result=false;
  
  // read result
  {
    std::ifstream in(result_tmp_file.c_str());
    
    bool result_found=false;
    while(in)
    {
      std::string line;

      str_getline(in, line);
      
      if(line!="" && line[line.size()-1]=='\r')
        line.resize(line.size()-1);

      if(line=="s TRUE")
      {
        result=true;
        result_found=true;
        break;
      }
      else if(line=="s FALSE")
      {
        result=false;
        result_found=true;
        break;
      }
    }

    if(!result_found)
    {
      messaget::error("Quantor failed: unknown result");
      return P_ERROR;
    }    
  }

  if(result)
  {
    messaget::status("Quantor: TRUE");
    return P_SATISFIABLE;
  }
  else
  {
    messaget::status("Quantor: FALSE");
    return P_UNSATISFIABLE;
  }
 
  return P_ERROR;
}