private Variable ConvertEmptyset(out MSOFormula <BDD> psi)
{
var X = MkNewVar2();
psi = new MSOIsEmpty <BDD>(X);
return(X);
}
public override MSOFormula ToMSO(FreshGen fg, string V)
{
int c = fg.get();
string x = "_x_" + c.ToString();
string y = "_y_" + c.ToString();
string X = "_X_" + c.ToString();
int i = str.Length - 1;
string z_i, z_im;
MSOFormula phi = null;
phi = new MSOLabel("z0", str[0]);
while (i > 0)
{
z_i = "z" + i.ToString();
z_im = "z" + (i - 1).ToString();
phi = new MSOExistsFO(z_i, new MSOAnd(new MSOSucc(z_im, z_i),
new MSOAnd(new MSOLabel(z_i, str[i]), phi)));
i--;
}
return(new MSOForallFO("z0", new MSOIff(new MSOBelong("z0", V), phi)));
}
public void MSO_Succ_Z3A()
{
var z3Context = new Context();
var S = z3Context.IntSort;
var solver = new Z3BoolAlg(z3Context, S);
Func <int, BoolExpr> IsPos = (i => z3Context.MkEq(solver.x, z3Context.MkInt(i)));
var x = new Variable("x", true);
var y = new Variable("y", true);
var x_is_0 = new MSOPredicate <BoolExpr>(IsPos(0), x);
var y_is_1 = new MSOPredicate <BoolExpr>(IsPos(1), y);
//every 0 is immediately followed by a 1
MSOFormula <BoolExpr> phi = Forall(x, Implies(x_is_0, Exists(y, And(Succ(x, y), y_is_1))));
//var ca = new CartesianAlgebraBDD<BoolExpr>(solver);
var aut = phi.GetAutomaton(solver);
//aut.ShowGraph();
//Automaton<BoolExpr> aut1 = Automaton<BoolExpr>.ProjectSecond<BDD>(aut);
var expected_automaton = Automaton <BoolExpr> .Create(solver, 0, new int[] { 0 },
new Move <BoolExpr>[] {
Move <BoolExpr> .Create(0, 0, z3Context.MkNot(IsPos(0))),
Move <BoolExpr> .Create(0, 1, IsPos(0)),
Move <BoolExpr> .Create(1, 0, IsPos(1))
});
bool equiv = aut.IsEquivalentWith(expected_automaton);
//Assert.IsTrue(equiv, "the automata must be equivalent");
}
public MSOFormula <BDD> ToMSO()
{
if (header != MonaHeader.M2LSTR)
{
throw new NotSupportedException("unsopprted header " + header);
}
if (declarations.Exists(d => (d.kind != Mona.MonaDeclKind.formula || d.kind != Mona.MonaDeclKind.var1 || d.kind != Mona.MonaDeclKind.var2)))
{
throw new NotSupportedException("unsopprted declaration (other than formula or var1 or var2)");
}
if (vars1.Exists(d => (d.univs != null || d.varwhere.where != null)))
{
throw new NotSupportedException("unsopprted var declaration (with universe or where condition)");
}
int fvcount = vars1.Count + vars2.Count;
MSOFormula <BDD> psi = null;
foreach (var decl in declarations)
{
if (decl.kind == MonaDeclKind.formula)
{
var phi = ConvertFormula(((MonaFormulaDecl)decl).formula, MapStack <string, MonaParam> .Empty);
psi = (psi == null ? phi : new MSOAnd <BDD>(psi, phi));
}
}
throw new NotImplementedException();
}
Automaton<T> CreateAutomaton3<T>(Func<int, T> f, int bitWidth, IBooleanAlgebra<T> Z)
{
Func<int, Variable, MSOPredicate<T>> pred = (i, s) => new MSOPredicate<T>(f(i), s);
MSOFormula<T> phi = new MSOTrue<T>();
// x1<x2<x3<x4...
for (int index = 1; index < bitWidth; index++)
{
MSOFormula<T> phi1 = new MSOLt<T>(V1("x" + (index - 1)), V1("x" + index));
phi = new MSOAnd<T>(phi, phi1);
}
// bi(xi)
for (int index = 0; index < bitWidth; index++)
{
MSOFormula<T> phi1 = pred(index, V1("x" + index));
phi = new MSOAnd<T>(phi, phi1);
}
// exists forall...
for (int index = 0; index < bitWidth; index++)
{
if (index % 2 == 0)
phi = new MSOExists<T>(V1("x" + index), phi);
else
phi = new MSOForall<T>(V1("x" + index), phi);
}
var aut = phi.GetAutomaton(Z);
return aut;
}
private Variable ConvertSet(MonaExpr set, MapStack <string, MonaParam> locals, out MSOFormula <BDD> psi)
{
if (set.NrOfSubexprs == 0)
{
return(ConvertEmptyset(out psi));
}
MSOFormula <BDD> disj = null;
Variable x = MkNewVar1();
Variable X = MkNewVar2();
for (int i = 0; i < set.NrOfSubexprs; i++)
{
MonaExpr t = set[i];
if (t.symbol.Kind == Tokens.RANGE)
{
MSOFormula <BDD> from_psi;
Variable from = ConvertTerm1(t[0], locals, out from_psi);
MSOFormula <BDD> to_psi;
Variable to = ConvertTerm1(t[1], locals, out to_psi);
MSOFormula <BDD> range = AddConstraints(from_psi, from, to_psi, to,
new MSOAnd <BDD>(new MSOLe <BDD>(from, x), new MSOLe <BDD>(x, to)));
if (disj == null)
{
disj = range;
}
else
{
disj = new MSOOr <BDD>(disj, range);
}
}
else
{
MSOFormula <BDD> y_psi;
Variable y = ConvertTerm1(t, locals, out y_psi);
MSOFormula <BDD> elem = new MSOEq <BDD>(x, y);
if (y_psi != null)
{
elem = new MSOExists <BDD>(y, new MSOAnd <BDD>(y_psi, elem));
}
if (disj == null)
{
disj = elem;
}
else
{
disj = new MSOOr <BDD>(disj, elem);
}
}
}
var pred = new MSOForall <BDD>(x, new MSOEquiv <BDD>(new MSOIn <BDD>(x, X), disj));
psi = pred;
return(X);
}
private static MSOFormula<BDD> AddConstraints(MSOFormula<BDD> psi_x, Variable x, MSOFormula<BDD> psi_y, Variable y, MSOFormula<BDD> res)
{
if (psi_y != null)
res = new MSOExists<BDD>(y, new MSOAnd<BDD>(psi_y, res));
if (psi_x != null)
res = new MSOExists<BDD>(x, new MSOAnd<BDD>(psi_x, res));
return res;
}
//LTL over finite traces
private static void AutomatarkMsoFormulasTest(string inputDir, string outFile)
{
Console.WriteLine("fileName , generic-bdd, product");
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(outFile))
{
var files = new List <string>(Directory.EnumerateFiles(inputDir, "*.mona", SearchOption.AllDirectories));
files.Sort((s1, s2) => cmp(s1, s2));
foreach (string fileName in files)
{
string contents = File.ReadAllText(fileName);
MonaProgram pgm1 = MonaParser.Parse(contents);
phi = pgm1.ToMSO();
var bv7 = new CharSetSolver(BitWidth.BV7);
bddSolver = new BDDAlgebra <BDD>(bv7);
var sw = new Stopwatch();
sw.Restart();
Thread t = new Thread(BDDSolver);
t.Start();
long t1 = 5000;
if (!t.Join(TimeSpan.FromSeconds(5)))
{
t.Abort();
t1 = 5000;
}
else
{
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
bv7 = new CharSetSolver(BitWidth.BV7);
cartSolver = new CartesianAlgebraBDD <BDD>(bv7);
sw.Restart();
t = new Thread(CartesianSolver);
t.Start();
long t2 = 5000;
if (!t.Join(TimeSpan.FromSeconds(5)))
{
t.Abort();
t2 = 5000;
}
else
{
sw.Stop();
t2 = sw.ElapsedMilliseconds;
}
//if (t2 > 5000)
// t2 = 5000;
file.WriteLine(fileName + "," + (double)t1 / numTests + "," + (double)t2 / numTests);
Console.WriteLine(fileName + "," + (double)t1 / numTests + "," + (double)t2 / numTests);
}
}
}
public MSOFormula <BDD> ToMSO()
{
if (header == MonaHeader.M2LTREE || header == MonaHeader.WS2S)
{
throw new NotSupportedException("unsopprted header " + header);
}
foreach (var d in declarations)
{
if (d.kind != Mona.MonaDeclKind.formula &&
d.kind != Mona.MonaDeclKind.var1 &&
d.kind != Mona.MonaDeclKind.var2 &&
d.kind != Mona.MonaDeclKind.constant &&
d.kind != Mona.MonaDeclKind.pred &&
d.kind != Mona.MonaDeclKind.macro)
{
throw new NotImplementedException("declaration: " + d.ToString());
}
MonaVarDecl vd = d as MonaVarDecl;
if (vd != null && (vd.univs != null || vd.varwhere.where != null))
{
throw new NotImplementedException("var declaration (with universe or where condition): " + vd.ToString());
}
}
int fvcount = vars1.Count + vars2.Count;
MSOFormula <BDD> psi = null;
foreach (var decl in declarations)
{
if (decl.kind == MonaDeclKind.formula)
{
var phi = ConvertFormula(((MonaFormulaDecl)decl).formula, MapStack <string, MonaParam> .Empty);
if (psi == null)
{
psi = phi;
}
else
{
psi = psi & phi;
}
}
else if (decl.kind == MonaDeclKind.pred || decl.kind == MonaDeclKind.macro)
{
var pd = decl as MonaPredDecl;
predMap[pd.name.text] = ConvertFormula(pd.formula, MapStack <string, MonaParam> .Empty.Push(pd.pmap));
}
}
if (psi == null)
{
throw new ArgumentException("formula is missing from the mona program");
}
return(psi);
}
public override MSOFormula ToMSO(FreshGen fg, string v)
{
switch (op)
{
case PDLStringPosOperator.FirstOcc:
{
int i = str.Length - 1;
string z_i, z_im;
MSOFormula phi = null; //new MSOForallFO("x", new MSOEqual("x", "x"));
//TODO make sure input string is non empty that is i/=0
phi = new MSOLabel("z0", str[0]);
while (i > 0)
{
z_i = "z" + i.ToString();
z_im = "z" + (i - 1).ToString();
phi = new MSOExistsFO(z_i, new MSOAnd(new MSOSucc(z_im, z_i),
new MSOAnd(new MSOLabel(z_i, str[i]), phi)));
i--;
}
return(new MSOAnd(new MSOForallFO("z0", new MSOIf(phi, new MSOLessEq(v, "z0"))),
new MSOExistsFO("z0", new MSOAnd(phi, new MSOEqual(v, "z0")))));
}
case PDLStringPosOperator.LastOcc:
{
int i = str.Length - 1;
string z_i, z_im;
MSOFormula phi = null; //new MSOForallFO("x", new MSOEqual("x", "x"));
//TODO make sure input string is non empty that is i/=0
phi = new MSOLabel("z0", str[0]);
while (i > 0)
{
z_i = "z" + i.ToString();
z_im = "z" + (i - 1).ToString();
phi = new MSOExistsFO(z_i, new MSOAnd(new MSOSucc(z_im, z_i),
new MSOAnd(new MSOLabel(z_i, str[i]), phi)));
i--;
}
return(new MSOAnd(new MSOForallFO("z0", new MSOIf(phi, new MSOLessEq("z0", v))),
new MSOExistsFO("z0", new MSOAnd(phi, new MSOEqual(v, "z0")))));
}
default: throw new PDLException("undefined operator");
}
}
private static MSOFormula <BDD> AddConstraints(MSOFormula <BDD> psi_x, Variable x, MSOFormula <BDD> psi_y, Variable y, MSOFormula <BDD> res)
{
if (psi_y != null)
{
res = new MSOExists <BDD>(y, new MSOAnd <BDD>(psi_y, res));
}
if (psi_x != null)
{
res = new MSOExists <BDD>(x, new MSOAnd <BDD>(psi_x, res));
}
return(res);
}
static Automaton <T> CreateAutomaton2 <T>(Func <int, T> f, int bitWidth, IBooleanAlgebra <T> Z)
{
Func <int, string, MSOPredicate <T> > pred = (i, s) => new MSOPredicate <T>(f(i), new Variable(s, true));
MSOFormula <T> phi = new MSOFalse <T>();
for (int index = 0; index < bitWidth; index++)
{
MSOFormula <T> phi1 = pred(index, "var");
phi1 = new MSOExists <T>(new Variable("var", true), phi1);
phi = new MSOOr <T>(phi, phi1);
}
phi = new MSOExists <T>(new Variable("var", true), phi);
var aut = phi.GetAutomaton(Z);
return(aut);
}
Automaton<T> CreateAutomaton2<T>(Func<int, T> f, int bitWidth, IBooleanAlgebra<T> Z)
{
Func<int, Variable, MSOPredicate<T>> pred = (i, s) => new MSOPredicate<T>(f(i), s);
MSOFormula<T> phi = new MSOFalse<T>();
for (int index = 0; index < bitWidth; index++)
{
MSOFormula<T> phi1 = pred(index, V1("var"));
phi1 = new MSOExists<T>(V1("var"), phi1);
phi = new MSOOr<T>(phi, phi1);
}
phi = new MSOExists<T>(V1("var"), phi);
var aut = phi.GetAutomaton(Z);
return aut;
}
Automaton <T> CreateAutomaton3 <T>(Func <int, T> f, int bitWidth, IBooleanAlgebra <T> Z)
{
Func <int, string, MSOPredicate <T> > pred = (i, s) => new MSOPredicate <T>(f(i), s);
MSOFormula <T> phi = new MSOTrue <T>();
// x1<x2<x3<x4...
for (int index = 1; index < bitWidth; index++)
{
MSOFormula <T> phi1 = new MSOLt <T>("x" + (index - 1), "x" + index);
phi = new MSOAnd <T>(phi, phi1);
}
// bi(xi)
for (int index = 0; index < bitWidth; index++)
{
MSOFormula <T> phi1 = pred(index, "x" + index);
phi = new MSOAnd <T>(phi, phi1);
}
// exists forall...
for (int index = 0; index < bitWidth; index++)
{
if (index % 2 == 0)
{
phi = new MSOExistsFo <T>("x" + index, phi);
}
else
{
phi = new MSOForallFo <T>("x" + index, phi);
}
}
Assert.IsTrue(phi.IsWellFormedFormula());
var aut = phi.GetAutomaton(Z);
return(aut);
}
static Automaton <T> CreateAutomaton3 <T>(Func <int, T> f, int bitWidth, IBooleanAlgebra <T> Z)
{
Func <int, string, MSOPredicate <T> > pred = (i, s) => new MSOPredicate <T>(f(i), new Variable(s, true));
MSOFormula <T> phi = new MSOTrue <T>();
// x1<x2<x3<x4...
for (int index = 1; index < bitWidth; index++)
{
MSOFormula <T> phi1 = new MSOLt <T>(new Variable("x" + (index - 1), true), new Variable("x" + index, true));
phi = new MSOAnd <T>(phi, phi1);
}
// bi(xi)
for (int index = 0; index < bitWidth; index++)
{
MSOFormula <T> phi1 = pred(index, "x" + index);
phi = new MSOAnd <T>(phi, phi1);
}
// exists forall...
for (int index = 0; index < bitWidth; index++)
{
if (index % 2 == 0)
{
phi = new MSOExists <T>(new Variable("x" + index, true), phi);
}
else
{
phi = new MSOForall <T>(new Variable("x" + index, true), phi);
}
}
var aut = phi.GetAutomaton(Z);
return(aut);
}
public void MSO_Succ_Z3A()
{
var z3Context = new Context();
var S = z3Context.IntSort;
var solver = new Z3BoolAlg(z3Context, S);
Func <int, BoolExpr> IsInt = (i => z3Context.MkEq(solver.x, z3Context.MkInt(i)));
var x_is_0 = new MSOPredicate <BoolExpr>(IsInt(0), "x");
var y_is_1 = new MSOPredicate <BoolExpr>(IsInt(1), "y");
//every 0 is immediately followed by a 1
MSOFormula <BoolExpr> phi = Forall("x", Implies(x_is_0, Exists("y", And(Succ("x", "y"), y_is_1))));
var aut = phi.GetAutomaton(solver);
var expected_automaton = Automaton <BoolExpr> .Create(solver, 0, new int[] { 0 },
new Move <BoolExpr>[] {
Move <BoolExpr> .Create(0, 0, z3Context.MkNot(IsInt(0))),
Move <BoolExpr> .Create(0, 1, IsInt(0)),
Move <BoolExpr> .Create(1, 0, IsInt(1))
});
bool equiv = aut.IsEquivalentWith(expected_automaton, solver);
Assert.IsTrue(equiv, "the automata must be equivalent");
}
private MSOFormula<BDD> ConvertPredApp(MonaPredApp predApp, MapStack<string, MonaParam> locals)
{
var predDef = predMap[predApp.symbol.text];
var predDecl = (MonaPredDecl)globals[predApp.symbol.text];
int k = predDecl.parameters.Count;
if (k != predApp.NrOfSubexprs)
throw new ArgumentException("invalid call of " + predDecl.name);
if (k == 0)
return predDef;
var newVars = new Variable[k];
Dictionary<string, Variable> substitution = new Dictionary<string, Variable>();
var argPreds = new MSOFormula<BDD>[k];
var argVars = new Variable[k];
for (int i = 0; i < k; i++)
{
if (predDecl.parameters[i].kind != MonaParamKind.var1 && predDecl.parameters[i].kind != MonaParamKind.var2)
throw new NotImplementedException("parameter kind " + predDecl.parameters[i].kind.ToString());
MSOFormula<BDD> argPreds_i;
Variable argVars_i;
if (predDecl.parameters[i].kind == MonaParamKind.var1)
{
argVars_i = ConvertTerm1(predApp[i], locals, out argPreds_i);
if (argPreds_i == null)
{
var tmp1 = MkNewVar1();
argPreds_i = new MSOEq<BDD>(tmp1, argVars_i);
argVars_i = tmp1;
}
}
else
{
argVars_i = ConvertTerm2(predApp[i], locals, out argPreds_i);
if (argPreds_i == null)
{
var tmp2 = MkNewVar2();
argPreds_i = new MSOEq<BDD>(tmp2, argVars_i);
argVars_i = tmp2;
}
}
argPreds[i] = argPreds_i;
argVars[i] = argVars_i;
substitution[predDecl.parameters[i].Token.text] = argVars_i;
}
MSOFormula<BDD> psi = predDef.SubstituteVariables(substitution);
for (int i = k - 1; i >= 0; i--)
psi = new MSOExists<BDD>(argVars[i], argPreds[i] & psi);
return psi;
}
private Variable ConvertSet(MonaExpr set, MapStack<string, MonaParam> locals, out MSOFormula<BDD> psi)
{
if (set.NrOfSubexprs == 0)
return ConvertEmptyset(out psi);
MSOFormula<BDD> disj = null;
Variable x = MkNewVar1();
Variable X = MkNewVar2();
for (int i=0; i < set.NrOfSubexprs; i++)
{
MonaExpr t = set[i];
if (t.symbol.Kind == Tokens.RANGE)
{
MSOFormula<BDD> from_psi;
Variable from = ConvertTerm1(t[0], locals, out from_psi);
MSOFormula<BDD> to_psi;
Variable to = ConvertTerm1(t[1], locals, out to_psi);
MSOFormula<BDD> range = AddConstraints(from_psi, from, to_psi, to,
new MSOAnd<BDD>(new MSOLe<BDD>(from, x), new MSOLe<BDD>(x, to)));
if (disj == null)
disj = range;
else
disj = new MSOOr<BDD>(disj, range);
}
else
{
MSOFormula<BDD> y_psi;
Variable y = ConvertTerm1(t, locals, out y_psi);
MSOFormula<BDD> elem = new MSOEq<BDD>(x, y);
if (y_psi != null)
elem = new MSOExists<BDD>(y, new MSOAnd<BDD>(y_psi, elem));
if (disj == null)
disj = elem;
else
disj = new MSOOr<BDD>(disj, elem);
}
}
var pred = new MSOForall<BDD>(x, new MSOEquiv<BDD>(new MSOIn<BDD>(x, X), disj));
psi = pred;
return X;
}
public static void Run()
{
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"randomMSOInt.csv", false))
{
Console.WriteLine("num-predicates, num-minterms, minterm-time, generic-bdd, product ");
file.WriteLine("num-predicates, num-minterms, minterm-time, generic-bdd, product ");
}
random = new Random(0);
currSeed = 0;
for (int maxConst = 3; maxConst < 4; maxConst++)
for (int phisize = 5; phisize < 8; phisize += 1)
{
//Console.WriteLine(maxConst + "," + phisize);
for (int i = 0; i < howMany; i++)
{
c = new Context();
z3 = new Z3BoolAlg(c, c.IntSort, timeout);
size = phisize;
try
{
var pair = GenerateMSOZ3Formula();
if (maxConst == 4 && phisize > 5)
break;
formula = pair.First;
predicates = pair.Second;
if (predicates.Count > 2)
{
var bddsolver = new BDDAlgebra<BoolExpr>(z3);
var sw = new Stopwatch();
sw.Restart();
long tbdd = timeout;
try
{
formula.GetAutomaton(bddsolver, false);
sw.Stop();
tbdd = sw.ElapsedMilliseconds;
if (tbdd > timeout)
tbdd = timeout;
}
catch (Z3Exception e)
{
tbdd = timeout;
}
catch (AutomataException e)
{
tbdd = timeout;
}
if (tbdd != timeout)
{
long tcart = timeout;
try
{
var bdd = new BDDAlgebra();
solver = new CartesianAlgebraBDD<BoolExpr>(bdd, z3);
sw.Restart();
formula.GetAutomaton(solver);
sw.Stop();
tcart = sw.ElapsedMilliseconds;
if (tcart > timeout)
tcart = timeout;
}
catch (Z3Exception e)
{
tcart = timeout;
}
catch (AutomataException e)
{
tcart = timeout;
}
sw.Restart();
long tminterm = timeout;
List<Pair<bool[], BoolExpr>> mint = new List<Pair<bool[], BoolExpr>>();
try
{
mint = z3.GenerateMinterms(predicates.ToArray()).ToList();
sw.Stop();
tminterm = sw.ElapsedMilliseconds;
if (tminterm > timeout)
tminterm = timeout;
}
catch (Z3Exception e)
{
tminterm = timeout;
}
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"randomMSOInt.csv", true))
{
Console.WriteLine(predicates.Count + ", " + (tminterm == timeout ? (int)Math.Pow(2, predicates.Count) : mint.Count) + ", " + (double)tminterm + ", " + (double)tbdd + ", " + (double)tcart);
file.WriteLine(predicates.Count + ", " + (tminterm == timeout ? (int)Math.Pow(2, predicates.Count) : mint.Count) + ", " + (double)tminterm + ", " + (double)tbdd + ", " + (double)tcart);
}
}
else {
//Console.WriteLine("moving to next one");
}
}
else
{
// Console.WriteLine("moving to next one");
}
}
catch (Z3Exception e)
{
Console.WriteLine("Z3 out of memory");
return;
}
catch (OutOfMemoryException e)
{
Console.WriteLine("Out of memory");
return;
}
}
}
}
static MSOOr <BoolExpr> Or(MSOFormula <BoolExpr> psi, MSOFormula <BoolExpr> phi)
{
return(new MSOOr <BoolExpr>(psi, phi));
}
/// <summary>
/// If t is a variable name then returns t as a s-o variable and sets psi=null.
/// Else returns a fresh s-o variable X and outputs psi(X) s.t. psi(X) iff X=t.
/// </summary>
private Variable ConvertTerm2(MonaExpr t, MapStack<string, MonaParam> locals, out MSOFormula<BDD> psi)
{
switch (t.symbol.Kind)
{
case Tokens.NAME:
{
psi = null;
return new Variable(t.symbol.text, false);
}
case Tokens.INTER:
return ConvertInter(t[0], t[1], locals, out psi);
case Tokens.UNION:
return ConvertUnion(t[0], t[1], locals, out psi);
case Tokens.SETMINUS:
return ConvertSetminus(t[0], t[1], locals, out psi);
case Tokens.EMPTY:
return ConvertEmptyset(out psi);
case Tokens.LBRACE:
return ConvertSet(t, locals, out psi);
default:
throw new NotImplementedException(t.ToString());
}
}
static MSOImplies <BoolExpr> Implies(MSOFormula <BoolExpr> lhs, MSOFormula <BoolExpr> rhs)
{
return(new MSOImplies <BoolExpr>(lhs, rhs));
}
private MSOFormula <BDD> ConvertPredApp(MonaPredApp predApp, MapStack <string, MonaParam> locals)
{
var predDef = predMap[predApp.symbol.text];
var predDecl = (MonaPredDecl)globals[predApp.symbol.text];
int k = predDecl.parameters.Count;
if (k != predApp.NrOfSubexprs)
{
throw new ArgumentException("invalid call of " + predDecl.name);
}
if (k == 0)
{
return(predDef);
}
var newVars = new Variable[k];
Dictionary <string, Variable> substitution = new Dictionary <string, Variable>();
var argPreds = new MSOFormula <BDD> [k];
var argVars = new Variable[k];
for (int i = 0; i < k; i++)
{
if (predDecl.parameters[i].kind != MonaParamKind.var1 && predDecl.parameters[i].kind != MonaParamKind.var2)
{
throw new NotImplementedException("parameter kind " + predDecl.parameters[i].kind.ToString());
}
MSOFormula <BDD> argPreds_i;
Variable argVars_i;
if (predDecl.parameters[i].kind == MonaParamKind.var1)
{
argVars_i = ConvertTerm1(predApp[i], locals, out argPreds_i);
if (argPreds_i == null)
{
var tmp1 = MkNewVar1();
argPreds_i = new MSOEq <BDD>(tmp1, argVars_i);
argVars_i = tmp1;
}
}
else
{
argVars_i = ConvertTerm2(predApp[i], locals, out argPreds_i);
if (argPreds_i == null)
{
var tmp2 = MkNewVar2();
argPreds_i = new MSOEq <BDD>(tmp2, argVars_i);
argVars_i = tmp2;
}
}
argPreds[i] = argPreds_i;
argVars[i] = argVars_i;
substitution[predDecl.parameters[i].Token.text] = argVars_i;
}
MSOFormula <BDD> psi = predDef.SubstituteVariables(substitution);
for (int i = k - 1; i >= 0; i--)
{
psi = new MSOExists <BDD>(argVars[i], argPreds[i] & psi);
}
return(psi);
}
/// <summary>
/// If t is a variable name then returns t as a f-o variable and sets psi=null.
/// Else returns a fresh f-o variable x and outputs psi(x) s.t. psi(x) iff x=t.
/// </summary>
Variable ConvertTerm1(MonaExpr t, MapStack <string, MonaParam> locals, out MSOFormula <BDD> psi)
{
switch (t.symbol.Kind)
{
case Tokens.NAME:
{
MonaParam p;
if (locals.TryGetValue(t.symbol.text, out p))
{
if (p.kind == MonaParamKind.var1)
{
psi = null;
return(new Variable(t.symbol.text, true));
}
else
{
throw new NotImplementedException(t.ToString());
}
}
else
{
MonaDecl d;
if (globals.TryGetValue(t.symbol.text, out d))
{
if (d.kind == MonaDeclKind.constant)
{
int n = ((MonaConstDecl)d).def.ToInt(globals);
Variable x = MkNewVar1();
var pred = new MSOeqN <BDD>(x, n);
psi = pred;
return(x);
}
else
{
throw new NotImplementedException(t.ToString());
}
}
else
{
throw new NotImplementedException(t.ToString());
}
}
}
case Tokens.PLUS:
{
Variable y = MkNewVar1();
if (t[0].symbol.Kind == Tokens.NAME)
{
int n = t[1].ToInt(globals);
Variable x = new Variable(t[0].symbol.text, true);
psi = new MSOSuccN <BDD>(x, y, n); // y = x + n
}
else
{
int n = t.ToInt(globals);
psi = new MSOeqN <BDD>(y, n); // y = n
}
return(y);
}
case Tokens.MIN:
{
MSOFormula <BDD> X_psi;
Variable X = ConvertTerm2(t[0], locals, out X_psi);
Variable x = MkNewVar1();
MSOFormula <BDD> min = new MSOMin <BDD>(x, X);
if (X_psi != null)
{
min = new MSOExists <BDD>(X, new MSOAnd <BDD>(X_psi, min));
}
psi = min;
return(x);
}
case Tokens.MAX:
{
MSOFormula <BDD> X_psi;
Variable X = ConvertTerm2(t[0], locals, out X_psi);
Variable x = MkNewVar1();
MSOFormula <BDD> max = new MSOMax <BDD>(x, X);
if (X_psi != null)
{
max = new MSOExists <BDD>(X, new MSOAnd <BDD>(X_psi, max));
}
psi = max;
return(x);
}
default:
throw new NotImplementedException(t.ToString());
}
}
static MSOExistsFo <BoolExpr> Exists(string x, MSOFormula <BoolExpr> psi)
{
return(new MSOExistsFo <BoolExpr>(x, psi));
}
private Variable ConvertSetminus(MonaExpr set1, MonaExpr set2, MapStack <string, MonaParam> locals, out MSOFormula <BDD> pred)
{
MSOFormula <BDD> psi1;
var X1 = ConvertTerm2(set1, locals, out psi1);
MSOFormula <BDD> psi2;
var X2 = ConvertTerm2(set2, locals, out psi2);
var X = MkNewVar2();
var x = MkNewVar1();
MSOFormula <BDD> diff = new MSOForall <BDD>(x,
new MSOEquiv <BDD>(new MSOIn <BDD>(x, X),
new MSOAnd <BDD>(new MSOIn <BDD>(x, X1),
new MSONot <BDD>(new MSOIn <BDD>(x, X2)))));
pred = AddConstraints(psi2, X2, psi1, X1, diff);
return(X);
}
//LTL over finite traces
private static void AutomatarkMsoFormulasTest(string inputDir, string outFile)
{
Console.WriteLine("fileName , generic-bdd, product");
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(outFile))
{
var files = new List<string>(Directory.EnumerateFiles(inputDir, "*.mona", SearchOption.AllDirectories));
files.Sort((s1, s2) => cmp(s1, s2));
foreach (string fileName in files)
{
string contents = File.ReadAllText(fileName);
MonaProgram pgm1 = MonaParser.Parse(contents);
phi = pgm1.ToMSO();
var bv7 = new CharSetSolver(BitWidth.BV7);
bddSolver = new BDDAlgebra<BDD>(bv7);
var sw = new Stopwatch();
sw.Restart();
Thread t = new Thread(BDDSolver);
t.Start();
long t1 = 5000;
if (!t.Join(TimeSpan.FromSeconds(5)))
{
t.Abort();
t1 = 5000;
}
else {
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
bv7 = new CharSetSolver(BitWidth.BV7);
cartSolver = new CartesianAlgebraBDD<BDD>(bv7);
sw.Restart();
t = new Thread(CartesianSolver);
t.Start();
long t2 = 5000;
if (!t.Join(TimeSpan.FromSeconds(5)))
{
t.Abort();
t2 = 5000;
}
else {
sw.Stop();
t2 = sw.ElapsedMilliseconds;
}
//if (t2 > 5000)
// t2 = 5000;
file.WriteLine(fileName + "," + (double)t1 / numTests + "," + (double)t2 / numTests);
Console.WriteLine(fileName + "," + (double)t1 / numTests + "," + (double)t2 / numTests);
}
}
}
private Variable ConvertUnion(MonaExpr set1, MonaExpr set2, MapStack<string, MonaParam> locals, out MSOFormula<BDD> pred)
{
MSOFormula<BDD> psi1;
var X1 = ConvertTerm2(set1, locals, out psi1);
MSOFormula<BDD> psi2;
var X2 = ConvertTerm2(set2, locals, out psi2);
var X = MkNewVar2();
var x = MkNewVar1();
MSOFormula<BDD> union = new MSOForall<BDD>(x,
new MSOEquiv<BDD>(new MSOIn<BDD>(x, X),
new MSOOr<BDD>(new MSOIn<BDD>(x, X1),
new MSOIn<BDD>(x, X2))));
pred = AddConstraints(psi2, X2, psi1, X1, union);
return X;
}
static MSOAnd <BoolExpr> And(MSOFormula <BoolExpr> psi, MSOFormula <BoolExpr> phi)
{
return(new MSOAnd <BoolExpr>(psi, phi));
}
static MSOForall <BoolExpr> Forall(Variable x, MSOFormula <BoolExpr> psi)
{
return(new MSOForall <BoolExpr>(x, psi));
}
/// <summary>
/// If t is a variable name then returns t as a f-o variable and sets psi=null.
/// Else returns a fresh f-o variable x and outputs psi(x) s.t. psi(x) iff x=t.
/// </summary>
Variable ConvertTerm1(MonaExpr t, MapStack<string, MonaParam> locals, out MSOFormula<BDD> psi)
{
switch (t.symbol.Kind)
{
case Tokens.NAME:
{
MonaParam p;
if (locals.TryGetValue(t.symbol.text, out p))
{
if (p.kind == MonaParamKind.var1)
{
psi = null;
return new Variable(t.symbol.text, true);
}
else
throw new NotImplementedException(t.ToString());
}
else
{
MonaDecl d;
if (globals.TryGetValue(t.symbol.text, out d))
{
if (d.kind == MonaDeclKind.constant)
{
int n = ((MonaConstDecl)d).def.ToInt(globals);
Variable x = MkNewVar1();
var pred = new MSOeqN<BDD>(x, n);
psi = pred;
return x;
}
else if (d.kind == MonaDeclKind.var1)
{
psi = null;
return new Variable(t.symbol.text, true);
}
else
throw new NotImplementedException(t.ToString());
}
else
throw new NotImplementedException(t.ToString());
}
}
case Tokens.PLUS:
{
Variable y = MkNewVar1();
if (t[0].symbol.Kind == Tokens.NAME)
{
int n = t[1].ToInt(globals);
Variable x = new Variable(t[0].symbol.text, true);
psi = new MSOSuccN<BDD>(x, y, n); // y = x + n
}
else
{
int n = t.ToInt(globals);
psi = new MSOeqN<BDD>(y, n); // y = n
}
return y;
}
case Tokens.MIN:
{
MSOFormula<BDD> X_psi;
Variable X = ConvertTerm2(t[0], locals, out X_psi);
Variable x = MkNewVar1();
MSOFormula<BDD> min = new MSOMin<BDD>(x, X);
if (X_psi != null)
min = new MSOExists<BDD>(X, new MSOAnd<BDD>(X_psi, min));
psi = min;
return x;
}
case Tokens.MAX:
{
MSOFormula<BDD> X_psi;
Variable X = ConvertTerm2(t[0], locals, out X_psi);
Variable x = MkNewVar1();
MSOFormula<BDD> max = new MSOMax<BDD>(x, X);
if (X_psi != null)
max = new MSOExists<BDD>(X, new MSOAnd<BDD>(X_psi, max));
psi = max;
return x;
}
case Tokens.NUMBER:
{
Variable x = MkNewVar1();
int num = t.symbol.ToInt();
psi = new MSOeqN<BDD>(x,num);
return x;
}
default:
throw new NotImplementedException(t.ToString());
}
}
/// <summary>
/// If t is a variable name then returns t as a s-o variable and sets psi=null.
/// Else returns a fresh s-o variable X and outputs psi(X) s.t. psi(X) iff X=t.
/// </summary>
private Variable ConvertTerm2(MonaExpr t, MapStack <string, MonaParam> locals, out MSOFormula <BDD> psi)
{
switch (t.symbol.Kind)
{
case Tokens.NAME:
{
psi = null;
return(new Variable(t.symbol.text, false));
}
case Tokens.INTER:
return(ConvertInter(t[0], t[1], locals, out psi));
case Tokens.UNION:
return(ConvertUnion(t[0], t[1], locals, out psi));
case Tokens.SETMINUS:
return(ConvertSetminus(t[0], t[1], locals, out psi));
case Tokens.EMPTY:
return(ConvertEmptyset(out psi));
case Tokens.LBRACE:
return(ConvertSet(t, locals, out psi));
default:
throw new NotImplementedException(t.ToString());
}
}
static MSOExists <BoolExpr> Exists(Variable x, MSOFormula <BoolExpr> psi)
{
return(new MSOExists <BoolExpr>(x, psi));
}
private Variable ConvertEmptyset(out MSOFormula<BDD> psi)
{
var X = MkNewVar2();
psi = new MSOIsEmpty<BDD>(X);
return X;
}
public static void Run()
{
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"randomMSOInt.csv", false))
{
Console.WriteLine("num-predicates, num-minterms, minterm-time, generic-bdd, product ");
file.WriteLine("num-predicates, num-minterms, minterm-time, generic-bdd, product ");
}
random = new Random(0);
currSeed = 0;
for (int maxConst = 3; maxConst < 4; maxConst++)
{
for (int phisize = 5; phisize < 8; phisize += 1)
{
//Console.WriteLine(maxConst + "," + phisize);
for (int i = 0; i < howMany; i++)
{
c = new Context();
z3 = new Z3BoolAlg(c, c.IntSort, timeout);
size = phisize;
try
{
var pair = GenerateMSOZ3Formula();
if (maxConst == 4 && phisize > 5)
{
break;
}
formula = pair.First;
predicates = pair.Second;
if (predicates.Count > 2)
{
var bddsolver = new BDDAlgebra <BoolExpr>(z3);
var sw = new Stopwatch();
sw.Restart();
long tbdd = timeout;
try
{
formula.GetAutomaton(bddsolver, false);
sw.Stop();
tbdd = sw.ElapsedMilliseconds;
if (tbdd > timeout)
{
tbdd = timeout;
}
}
catch (Z3Exception e)
{
tbdd = timeout;
}
catch (AutomataException e)
{
tbdd = timeout;
}
if (tbdd != timeout)
{
long tcart = timeout;
try
{
var bdd = new BDDAlgebra();
solver = new CartesianAlgebraBDD <BoolExpr>(bdd, z3);
sw.Restart();
formula.GetAutomaton(solver);
sw.Stop();
tcart = sw.ElapsedMilliseconds;
if (tcart > timeout)
{
tcart = timeout;
}
}
catch (Z3Exception e)
{
tcart = timeout;
}
catch (AutomataException e)
{
tcart = timeout;
}
sw.Restart();
long tminterm = timeout;
List <Pair <bool[], BoolExpr> > mint = new List <Pair <bool[], BoolExpr> >();
try
{
mint = z3.GenerateMinterms(predicates.ToArray()).ToList();
sw.Stop();
tminterm = sw.ElapsedMilliseconds;
if (tminterm > timeout)
{
tminterm = timeout;
}
}
catch (Z3Exception e)
{
tminterm = timeout;
}
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"randomMSOInt.csv", true))
{
Console.WriteLine(predicates.Count + ", " + (tminterm == timeout ? (int)Math.Pow(2, predicates.Count) : mint.Count) + ", " + (double)tminterm + ", " + (double)tbdd + ", " + (double)tcart);
file.WriteLine(predicates.Count + ", " + (tminterm == timeout ? (int)Math.Pow(2, predicates.Count) : mint.Count) + ", " + (double)tminterm + ", " + (double)tbdd + ", " + (double)tcart);
}
}
else
{
//Console.WriteLine("moving to next one");
}
}
else
{
// Console.WriteLine("moving to next one");
}
}
catch (Z3Exception e)
{
Console.WriteLine("Z3 out of memory");
return;
}
catch (OutOfMemoryException e)
{
Console.WriteLine("Out of memory");
return;
}
}
}
}
}
private MSOFormula <BDD> ConvertFormula(MonaExpr expr, MapStack <string, MonaParam> locals)
{
switch (expr.symbol.Kind)
{
case Tokens.TRUE:
return(new MSOTrue <BDD>());
case Tokens.FALSE:
return(new MSOFalse <BDD>());
case Tokens.NOT:
return(new MSONot <BDD>(ConvertFormula(expr[0], locals)));
case Tokens.AND:
return(new MSOAnd <BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals)));
case Tokens.OR:
return(new MSOOr <BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals)));
case Tokens.IMPLIES:
return(new MSOImplies <BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals)));
case Tokens.EQUIV:
return(new MSOEquiv <BDD>(ConvertFormula(expr[0], locals), ConvertFormula(expr[1], locals)));
case Tokens.EQ:
return(ConvertEq(expr[0], expr[1], locals));
case Tokens.NE:
return(new MSONot <BDD>(ConvertEq(expr[0], expr[1], locals)));
case Tokens.LT:
return(ConvertLt(expr[0], expr[1], locals));
case Tokens.GT:
return(ConvertLt(expr[1], expr[0], locals));
case Tokens.LE:
return(ConvertLe(expr[0], expr[1], locals));
case Tokens.GE:
return(ConvertLe(expr[1], expr[0], locals));
case Tokens.SUBSET:
return(ConvertSubset(expr[1], expr[0], locals));
case Tokens.IN:
return(ConvertIn(expr[0], expr[1], locals));
case Tokens.NOTIN:
return(new MSONot <BDD>(ConvertIn(expr[0], expr[1], locals)));
case Tokens.EMPTY:
return(ConvertIsEmpty(expr[0], locals));
case Tokens.EX1:
case Tokens.EX2:
{
MonaQFormula phi = (MonaQFormula)expr;
if ((phi.universes != null && phi.universes.Count > 1) ||
phi.vars.Exists(vw => vw.where != null))
{
throw new NotImplementedException(expr.ToString());
}
MSOFormula <BDD> psi = ConvertFormula(phi.formula, locals.Push(phi.varmap));
foreach (var vw in phi.vars)
{
psi = new MSOExists <BDD>(new Variable(vw.name, phi.varmap[vw.name].type == MonaExprType.INT), psi);
}
return(psi);
}
case Tokens.ALL1:
case Tokens.ALL2:
{
MonaQFormula phi = (MonaQFormula)expr;
if ((phi.universes != null && phi.universes.Count > 1) ||
phi.vars.Exists(vw => vw.where != null))
{
throw new NotImplementedException(expr.ToString());
}
MSOFormula <BDD> psi = ConvertFormula(phi.formula, locals.Push(phi.varmap));
foreach (var vw in phi.vars)
{
psi = new MSOForall <BDD>(new Variable(vw.name, phi.varmap[vw.name].type == MonaExprType.INT), psi);
}
return(psi);
}
default:
throw new NotImplementedException(expr.ToString());
}
}
static MSOForallFo <BoolExpr> Forall(string x, MSOFormula <BoolExpr> psi)
{
return(new MSOForallFo <BoolExpr>(x, psi));
}
