static bool test_existential_quantification(int n_cls, int n_vars, int n_qvar, int rseed)
{
rand = new Random(rseed);
int [] [] clauses = new int [n_cls][];
for (int i = 0; i < n_cls; ++i)
{
clauses[i] = randclause(1, n_vars + 1);
}
int [] qvars = new int [n_qvar];
for (int i = 1; i <= n_qvar; ++i)
{
qvars[i - 1] = i + i;
}
SATSolver solver = new SATSolver();
solver.SetNumVariables(n_vars);
solver.ConvertVarsToPI();
int s = build_irregular_struct(solver, clauses, 1);
int q1 = solver.expand_exist_quantify(s, qvars);
//int q2 = solver.enum_exist_quantify(s, qvars);
int q2 = solver.enum_exist_quantify_smart(s, qvars);
SATStatus status = solver.solve();
sharp_assert(status == SATStatus.SATISFIABLE);
int notequ = solver.Xor(q1, q2);
solver.Constraint(notequ);
status = solver.Solve();
sharp_assert(status == SATStatus.UNSATISFIABLE);
return(true);
}
public static bool test_small_model()
{
SATSolver solver = new SATSolver();
int a = solver.NthPI(0);
int b = solver.NthPI(1);
int c = solver.NthPI(2);
int d = solver.NthPI(3);
int ab = solver.And(a, b);
int cd = solver.And(c, d);
int abcd = solver.And(ab, cd);
int constraint = solver.Constraint(abcd);
solver.Solve();
int [] model = solver.FindSmallModel();
print_model(model);
solver.ReleaseConstraint(constraint);
int not_abcd = solver.Not(abcd);
constraint = solver.Constraint(not_abcd);
solver.Solve();
model = solver.FindSmallModel();
print_model(model);
solver.ReleaseConstraint(constraint);
int e = solver.CreatePI();
int f = solver.CreatePI();
int exf = solver.Xor(e, f);
int and_exf_abcd = solver.And(exf, abcd);
constraint = solver.Constraint(and_exf_abcd);
solver.Solve();
model = solver.FindSmallModel();
print_model(model);
solver.ReleaseConstraint(constraint);
int not_and_exf_abcd = solver.Not(and_exf_abcd);
constraint = solver.Constraint(not_and_exf_abcd);
solver.Solve();
model = solver.FindSmallModel();
print_model(model);
solver.ReleaseConstraint(constraint);
return(true);
}
static bool test_interpolant_clauses(int n_vars, int n_cls, int span, int randseed)
{
rand = new Random(randseed);
int [] [] a_clauses;
int [] [] b_clauses;
a_clauses = new int [n_cls][];
b_clauses = new int [n_cls][];
for (int i = 0; i < n_cls; ++i)
{
a_clauses[i] = randclause(1, n_vars / 2 + span);
}
for (int i = 0; i < n_cls; ++i)
{
b_clauses[i] = randclause(n_vars / 2 - span, n_vars + 1);
}
SATSolver solver = new SATSolver();
solver.SetNumVariables(n_vars);
int a_gid = solver.AllocGID();
int b_gid = solver.AllocGID();
//1. Test if A is satisfiable
for (int i = 0; i < n_cls; ++i)
{
solver.AddClause(a_clauses[i], a_gid);
}
if (solver.Solve() != SATStatus.SATISFIABLE)
{
Write("A SAT");
return(false);
}
solver.DeleteGroup(a_gid);
//1. Test if B is satisfiable
for (int i = 0; i < n_cls; ++i)
{
solver.AddClause(b_clauses[i], b_gid);
}
if (solver.Solve() != SATStatus.SATISFIABLE)
{
Write("B SAT");
return(false);
}
//3. Generate Interpolant
a_gid = solver.AllocGID();
for (int i = 0; i < n_cls; ++i)
{
solver.AddClause(a_clauses[i], a_gid);
}
Write("Interpolant ");
int interpolant = solver.GenInterpolantFromClauseGroups(a_gid, b_gid);
if (interpolant == -1)
{
Write("AB SAT");
return(false);
}
solver.Reference(interpolant);
//now test IB Unsatisfiable
Write("IB ");
solver.DeleteGroup(a_gid);
sharp_assert(solver.stats.num_orig_clauses == n_cls);
int c = solver.Constraint(interpolant);
SATStatus status = solver.Solve();
if (status != SATStatus.UNSATISFIABLE)
{
sharp_assert(false);
}
//4. test AI Satisfiable
Write("AI ");
solver.DeleteGroup(b_gid);
a_gid = solver.AllocGID();
for (int i = 0; i < n_cls; ++i)
{
solver.AddClause(a_clauses[i], a_gid);
}
status = solver.Solve();
if (status != SATStatus.SATISFIABLE)
{
assert(false);
}
//5. test AI' Unsat (i.e. A=>I)
Write("AI' ");
solver.ReleaseConstraint(c);
c = solver.Constraint(solver.Not(interpolant));
status = solver.Solve();
if (status != SATStatus.UNSATISFIABLE)
{
sharp_assert(false);
}
solver.ReleaseConstraint(c);
return(true);
}
static bool test_interpolant_structure(int n_vars, int n_cls, int span, int randseed)
{
rand = new Random(randseed);
int [] [] a_clauses;
int [] [] b_clauses;
a_clauses = new int [n_cls][];
b_clauses = new int [n_cls][];
for (int i = 0; i < n_cls; ++i)
{
a_clauses[i] = randclause(1, n_vars / 2 + span);
}
for (int i = 0; i < n_cls; ++i)
{
b_clauses[i] = randclause(n_vars / 2 - span, n_vars + 1);
}
SATSolver solver = new SATSolver();
solver.SetNumVariables(n_vars);
solver.ConvertVarsToPI();
int s_a = build_struct(solver, a_clauses);
int s_b = build_struct(solver, b_clauses);
solver.Reference(s_a);
solver.Reference(s_b);
//1. Test if A is satisfiable
int c_a = solver.Constraint(s_a);
if (solver.Solve() != SATStatus.SATISFIABLE)
{
Write("A SAT");
return(false);
}
solver.ReleaseConstraint(c_a);
//2. Test if B is satisfiable
int c_b = solver.Constraint(s_b);
if (solver.Solve() != SATStatus.SATISFIABLE)
{
Write("B SAT");
return(false);
}
solver.ReleaseConstraint(c_b);
//now get interpolant I
Write("Interpolant ");
int interpolant = solver.GenInterpolantFromSignals(s_a, s_b);
if (interpolant == -1)
{
Write("AB SAT");
return(false);
}
solver.Reference(interpolant);
//3. test IB Unsatisfiable
Write("IB ");
c_b = solver.Constraint(s_b);
int c_i = solver.Constraint(interpolant);
SATStatus status = solver.Solve();
if (status != SATStatus.UNSATISFIABLE)
{
sharp_assert(false);
}
solver.ReleaseConstraint(c_b);
//4. test AI Satisfiable
Write("AI ");
c_a = solver.Constraint(s_a);
status = solver.Solve();
if (status != SATStatus.SATISFIABLE)
{
assert(false);
}
//5. test AI' Unsat (i.e. A=>I)
Write("AI' ");
solver.ReleaseConstraint(c_i);
solver.Constraint(solver.Not(interpolant));
status = solver.Solve();
if (status != SATStatus.UNSATISFIABLE)
{
sharp_assert(false);
}
return(true);
}
public static void log_execution(string [] args)
{
SATSolver solver = new SATSolver();
if (args.Length != 1)
{
WriteLine("Simple SAT Solver using the C# interface");
WriteLine("Usage: sharpSat CNF_file ");
return;
}
FileInfo file = new FileInfo(args[0]);
StreamReader input = file.OpenText();
string line;
IntVector nodes = new IntVector(4);
while (true)
{
line = input.ReadLine();
if (line == null)
{
break;
}
string [] tokens = line.Split(new char[] { ' ', '\t' });
int index = 0;
string token = getToken(tokens, ref index);
int k = int.Parse(token);
token = getToken(tokens, ref index);
sharp_assert(token == "=");
token = getToken(tokens, ref index);
if (token == "INIT_VARS")
{
solver.SetNumVariables(k);
solver.ConvertVarsToPI();
nodes.resize(k + k + 2);
for (int i = 0; i < k + k + 2; ++i)
{
nodes[i] = i;
}
}
else if (token == "CONSTRAINT")
{
solver.Constraint(nodes[k]);
SATStatus status = solver.Solve();
if (status == SATStatus.UNSATISFIABLE)
{
WriteLine("UNSAT");
}
else
{
WriteLine("SAT");
}
}
else if (token == "PI")
{
continue;
}
else if (token == "CL")
{
IntVector lits = new IntVector(4);
token = getToken(tokens, ref index);
while (token != null)
{
lits.push_back(int.Parse(token));
token = getToken(tokens, ref index);
}
solver.AddClause(lits.ToArray());
}
else if (token == "AND")
{
token = getToken(tokens, ref index);
int i1 = int.Parse(token);
token = getToken(tokens, ref index);
int i2 = int.Parse(token);
int r = solver.And(nodes[i1], nodes[i2]);
if (nodes.size() < k + 2)
{
nodes.resize(k + 2);
}
nodes[k] = r;
nodes [k ^ 1] = (r ^ 1);
}
else if (token == "XOR")
{
token = getToken(tokens, ref index);
int i1 = int.Parse(token);
token = getToken(tokens, ref index);
int i2 = int.Parse(token);
int r = solver.Xor(nodes[i1], nodes[i2]);
if (nodes.size() < k + 1)
{
nodes.resize(k + 1);
}
nodes[k] = r;
nodes [k ^ 1] = (r ^ 1);
}
else
{
fatal("Unrecognized Symbol");
}
}
}