public void BooleanAlgebraZ3_test2()
{
var ctx = new Context();
var sort = ctx.IntSort;
var solver = new Z3BoolAlg(ctx, sort);
var alg = new BDDAlgebra <BoolExpr>(solver);
var x = new Variable("x", true);
var y = new Variable("y", true);
var z = new Variable("z", true);
var xLTy = new MSOLt <BoolExpr>(x, y);
var xLTzLTy = new MSOAnd <BoolExpr>((new MSOLt <BoolExpr>(x, z)), (new MSOLt <BoolExpr>(z, y)));
var Ez = new MSOExists <BoolExpr>(z, xLTzLTy);
var notEz = new MSONot <BoolExpr>(Ez);
var xSyDef = new MSOAnd <BoolExpr>(xLTy, notEz);
var aut_xSyDef = xSyDef.GetAutomaton(alg);
var aut_xLTzLTy = xLTzLTy.GetAutomaton(alg);
var aut_Ez = Ez.GetAutomaton(alg);
var aut_notEz = notEz.GetAutomaton(alg);
var aut_xLTy = xLTy.GetAutomaton(alg);
//aut_xSyDef.ShowGraph("aut_xSyDEf");
//aut_xLTzLTy.ShowGraph("aut_xLTzLTy");
//aut_Ez.ShowGraph("aut_Ez");
//aut_notEz.ShowGraph("aut_notEz");
var xSyPrim = new MSOSuccN <BoolExpr>(x, y, 1);
var aut_xSyPrim = xSyPrim.GetAutomaton(alg);
var equiv = aut_xSyPrim.IsEquivalentWith(aut_xSyDef);
Assert.IsTrue(equiv);
}
public void BooleanAlgebraZ3_test2()
{
var ctx = new Context();
var sort = ctx.IntSort;
var solver = new Z3BoolAlg(ctx, sort);
var alg = new BDDAlgebra <BoolExpr>(solver);
var x = new WS1SVariable <BoolExpr>("x");
var y = new WS1SVariable <BoolExpr>("y");
var z = new WS1SVariable <BoolExpr>("z");
var xLTy = x < y;
var xLTzLTy = (x < z) & (z < y);
var Ez = new WS1SExists <BoolExpr>(z, xLTzLTy);
var notEz = new WS1SNot <BoolExpr>(Ez);
var xSyDef = new WS1SAnd <BoolExpr>(xLTy, notEz);
var aut_xSyDef = xSyDef.GetAutomaton(alg, x, y);
var aut_xLTzLTy = xLTzLTy.GetAutomaton(alg, x, y, z);
var aut_Ez = Ez.GetAutomaton(alg, x, y);
var aut_notEz = notEz.GetAutomaton(alg, x, y);
var aut_xLTy = xLTy.GetAutomaton(alg, x, y);
//aut_xSyDef.ShowGraph("aut_xSyDEf");
//aut_xLTzLTy.ShowGraph("aut_xLTzLTy");
//aut_Ez.ShowGraph("aut_Ez");
//aut_notEz.ShowGraph("aut_notEz");
var xSyPrim = new WS1SSuccN <BoolExpr>(x, y, 1);
var aut_xSyPrim = xSyPrim.GetAutomaton(alg, x, y);
var equiv = aut_xSyPrim.IsEquivalentWith(aut_xSyDef, alg);
Assert.IsTrue(equiv);
}
public void Mona2AutomatonTest2()
{
BDDAlgebra solver = new BDDAlgebra();
string source1 = @"
m2l-str;
var1 x,y;
y = x + 1;
";
string source2 = @"
m2l-str;
var1 x,y;
x < y & ~ex1 z: x<z & z<y;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver);
//aut1.ShowGraph("aut1");
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver);
//aut2.ShowGraph("aut2");
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
public void Mona2AutomatonTest2()
{
BDDAlgebra solver = new BDDAlgebra();
string source1 = @"
m2l-str;
var1 x,y;
y = x + 1;
";
string source2 = @"
m2l-str;
var1 x,y;
x < y & ~ex1 z: x<z & z<y;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver);
//aut1.ShowGraph("aut1");
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver);
//aut2.ShowGraph("aut2");
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
public void Mona2AutomatonTest3(bool singletonSetSemantics)
{
BDDAlgebra solver = new BDDAlgebra();
string source1 = @"
m2l-str;
var1 x,y;
y = x + 2;
";
string source2 = @"
m2l-str;
var1 x,y;
ex1 z: x<z & z<y;
x < y & ~ex1 z1,z2: x<z1 & z1<y & x<z2 & z2<y & z1 ~= z2;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver, 0, singletonSetSemantics);
//aut1.ShowGraph("aut1");
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver, 0, singletonSetSemantics);
//aut2.ShowGraph("aut2");
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
public void Mona2AutomatonTest_pred1(bool useSingletonSetSemantics)
{
BDDAlgebra solver = new BDDAlgebra();
string source1 =
@"m2l-str;
pred succ(var1 x,y) = x < y & ~ex1 z:(x < z & z < y);
var1 x,y,z;
succ(x,y) & succ(y,z);
";
string source2 =
@"m2l-str;
var1 x,y,z;
y = x+1 & z = y + 1;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver, 0, useSingletonSetSemantics);
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver, 0, useSingletonSetSemantics);
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
public void Mona2AutomatonTest3(bool singletonSetSemantics)
{
BDDAlgebra solver = new BDDAlgebra();
string source1 = @"
m2l-str;
var1 x,y;
y = x + 2;
";
string source2 = @"
m2l-str;
var1 x,y;
ex1 z: x<z & z<y;
x < y & ~ex1 z1,z2: x<z1 & z1<y & x<z2 & z2<y & z1 ~= z2;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver, 0, singletonSetSemantics);
//aut1.ShowGraph("aut1");
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver, 0, singletonSetSemantics);
//aut2.ShowGraph("aut2");
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
void TestMintermExplosion(int bitWidth, bool useBDD = false)
{
TestContext.WriteLine("----------------");
TestContext.WriteLine(bitWidth.ToString());
if (useBDD)
{
//var S = new CharSetSolver(BitWidth.BV32);
var S = new BDDAlgebra();
TestContext.WriteLine("BDD");
int t = System.Environment.TickCount;
var aut1 = CreateAutomaton1 <BDD>(S.MkBitTrue, bitWidth, S);
var aut2 = CreateAutomaton2 <BDD>(S.MkBitTrue, bitWidth, S);
var aut3 = CreateAutomaton3 <BDD>(S.MkBitTrue, bitWidth, S);
t = System.Environment.TickCount - t;
TestContext.WriteLine(t + "ms");
//aut.ShowGraph("aut" + bitWidth);
}
else
{
TestContext.WriteLine("Z3");
Z3Provider Z = new Z3Provider(BitWidth.BV7);
var x = Z.MkConst("x", Z.IntSort);
Func <int, Expr> f = (i => Z.MkEq((Z.MkInt(1)), Z.MkMod(Z.MkDiv(x, Z.MkInt(1 << (i % 32))), Z.MkInt(2))));
int t = System.Environment.TickCount;
var aut1 = CreateAutomaton1 <Expr>(f, bitWidth, Z);
var aut2 = CreateAutomaton2 <Expr>(f, bitWidth, Z);
var aut3 = CreateAutomaton3 <Expr>(f, bitWidth, Z);
t = System.Environment.TickCount - t;
TestContext.WriteLine(t + "ms");
//aut.ShowGraph("aut" + bitWidth);
}
}
public void Mona2AutomatonTest_pred3()
{
BDDAlgebra solver = new BDDAlgebra();
string source1 =
@"m2l-str;
pred belongs(var1 x, var2 X) = x in X;
pred subs(var2 X, Y) = all1 x: belongs(x,X) => belongs(x,Y);
pred equal(var2 X,Y) = subs(X,Y) & subs(Y,X);
var2 X, Y;
equal(X,Y);
";
string source2 =
@"m2l-str;
var2 Y, X;
Y = X;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver);
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver);
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
//Run the test on each phi in phis and store result in infFile
static void RunTest(System.IO.StreamWriter outFile, List <Pair <MSOFormula <BDD>, CharSetSolver> > phis, int stop1At = 100, int stop2At = 100, int stop3At = 100)
{
var sw = new Stopwatch();
using (System.IO.StreamWriter file = outFile)
{
file.WriteLine("k, old, cartesian-bdd, cartesian-product");
int to = 2;
foreach (var p in phis)
{
// T1
var t1 = timeout;
if (to < stop1At)
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.First.GetAutomaton(p.Second);
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
//T2
var t2 = timeout;
if (to < stop1At)
{
var cartesianBDD = new CartesianAlgebraBDD <BDD>(p.Second);
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.First.GetAutomaton(cartesianBDD);
}
sw.Stop();
t2 = sw.ElapsedMilliseconds;
}
// T3
var t3 = timeout;
if (to < stop3At)
{
BDDAlgebra <BDD> cartesianProduct = new BDDAlgebra <BDD>(p.Second);
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.First.GetAutomaton(cartesianProduct, false);
}
sw.Stop();
t3 = sw.ElapsedMilliseconds;
}
file.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests);
Console.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests);
to++;
}
}
}
//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 void TestShiftRight2()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] {0, 15}, 3);
Assert.AreEqual<int>(9, cond.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftRight", "c:/tmp/TestShiftRight2.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
var sr = solver.ShiftRight(cond);
Assert.AreEqual<int>(7, sr.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(sr, "TestShiftRight", "c:/tmp/TestShiftRight2res.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestBvSetSolver2()
{
var solver = new BDDAlgebra();
var set = solver.MkNot(solver.MkOr(solver.MkSetFromRange(10001, uint.MaxValue, 31), solver.MkSetFromRange(5, 1004, 31)));
ulong elems = solver.ComputeDomainSize(set, 31);
int nodes = set.CountNodes();
uint expected = 10000 - 1000 + 1;
Assert.AreEqual <ulong>(expected, elems);
}
public void TestShiftLeft1()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftLeft", "c:/tmp/TestShiftLeftIn.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
//BvSet bvs = solver.ShiftLeft(cond, 30);
//Assert.AreEqual<int>(5, bvs.CountNodes());
BDD bvs2 = solver.ShiftLeft(cond, 28);
Assert.AreEqual<int>(9, bvs2.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(bvs, "TestShiftLeft", "c:/tmp/TestShiftLeftOut.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestShiftRight1()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond1 = solver.MkSetFromRange(0, 7, 3);
BDD cond2 = solver.MkSetFromElements(new uint[] {9, 10, 12, 15}, 3);
BDD cond = solver.MkOr(cond1, cond2);
Assert.AreEqual<int>(8, cond.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftRight", "c:/tmp/TestShiftRight1.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
BDD sr = solver.ShiftRight(cond);
Assert.AreEqual<BDD>(solver.True, sr);
}
public void BooleanAlgebraZ3_test1()
{
var ctx = new Context();
var sort = ctx.IntSort;
var solver = new Z3BoolAlg(ctx, sort);
var alg = new BDDAlgebra <BoolExpr>(solver);
var x = new Variable("x", true);
var pred = new MSOPredicate <BoolExpr>(ctx.MkEq(solver.x, ctx.MkNumeral(42, sort)), x);
MSOFormula <BoolExpr> phi = new MSOExists <BoolExpr>(x, pred);
var pred_aut = pred.GetAutomaton(alg);
//pred_aut.ShowGraph("pred_aut");
}
public void TestShiftLeftThenRight()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftLeft2_cond", "c:/tmp/TestShiftLeft2_cond.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
BDD bvs = solver.ShiftLeft(cond, 4);
BDD concat = solver.MkAnd(bvs, cond);
Assert.AreEqual<int>(16, concat.CountNodes());
BDD cond1 = solver.ShiftRight(solver.ShiftRight(solver.ShiftRight(solver.ShiftRight(concat))));
Assert.AreEqual<BDD>(cond1, cond);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(concat, "TestShiftLeft2_concat", "c:/tmp/TestShiftLeft2_concat.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestUlongBvsSetCreation()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new ulong[] { 0UL, (ulong)0xFFFFFFFF }, 31);
BDD bvs = solver.ShiftLeft(cond, 4);
var ranges = solver.ToRanges64(bvs, bvs.Ordinal);
Assert.AreEqual<int>(2, ranges.Length);
Assert.AreEqual<ulong>(0UL, ranges[0].First);
Assert.AreEqual<ulong>(0xFUL, ranges[0].Second);
Assert.AreEqual<ulong>((ulong)0xFFFFFFFF0, ranges[1].First);
Assert.AreEqual<ulong>((ulong)0xFFFFFFFFF, ranges[1].Second);
}
public void TestShiftLeft1()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftLeft", "c:/tmp/TestShiftLeftIn.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
//BvSet bvs = solver.ShiftLeft(cond, 30);
//Assert.AreEqual<int>(5, bvs.CountNodes());
BDD bvs2 = solver.ShiftLeft(cond, 28);
Assert.AreEqual <int>(9, bvs2.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(bvs, "TestShiftLeft", "c:/tmp/TestShiftLeftOut.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestShiftRight2()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
Assert.AreEqual <int>(9, cond.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftRight", "c:/tmp/TestShiftRight2.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
var sr = solver.ShiftRight(cond);
Assert.AreEqual <int>(7, sr.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(sr, "TestShiftRight", "c:/tmp/TestShiftRight2res.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void TestShiftRight1()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond1 = solver.MkSetFromRange(0, 7, 3);
BDD cond2 = solver.MkSetFromElements(new uint[] { 9, 10, 12, 15 }, 3);
BDD cond = solver.MkOr(cond1, cond2);
Assert.AreEqual <int>(8, cond.CountNodes());
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftRight", "c:/tmp/TestShiftRight1.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
BDD sr = solver.ShiftRight(cond);
Assert.AreEqual <BDD>(solver.True, sr);
}
public void TestUlongBvsSetCreation()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new ulong[] { 0UL, (ulong)0xFFFFFFFF }, 31);
BDD bvs = solver.ShiftLeft(cond, 4);
var ranges = solver.ToRanges64(bvs, bvs.Ordinal);
Assert.AreEqual <int>(2, ranges.Length);
Assert.AreEqual <ulong>(0UL, ranges[0].First);
Assert.AreEqual <ulong>(0xFUL, ranges[0].Second);
Assert.AreEqual <ulong>((ulong)0xFFFFFFFF0, ranges[1].First);
Assert.AreEqual <ulong>((ulong)0xFFFFFFFFF, ranges[1].Second);
}
public void TestWS1S_Forall_x_Exists_y_x_lt_y()
{
var triv = new TrivialBooleanAlgebra();
var ca = new BDDAlgebra <bool>(triv);
var x = new Variable("x", false);
var y = new Variable("y", false);
var x_lt_y = new WS1SLt <bool>(x, y);
var psi4 = ~(new WS1SExists <bool>(x, new WS1SSingleton <bool>(x) & ~(new WS1SExists <bool>(y, new WS1SSingleton <bool>(y) & (x_lt_y)))));
var aut = psi4.GetAutomaton(ca, x, y);
//aut.ShowGraph("aut");
//accepts only the empty word
Assert.IsTrue(aut.StateCount == 1 && aut.IsFinalState(aut.InitialState) && aut.MoveCount == 0);
}
public void TestWS1S_Forall_x_Exists_y_x_lt_y()
{
var triv = new TrivialBooleanAlgebra();
var ca = new BDDAlgebra<bool>(triv);
var x = new Variable("x", true);
var y = new Variable("y", true);
var x_lt_y = new MSOLt<bool>(x, y);
var aut_x_lt_y = x_lt_y.GetAutomaton(ca);
//aut_x_lt_y.ShowGraph("aut_x_lt_y");
var psi4 = new MSOForall<bool>(x, new MSOExists<bool>(y, (x_lt_y)));
var aut = psi4.GetAutomaton(ca);
//accepts only the empty word
Assert.IsTrue(aut.StateCount == 1 && aut.IsFinalState(aut.InitialState) && aut.MoveCount == 0);
}
public void Mona2AutomatonTest1()
{
string source = @"
m2l-str;
var1 x,y;
x < y;
";
MonaProgram pgm = MonaParser.Parse(source);
var mso = pgm.ToMSO();
BDDAlgebra solver = new BDDAlgebra();
var aut = mso.GetAutomaton(solver);
//aut.ShowGraph();
Assert.IsTrue(aut.StateCount == 3);
}
public void TestWS1S_Forall_x_Exists_y_x_lt_y()
{
var triv = new TrivialBooleanAlgebra();
var ca = new BDDAlgebra <bool>(triv);
var x = new WS1SVariable <bool>("x");
var y = new WS1SVariable <bool>("y");
// Forall x.Exists y.x < y
var psi4 = ~(x ^ !x & ~(y ^ (x < y)));
var aut = psi4.GetAutomaton(ca, x, y);
//aut.ShowGraph("aut");
//accepts only the empty word
Assert.IsTrue(aut.StateCount == 1 && aut.IsFinalState(aut.InitialState) && aut.MoveCount == 0);
}
public void Mona2AutomatonTest4()
{
BDDAlgebra solver = new BDDAlgebra();
string source1 = @"
m2l-str;
var2 X,Y;
Y = X;
";
string source2 = @"
m2l-str;
var2 X,Y;
all1 z: z in X <=> z in Y;
";
string source3 = @"
m2l-str;
var2 X,Y;
Y sub X & X sub Y;
";
string source4 = @"
m2l-str;
var2 X,Y;
Y\X = empty & X\Y = empty;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver);
//aut1.ShowGraph("aut1");
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver);
//aut2.ShowGraph("aut2");
MonaProgram pgm3 = MonaParser.Parse(source3);
var mso3 = pgm3.ToMSO();
var aut3 = mso3.GetAutomaton(solver);
MonaProgram pgm4 = MonaParser.Parse(source4);
var mso4 = pgm4.ToMSO();
var aut4 = mso4.GetAutomaton(solver);
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
Assert.IsTrue(aut1.IsEquivalentWith(aut3));
Assert.IsTrue(aut1.IsEquivalentWith(aut4));
}
public void TestShiftLeftThenRight()
{
BDDAlgebra solver = new BDDAlgebra();
BDD cond = solver.MkSetFromElements(new uint[] { 0, 15 }, 3);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(cond, "TestShiftLeft2_cond", "c:/tmp/TestShiftLeft2_cond.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
BDD bvs = solver.ShiftLeft(cond, 4);
BDD concat = solver.MkAnd(bvs, cond);
Assert.AreEqual <int>(16, concat.CountNodes());
BDD cond1 = solver.ShiftRight(solver.ShiftRight(solver.ShiftRight(solver.ShiftRight(concat))));
Assert.AreEqual <BDD>(cond1, cond);
//Automata.Internal.DirectedGraphs.DotWriter.CharSetToDot(concat, "TestShiftLeft2_concat", "c:/tmp/TestShiftLeft2_concat.dot", Internal.DirectedGraphs.DotWriter.RANKDIR.TB, 12);
}
public void Mona2AutomatonTest1()
{
string source = @"
m2l-str;
var1 x,y;
x < y;
";
MonaProgram pgm = MonaParser.Parse(source);
var mso = pgm.ToMSO();
BDDAlgebra solver = new BDDAlgebra();
var aut = mso.GetAutomaton(solver);
//aut.ShowGraph();
Assert.IsTrue(aut.StateCount == 3);
}
public void TestBvSetSolver5()
{
var solver = new BDDAlgebra();
var a = solver.MkSetFromRange(0, 3, 6);
var b = solver.MkSetFromRange(0x40, 0x43, 6);
var c = solver.MkSetFromRange(0x20, 0x23, 6);
var d = solver.MkSetFromRange(0x60, 0x63, 6);
var all = new BDD[] { a, b, c, d };
//a.ToDot("_0_3.dot");
//b.ToDot("_10_13.dot");
var a_size = solver.ComputeDomainSize(a, 6);
var b_size = solver.ComputeDomainSize(b, 6);
var x = solver.MkAnd(a, b);
var u = solver.MkOr(all);
var u_size = solver.ComputeDomainSize(u, 6);
//u.ToDot("_0_3_u_10_13.dot");
var u_compl = solver.MkNot(u);
//u_compl.ToDot("_0_3_u_10_13_compl.dot");
var u_compl_size = solver.ComputeDomainSize(u_compl, 6);
Assert.AreEqual <ulong>(4, a_size);
Assert.AreEqual <ulong>(4, b_size);
Assert.IsTrue(x.IsEmpty);
Assert.AreEqual <ulong>(16, u_size);
var ranges = solver.ToRanges(u, 6);
Assert.AreEqual <int>(4, ranges.Length);
Assert.AreEqual <uint>(0, ranges[0].First);
Assert.AreEqual <uint>(3, ranges[0].Second);
Assert.AreEqual <uint>(0x20, ranges[1].First);
Assert.AreEqual <uint>(0x23, ranges[1].Second);
Assert.AreEqual <uint>(0x40, ranges[2].First);
Assert.AreEqual <uint>(0x43, ranges[2].Second);
Assert.AreEqual <uint>(0x60, ranges[3].First);
Assert.AreEqual <uint>(0x63, ranges[3].Second);
}
public void TestBvSetSolver3()
{
var solver = new BDDAlgebra();
var letters_ASCII = solver.MkOr(solver.MkSetFromRange('a', 'z', 6), solver.MkSetFromRange('A', 'Z', 6));
var letters_eASCII = solver.MkOr(solver.MkSetFromRange('a', 'z', 7), solver.MkSetFromRange('A', 'Z', 7));
Assert.AreEqual <ulong>(52, solver.ComputeDomainSize(letters_ASCII, 6));
Assert.AreEqual <ulong>(52, solver.ComputeDomainSize(letters_eASCII, 7));
var set7 = solver.MkNot(letters_ASCII);
ulong elems7 = solver.ComputeDomainSize(set7, 6);
uint expected7 = (1 << 7) - 52;
Assert.AreEqual <ulong>(expected7, elems7);
var set8 = solver.MkNot(letters_eASCII);
ulong elems8 = solver.ComputeDomainSize(set8, 7);
ulong expected8 = (1 << 8) - 52;
Assert.AreEqual <ulong>(expected8, elems8);
}
public void Mona2AutomatonTest_pred2()
{
BDDAlgebra solver = new BDDAlgebra();
string source =
@"m2l-str;
pred succ(var1 x,y) = x < y & ~ex1 z:(x < z & z < y);
var1 x,y,z;
succ(x,y) & succ(y,z);
";
MonaProgram pgm1 = MonaParser.Parse(source);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver, 0, true);
MonaProgram pgm2 = MonaParser.Parse(source);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver, 0, false);
Assert.IsFalse(aut1.IsEquivalentWith(aut2));
}
public void TestBvSetSolver4()
{
var solver = new BDDAlgebra();
var _0_3 = solver.MkSetFromRange(0, 3, 6);
var _10_13 = solver.MkSetFromRange(0x40, 0x43, 6);
//_0_3.ToDot("_0_3.dot");
//_10_13.ToDot("_10_13.dot");
var _0_3_size = solver.ComputeDomainSize(_0_3, 6);
var _10_13_size = solver.ComputeDomainSize(_10_13, 6);
var x = solver.MkAnd(_0_3, _10_13);
var _0_3_u_10_13 = solver.MkOr(_0_3, _10_13);
var _0_3_u_10_13_size = solver.ComputeDomainSize(_0_3_u_10_13, 6);
//_0_3_u_10_13.ToDot("_0_3_u_10_13.dot");
var _0_3_u_10_13_compl = solver.MkNot(_0_3_u_10_13);
//_0_3_u_10_13_compl.ToDot("_0_3_u_10_13_compl.dot");
var _0_3_u_10_13_compl_size = solver.ComputeDomainSize(_0_3_u_10_13_compl, 6);
Assert.AreEqual <ulong>(4, _0_3_size);
Assert.AreEqual <ulong>(4, _10_13_size);
Assert.IsTrue(x.IsEmpty);
Assert.AreEqual <ulong>(8, _0_3_u_10_13_size);
var ranges = solver.ToRanges(_0_3_u_10_13, 6);
Assert.AreEqual <int>(2, ranges.Length);
Assert.AreEqual <uint>(0, ranges[0].First);
Assert.AreEqual <uint>(3, ranges[0].Second);
Assert.AreEqual <uint>(0x40, ranges[1].First);
Assert.AreEqual <uint>(0x43, ranges[1].Second);
}
//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 CartesianAlgebraBDD(BDDAlgebra bddAlg, IBooleanAlgebra <T> nodeAlg) :
base(bddAlg, nodeAlg)
{
}
//Run the test on each phi in phis and store result in infFile
static void RunTest(System.IO.StreamWriter outFile, List<Pair<MSOFormula<BDD>, CharSetSolver>> phis, int stop1At = 100, int stop2At = 100, int stop3At = 100)
{
var sw = new Stopwatch();
using (System.IO.StreamWriter file = outFile)
{
Console.WriteLine("k, old, cartesian, generic-bdd");
file.WriteLine("k, old, cartesian, generic-bdd");
int to = 2;
foreach (var p in phis)
{
// T1
var t1 = timeout;
if (to < stop1At)
{
try
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.First.GetAutomaton(p.Second);
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
catch (OutOfMemoryException)
{
t1 = timeout * numTests;
}
}
//T2
var t2 = timeout;
if (to < stop1At)
{
var cartesianBDD = new CartesianAlgebraBDD<BDD>(p.Second);
try
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.First.GetAutomaton(cartesianBDD);
}
sw.Stop();
t2 = sw.ElapsedMilliseconds;
}
catch (OutOfMemoryException)
{
t2 = timeout * numTests;
}
}
// T3
var t3 = timeout;
if (to < stop3At)
{
BDDAlgebra<BDD> cartesianProduct = new BDDAlgebra<BDD>(p.Second);
try
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.First.GetAutomaton(cartesianProduct, false);
}
sw.Stop();
t3 = sw.ElapsedMilliseconds;
}
catch (OutOfMemoryException)
{
t3 = timeout * numTests;
}
}
file.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests);
Console.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests);
to++;
}
}
}
public void TestBvSetSolver5()
{
var solver = new BDDAlgebra();
var a = solver.MkSetFromRange(0, 3, 6);
var b = solver.MkSetFromRange(0x40, 0x43, 6);
var c = solver.MkSetFromRange(0x20, 0x23, 6);
var d = solver.MkSetFromRange(0x60, 0x63, 6);
var all = new BDD[] { a, b, c, d };
//a.ToDot("_0_3.dot");
//b.ToDot("_10_13.dot");
var a_size = solver.ComputeDomainSize(a, 6);
var b_size = solver.ComputeDomainSize(b, 6);
var x = solver.MkAnd(a, b);
var u = solver.MkOr(all);
var u_size = solver.ComputeDomainSize(u, 6);
//u.ToDot("_0_3_u_10_13.dot");
var u_compl = solver.MkNot(u);
//u_compl.ToDot("_0_3_u_10_13_compl.dot");
var u_compl_size = solver.ComputeDomainSize(u_compl, 6);
Assert.AreEqual<ulong>(4, a_size);
Assert.AreEqual<ulong>(4, b_size);
Assert.IsTrue(x.IsEmpty);
Assert.AreEqual<ulong>(16, u_size);
var ranges = solver.ToRanges(u, 6);
Assert.AreEqual<int>(4, ranges.Length);
Assert.AreEqual<uint>(0, ranges[0].First);
Assert.AreEqual<uint>(3, ranges[0].Second);
Assert.AreEqual<uint>(0x20, ranges[1].First);
Assert.AreEqual<uint>(0x23, ranges[1].Second);
Assert.AreEqual<uint>(0x40, ranges[2].First);
Assert.AreEqual<uint>(0x43, ranges[2].Second);
Assert.AreEqual<uint>(0x60, ranges[3].First);
Assert.AreEqual<uint>(0x63, ranges[3].Second);
}
public void Mona2AutomatonTest4()
{
BDDAlgebra solver = new BDDAlgebra();
string source1 = @"
m2l-str;
var2 X,Y;
Y = X;
";
string source2 = @"
m2l-str;
var2 X,Y;
all1 z: z in X <=> z in Y;
";
string source3 = @"
m2l-str;
var2 X,Y;
Y sub X & X sub Y;
";
string source4 = @"
m2l-str;
var2 X,Y;
Y\X = empty & X\Y = empty;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver);
//aut1.ShowGraph("aut1");
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver);
//aut2.ShowGraph("aut2");
MonaProgram pgm3 = MonaParser.Parse(source3);
var mso3 = pgm3.ToMSO();
var aut3 = mso3.GetAutomaton(solver);
MonaProgram pgm4 = MonaParser.Parse(source4);
var mso4 = pgm4.ToMSO();
var aut4 = mso4.GetAutomaton(solver);
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
Assert.IsTrue(aut1.IsEquivalentWith(aut3));
Assert.IsTrue(aut1.IsEquivalentWith(aut4));
}
public void TestBvSetSolver4()
{
var solver = new BDDAlgebra();
var _0_3 = solver.MkSetFromRange(0, 3, 6);
var _10_13 = solver.MkSetFromRange(0x40, 0x43, 6);
//_0_3.ToDot("_0_3.dot");
//_10_13.ToDot("_10_13.dot");
var _0_3_size = solver.ComputeDomainSize(_0_3, 6);
var _10_13_size = solver.ComputeDomainSize(_10_13, 6);
var x = solver.MkAnd(_0_3, _10_13);
var _0_3_u_10_13 = solver.MkOr(_0_3, _10_13);
var _0_3_u_10_13_size = solver.ComputeDomainSize(_0_3_u_10_13, 6);
//_0_3_u_10_13.ToDot("_0_3_u_10_13.dot");
var _0_3_u_10_13_compl = solver.MkNot(_0_3_u_10_13);
//_0_3_u_10_13_compl.ToDot("_0_3_u_10_13_compl.dot");
var _0_3_u_10_13_compl_size = solver.ComputeDomainSize(_0_3_u_10_13_compl, 6);
Assert.AreEqual<ulong>(4, _0_3_size);
Assert.AreEqual<ulong>(4, _10_13_size);
Assert.IsTrue(x.IsEmpty);
Assert.AreEqual<ulong>(8, _0_3_u_10_13_size);
var ranges = solver.ToRanges(_0_3_u_10_13, 6);
Assert.AreEqual<int>(2, ranges.Length);
Assert.AreEqual<uint>(0, ranges[0].First);
Assert.AreEqual<uint>(3, ranges[0].Second);
Assert.AreEqual<uint>(0x40, ranges[1].First);
Assert.AreEqual<uint>(0x43, ranges[1].Second);
}
public static void MintermTest()
{
var sw = new Stopwatch();
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"..\msomintermp1s1.txt"))
{
for (int size = 2; size < kminterm; size++)
{
// Tsolve no force
var s1 = new CharSetSolver(BitWidth.BV64);
var solver = new CartesianAlgebraBDD <BDD>(s1);
WS1SFormula <BDD> phi = new WS1STrue <BDD>();
for (int k = 1; k < size; k++)
{
var leq = new WS1SLt <BDD>(new Variable <BDD>("x" + (k - 1)), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, leq);
}
for (int k = 0; k < size; k++)
{
var axk = new WS1SPred <BDD>(s1.MkBitTrue(k), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, axk);
}
for (int k = size - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(solver);
}
sw.Stop();
var t1 = sw.ElapsedMilliseconds;
file.WriteLine((double)t1 / numTests);
Console.WriteLine((double)t1 / numTests);
}
}
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"..\msomintermp2s1.txt"))
{
for (int size = 2; size < kminterm; size++)
{
// Tsolve force
var s1 = new CharSetSolver(BitWidth.BV64);
var solver = new CartesianAlgebraBDD <BDD>(s1);
WS1SFormula <BDD> phi = new WS1STrue <BDD>();
for (int k = 0; k < size; k++)
{
var axk = new WS1SPred <BDD>(s1.MkBitTrue(k), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, axk);
}
for (int k = size - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
var t1 = 60000L;
if (size <= maxmint)
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(solver);
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
file.WriteLine((double)t1 / numTests);
Console.WriteLine((double)t1 / numTests);
}
}
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"..\msomintermp1s2.txt"))
{
for (int size = 2; size < kminterm; size++)
{
// Tsolve solver 2
var solver = new CharSetSolver(BitWidth.BV64);
var alg = new BDDAlgebra <BDD>(solver);
WS1SFormula <BDD> phi = new WS1STrue <BDD>();
for (int k = 1; k < size; k++)
{
var leq = new WS1SLt <BDD>(new Variable <BDD>("x" + (k - 1)), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, leq);
}
for (int k = 0; k < size; k++)
{
var axk = new WS1SPred <BDD>(solver.MkBitTrue(k), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, axk);
}
for (int k = size - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
var t1 = 60000L;
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(alg);
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
file.WriteLine((double)t1 / numTests);
Console.WriteLine((double)t1 / numTests);
}
}
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"..\msomintermp2s2.txt"))
{
for (int size = 2; size < kminterm; size++)
{
var solver = new CharSetSolver(BitWidth.BV64);
var alg = new BDDAlgebra <BDD>(solver);
//Tforce sol 2
WS1SFormula <BDD> phi = new WS1STrue <BDD>();
for (int k = 0; k < size; k++)
{
var axk = new WS1SPred <BDD>(solver.MkBitTrue(k), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, axk);
}
for (int k = size - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
var t1 = 60000L;
if (size <= maxmint)
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(alg);
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
file.WriteLine((double)t1 / numTests);
Console.WriteLine((double)t1 / numTests);
}
}
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"..\msominterm.txt"))
{
for (int size = 2; size < kminterm; size++)
{
//Tminterm
var solver = new CharSetSolver(BitWidth.BV64);
BDD[] predicates = new BDD[size];
solver.GenerateMinterms();
for (int k = 0; k < size; k++)
{
predicates[k] = solver.MkBitTrue(k);
}
var t1 = 60000L * numTests;
if (size <= maxmint)
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
var mint = solver.GenerateMinterms(predicates).ToList();
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
file.WriteLine((double)t1 / numTests);
Console.WriteLine((double)t1 / numTests);
}
}
}
public void Mona2AutomatonTest_pred1(bool useSingletonSetSemantics)
{
BDDAlgebra solver = new BDDAlgebra();
string source1 =
@"m2l-str;
pred succ(var1 x,y) = x < y & ~ex1 z:(x < z & z < y);
var1 x,y,z;
succ(x,y) & succ(y,z);
";
string source2 =
@"m2l-str;
var1 x,y,z;
y = x+1 & z = y + 1;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver,0, useSingletonSetSemantics);
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver,0, useSingletonSetSemantics);
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
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;
}
}
}
}
public void Mona2AutomatonTest_pred2()
{
BDDAlgebra solver = new BDDAlgebra();
string source =
@"m2l-str;
pred succ(var1 x,y) = x < y & ~ex1 z:(x < z & z < y);
var1 x,y,z;
succ(x,y) & succ(y,z);
";
MonaProgram pgm1 = MonaParser.Parse(source);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver,0, true);
MonaProgram pgm2 = MonaParser.Parse(source);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver,0, false);
Assert.IsFalse(aut1.IsEquivalentWith(aut2));
}
public void Mona2AutomatonTest_pred3()
{
BDDAlgebra solver = new BDDAlgebra();
string source1 =
@"m2l-str;
pred belongs(var1 x, var2 X) = x in X;
pred subs(var2 X, Y) = all1 x: belongs(x,X) => belongs(x,Y);
pred equal(var2 X,Y) = subs(X,Y) & subs(Y,X);
var2 X, Y;
equal(X,Y);
";
string source2 =
@"m2l-str;
var2 Y, X;
Y = X;
";
MonaProgram pgm1 = MonaParser.Parse(source1);
var mso1 = pgm1.ToMSO();
var aut1 = mso1.GetAutomaton(solver);
MonaProgram pgm2 = MonaParser.Parse(source2);
var mso2 = pgm2.ToMSO();
var aut2 = mso2.GetAutomaton(solver);
Assert.IsTrue(aut1.IsEquivalentWith(aut2));
}
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;
}
}
}
}
}
public static void POPLTestsNewSolver2()
{
var sw = new Stopwatch();
using (System.IO.StreamWriter file =
new System.IO.StreamWriter(@"..\msobddsol2.txt"))
{
for (int to = 2; to < kpopl; to++)
{
// T1
var s1 = new CharSetSolver(BitWidth.BV64);
var solver = new BDDAlgebra <BDD>(s1);
WS1SFormula <BDD> phi = new WS1STrue <BDD>();
for (int k = 1; k < to; k++)
{
var leq = new WS1SLt <BDD>(new Variable <BDD>("x" + (k - 1)), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, leq);
}
for (int k = to - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(solver);
}
sw.Stop();
var t1 = sw.ElapsedMilliseconds;
//T2
s1 = new CharSetSolver(BitWidth.BV64);
solver = new BDDAlgebra <BDD>(s1);
phi = new WS1STrue <BDD>();
for (int k = 1; k < to; k++)
{
var leq = new WS1SLt <BDD>(new Variable <BDD>("x" + (k - 1)), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, leq);
}
for (int k = 0; k < to; k++)
{
var axk = new WS1SPred <BDD>(s1.MkCharConstraint('a', false), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, axk);
}
for (int k = to - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(solver);
}
sw.Stop();
var t2 = sw.ElapsedMilliseconds;
// T3
s1 = new CharSetSolver(BitWidth.BV64);
solver = new BDDAlgebra <BDD>(s1);
phi = new WS1STrue <BDD>();
for (int k = 1; k < to; k++)
{
var leq = new WS1SLt <BDD>(new Variable <BDD>("x" + (k - 1)), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, leq);
}
for (int k = 0; k < to; k++)
{
var axk = new WS1SPred <BDD>(s1.MkCharConstraint('a', false), new Variable <BDD>("x" + k));
phi = new WS1SAnd <BDD>(phi, axk);
}
for (int k = to - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
var exycy = new WS1SExists <BDD>(new Variable <BDD>("y"), new WS1SPred <BDD>(s1.MkCharConstraint('c', false), new Variable <BDD>("y")));
phi = new WS1SAnd <BDD>(phi, exycy);
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(solver);
}
sw.Stop();
var t3 = sw.ElapsedMilliseconds;
//T4
s1 = new CharSetSolver(BitWidth.BV64);
solver = new BDDAlgebra <BDD>(s1);
phi = new WS1STrue <BDD>();
for (int k = 1; k < to; k++)
{
var leq = new WS1SLt <BDD>(new Variable <BDD>("x" + (k - 1)), new Variable <BDD>("x" + k));
var axk = new WS1SPred <BDD>(s1.MkCharConstraint('a', false), new Variable <BDD>("x" + (k - 1)));
var cxk = new WS1SPred <BDD>(s1.MkCharConstraint('c', false), new Variable <BDD>("x" + (k - 1)));
var inter = new WS1SOr <BDD>(new WS1SAnd <BDD>(leq, axk), cxk);
phi = new WS1SAnd <BDD>(phi, inter);
}
for (int k = to - 1; k >= 0; k--)
{
phi = new WS1SExists <BDD>(new Variable <BDD>("x" + k), phi);
}
exycy = new WS1SExists <BDD>(new Variable <BDD>("y"), new WS1SPred <BDD>(s1.MkCharConstraint('c', false), new Variable <BDD>("y")));
phi = new WS1SAnd <BDD>(phi, exycy);
var t4 = 60000L * numTests;
if (to <= maxmphipop)
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
phi.GetAutomaton(solver);
}
sw.Stop();
t4 = sw.ElapsedMilliseconds;
}
file.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests + "," + (double)t4 / numTests);
Console.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests + "," + (double)t4 / numTests);
}
}
}
//Run the test on each phi in phis and store result in infFile
static void RunTest(System.IO.StreamWriter outFile, List <Tuple <MSOFormula <BDD>, CharSetSolver> > phis, int stop1At = 100, int stop2At = 100, int stop3At = 100)
{
var sw = new Stopwatch();
using (System.IO.StreamWriter file = outFile)
{
Console.WriteLine("k, old, cartesian, generic-bdd");
file.WriteLine("k, old, cartesian, generic-bdd");
int to = 2;
foreach (var p in phis)
{
// T1
var t1 = timeout;
if (to < stop1At)
{
try
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.Item1.GetAutomaton(p.Item2);
}
sw.Stop();
t1 = sw.ElapsedMilliseconds;
}
catch (OutOfMemoryException)
{
t1 = timeout * numTests;
}
}
//T2
var t2 = timeout;
if (to < stop1At)
{
var cartesianBDD = new CartesianAlgebraBDD <BDD>(p.Item2);
try
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.Item1.GetAutomaton(cartesianBDD);
}
sw.Stop();
t2 = sw.ElapsedMilliseconds;
}
catch (OutOfMemoryException)
{
t2 = timeout * numTests;
}
}
// T3
var t3 = timeout;
if (to < stop3At)
{
BDDAlgebra <BDD> cartesianProduct = new BDDAlgebra <BDD>(p.Item2);
try
{
sw.Restart();
for (int t = 0; t < numTests; t++)
{
p.Item1.GetAutomaton(cartesianProduct, false);
}
sw.Stop();
t3 = sw.ElapsedMilliseconds;
}
catch (OutOfMemoryException)
{
t3 = timeout * numTests;
}
}
file.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests);
Console.WriteLine(to + "," + (double)t1 / numTests + "," + (double)t2 / numTests + "," + (double)t3 / numTests);
to++;
}
}
}
public void TestBvSetSolver()
{
var solver = new BDDAlgebra();
var set = solver.MkOr(solver.MkSetFromRange(10001, uint.MaxValue, 31),solver.MkSetFromRange(5, 1004, 31));
ulong elems = solver.ComputeDomainSize(set,31);
int nodes = set.CountNodes();
uint expected = (uint.MaxValue - 10000) + 1000;
Assert.AreEqual<ulong>(expected, elems);
}
public void TestBvSetSolver3()
{
var solver = new BDDAlgebra();
var letters_ASCII = solver.MkOr(solver.MkSetFromRange('a', 'z', 6), solver.MkSetFromRange('A', 'Z', 6));
var letters_eASCII = solver.MkOr(solver.MkSetFromRange('a', 'z', 7), solver.MkSetFromRange('A', 'Z', 7));
Assert.AreEqual<ulong>(52, solver.ComputeDomainSize(letters_ASCII, 6));
Assert.AreEqual<ulong>(52, solver.ComputeDomainSize(letters_eASCII, 7));
var set7 = solver.MkNot(letters_ASCII);
ulong elems7 = solver.ComputeDomainSize(set7, 6);
uint expected7 = (1<<7) - 52;
Assert.AreEqual<ulong>(expected7, elems7);
var set8 = solver.MkNot(letters_eASCII);
ulong elems8 = solver.ComputeDomainSize(set8, 7);
ulong expected8 = (1<<8) - 52;
Assert.AreEqual<ulong>(expected8, elems8);
}
