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> 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 TestMSO_Pred() { var solver = new CharSetSolver(BitWidth.BV16); var x = new Variable("x", true); var pred = new MSOPredicate <BDD>(solver.MkCharConstraint('c'), x); MSOFormula <BDD> phi = new MSOExists <BDD>(x, pred); var ca = new CartesianAlgebraBDD <BDD>(solver); var pred_aut = pred.GetAutomaton(ca); //pred_aut.ShowGraph("pred_aut"); var aut = phi.GetAutomaton(solver); for (int i = 0; i < 10; i++) { var s = solver.GenerateMember(aut); Assert.IsTrue(System.Text.RegularExpressions.Regex.IsMatch(s, "c"), "regex mismatch"); } var aut2 = solver.RegexConverter.Convert("c", System.Text.RegularExpressions.RegexOptions.Singleline); //aut2.ShowGraph("aut2"); //aut.ShowGraph("aut"); Assert.IsTrue(aut2.IsEquivalentWith(aut), "automata not equialent"); }
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()); } }
/// <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()); } }
public static void Run() { var sw = new Stopwatch(); //ex x1 x2... a(x1) /\ a(x2).../\ x1<x2... using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"..\mso-minterm-p1.csv")) { file.WriteLine("k, old, cartesian, trie, minterm"); for (int size = 2; size < kminterm; size++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula <BDD> phi = new MSOTrue <BDD>(); //x1<x2 /\... for (int k = 1; k < size; k++) { var leq = new MSOSuccN <BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true), 1); phi = new MSOAnd <BDD>(phi, leq); } //ai(xi) /\ ... for (int k = 0; k < size; k++) { var axk = new MSOPredicate <BDD>(solver.MkBitTrue(k), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, axk); } phi = new MSOAnd <BDD>(new MSOeqN <BDD>(new Variable("x" + 0, true), 0), phi); for (int k = size - 1; k >= 0; k--) { phi = new MSOExists <BDD>(new Variable("x" + k, true), phi); } //Old sw.Restart(); for (int t = 0; t < numTests; t++) { var aut = phi.GetAutomaton(solver); } var told = sw.ElapsedMilliseconds; //BDD sw.Restart(); for (int t = 0; t < numTests; t++) { var aut = phi.GetAutomaton(new CartesianAlgebraBDD <BDD>(solver)); } sw.Stop(); var t1 = sw.ElapsedMilliseconds; //Trie sw.Restart(); for (int t = 0; t < numTests; t++) { var aut = phi.GetAutomaton(new BDDAlgebra <BDD>(solver), false); } var t2 = sw.ElapsedMilliseconds; //Tminterm 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 t3 = 60000L * numTests; if (size <= maxmint) { sw.Restart(); for (int t = 0; t < numTests; t++) { var mint = solver.GenerateMinterms(predicates).ToList(); } sw.Stop(); t3 = sw.ElapsedMilliseconds; } file.WriteLine(size + ", " + (double)told / numTests + ", " + (double)t1 / numTests + ", " + (double)t2 / numTests + ", " + (double)t3 / numTests); Console.WriteLine(size + ", " + (double)told / numTests + ", " + (double)t1 / numTests + ", " + (double)t2 / numTests + ", " + (double)t3 / numTests); } } //ex x1 x2... a(x1) /\ a(x2)... using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"..\mso-minterm-p2.csv")) { file.WriteLine("k, old, cartesian, trie, minterm"); for (int size = 2; size < 10; size++) { // Tsolve force var solver = new CharSetSolver(); MSOFormula <BDD> phi = new MSOTrue <BDD>(); for (int k = 0; k < size; k++) { var axk = new MSOPredicate <BDD>(solver.MkBitTrue(k), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, axk); } for (int k = size - 1; k >= 0; k--) { phi = new MSOExists <BDD>(new Variable("x" + k, true), phi); } //Old sw.Restart(); for (int t = 0; t < numTests; t++) { var aut = phi.GetAutomaton(solver); } var told = sw.ElapsedMilliseconds; //Cartesian var t1 = 60000L * numTests; if (size <= 7) { sw.Restart(); for (int t = 0; t < numTests; t++) { phi.GetAutomaton(new CartesianAlgebraBDD <BDD>(solver)); } sw.Stop(); t1 = sw.ElapsedMilliseconds; } //Trie var t2 = 60000L * numTests; sw.Restart(); for (int t = 0; t < numTests; t++) { phi.GetAutomaton(new BDDAlgebra <BDD>(solver), false); } sw.Stop(); t2 = sw.ElapsedMilliseconds; //Tminterm 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 t3 = 60000L * numTests; if (size <= maxmint) { sw.Restart(); for (int t = 0; t < numTests; t++) { var mint = solver.GenerateMinterms(predicates).ToList(); } sw.Stop(); t3 = sw.ElapsedMilliseconds; } file.WriteLine(size + ", " + (double)told / numTests + ", " + (double)t1 / numTests + ", " + (double)t2 / numTests + ", " + (double)t3 / numTests); Console.WriteLine(size + ", " + (double)told / numTests + ", " + (double)t1 / numTests + ", " + (double)t2 / numTests + ", " + (double)t3 / numTests); } } }
private static Pair<MSOFormula<BoolExpr>, List<BoolExpr>> GenerateMSOFormula(int maxVarIndex) { int randomNumber = random.Next(0, 8); size--; if (size <= 0) { int variable = random.Next(0, maxVarIndex-1); BoolExpr b = GeneratePredicateOut(200); List<BoolExpr> l = new List<BoolExpr>(); l.Add(b); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(new MSOPredicate<BoolExpr>(b, new Variable("x"+variable, true)), l); } switch (randomNumber) { case 0: { Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi1 = GenerateMSOFormula(maxVarIndex + 1); MSOFormula<BoolExpr> phi = new MSOExists<BoolExpr>(new Variable("x"+maxVarIndex, true), phi1.First); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, phi1.Second); } case 1: { Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi1 = GenerateMSOFormula(maxVarIndex + 1); MSOFormula<BoolExpr> phi = new MSOForall<BoolExpr>(new Variable("x" + maxVarIndex, true), phi1.First); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, phi1.Second); } case 2: case 3: { Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi1 = GenerateMSOFormula(maxVarIndex); Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi2 = GenerateMSOFormula(maxVarIndex); MSOFormula<BoolExpr> phi = new MSOAnd<BoolExpr>(phi1.First, phi2.First); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, new List<BoolExpr>(phi1.Second.Union(phi2.Second))); } case 4: case 5: { Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi1 = GenerateMSOFormula(maxVarIndex); Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi2 = GenerateMSOFormula(maxVarIndex); MSOFormula<BoolExpr> phi = new MSOOr<BoolExpr>(phi1.First, phi2.First); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, new List<BoolExpr>(phi1.Second.Union(phi2.Second))); } case 6: { Pair<MSOFormula<BoolExpr>, List<BoolExpr>> phi1 = GenerateMSOFormula(maxVarIndex); MSOFormula<BoolExpr> phi = new MSONot<BoolExpr>(phi1.First); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, phi1.Second); } case 7: { if (maxVarIndex > 1) { int variable1 = random.Next(0, maxVarIndex - 1); int variable2 = random.Next(0, maxVarIndex - 1); if (variable1 == variable2) { if (variable1 == maxVarIndex - 1) variable1 = variable1 - 1; else variable2 = variable2 + 1; } //Successor MSOFormula<BoolExpr> phi = new MSOSuccN<BoolExpr>(varOf(variable1),varOf(variable2),random.Next(1,4)); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, new List<BoolExpr>()); } else { int variable = random.Next(0, maxVarIndex - 1); BoolExpr b = GeneratePredicate(); List<BoolExpr> l = new List<BoolExpr>(); l.Add(b); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(new MSOPredicate<BoolExpr>(b, new Variable("x" + variable, true)), l); } } case 8: { int variable1 = random.Next(0, maxVarIndex - 1); int variable2 = random.Next(0, maxVarIndex - 1); //less than MSOFormula<BoolExpr> phi = new MSOLe<BoolExpr>(varOf(variable1), varOf(variable2)); return new Pair<MSOFormula<BoolExpr>, List<BoolExpr>>(phi, new List<BoolExpr>()); } } return null; }
public static void RunPOPLTests() { //// all x1...xn. xi<xi+1 List <Pair <MSOFormula <BDD>, CharSetSolver> > phis = new List <Pair <MSOFormula <BDD>, CharSetSolver> >(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(); MSOFormula <BDD> phi = new MSOTrue <BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt <BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, leq); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists <BDD>(new Variable("x" + k, true), phi); } phis.Add(new Pair <MSOFormula <BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"..\popl14-1.csv"), phis); // all x1...xn. xi<xi+1 and a(xi) phis = new List <Pair <MSOFormula <BDD>, CharSetSolver> >(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula <BDD> phi = new MSOTrue <BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt <BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, leq); } for (int k = 0; k < to; k++) { var axk = new MSOPredicate <BDD>( solver.MkCharConstraint('a', false), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, axk); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists <BDD>(new Variable("x" + k, true), phi); } phis.Add(new Pair <MSOFormula <BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"..\popl14-2.csv"), phis); // all x1...xn. (xi<xi+1 and a(xi)) and ex y. c(y) phis = new List <Pair <MSOFormula <BDD>, CharSetSolver> >(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula <BDD> phi = new MSOTrue <BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt <BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, leq); } for (int k = 0; k < to; k++) { var axk = new MSOPredicate <BDD>(solver.MkCharConstraint('a', false), new Variable("x" + k, true)); phi = new MSOAnd <BDD>(phi, axk); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists <BDD>(new Variable("x" + k, true), phi); } var exycy = new MSOExists <BDD>(new Variable("y", true), new MSOPredicate <BDD>(solver.MkCharConstraint('c', false), new Variable("y", true))); phi = new MSOAnd <BDD>(phi, exycy); phis.Add(new Pair <MSOFormula <BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"..\popl14-3.csv"), phis); // all x1...xn. (xi<xi+1 and a(xi) \/ c(xi)) phis = new List <Pair <MSOFormula <BDD>, CharSetSolver> >(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula <BDD> phi = new MSOTrue <BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt <BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); var axk = new MSOPredicate <BDD>(solver.MkCharConstraint('a', false), new Variable("x" + (k - 1), true)); var cxk = new MSOPredicate <BDD>(solver.MkCharConstraint('c', false), new Variable("x" + (k - 1), true)); var inter = new MSOOr <BDD>(new MSOAnd <BDD>(leq, axk), cxk); phi = new MSOAnd <BDD>(phi, inter); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists <BDD>(new Variable("x" + k, true), phi); } MSOFormula <BDD> exycy = new MSOExists <BDD>(new Variable("y", true), new MSOPredicate <BDD>(solver.MkCharConstraint('c', false), new Variable("y", true))); phi = new MSOAnd <BDD>(phi, exycy); phis.Add(new Pair <MSOFormula <BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"..\popl14-4.csv"), phis, 10, 10, 11); }
private static Pair <MSOFormula <BoolExpr>, List <BoolExpr> > GenerateMSOFormula(int maxVarIndex) { int randomNumber = random.Next(0, 8); size--; if (size <= 0) { int variable = random.Next(0, maxVarIndex - 1); BoolExpr b = GeneratePredicateOut(200); List <BoolExpr> l = new List <BoolExpr>(); l.Add(b); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(new MSOPredicate <BoolExpr>(b, new Variable("x" + variable, true)), l)); } switch (randomNumber) { case 0: { Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi1 = GenerateMSOFormula(maxVarIndex + 1); MSOFormula <BoolExpr> phi = new MSOExists <BoolExpr>(new Variable("x" + maxVarIndex, true), phi1.First); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, phi1.Second)); } case 1: { Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi1 = GenerateMSOFormula(maxVarIndex + 1); MSOFormula <BoolExpr> phi = new MSOForall <BoolExpr>(new Variable("x" + maxVarIndex, true), phi1.First); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, phi1.Second)); } case 2: case 3: { Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi1 = GenerateMSOFormula(maxVarIndex); Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi2 = GenerateMSOFormula(maxVarIndex); MSOFormula <BoolExpr> phi = new MSOAnd <BoolExpr>(phi1.First, phi2.First); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, new List <BoolExpr>(phi1.Second.Union(phi2.Second)))); } case 4: case 5: { Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi1 = GenerateMSOFormula(maxVarIndex); Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi2 = GenerateMSOFormula(maxVarIndex); MSOFormula <BoolExpr> phi = new MSOOr <BoolExpr>(phi1.First, phi2.First); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, new List <BoolExpr>(phi1.Second.Union(phi2.Second)))); } case 6: { Pair <MSOFormula <BoolExpr>, List <BoolExpr> > phi1 = GenerateMSOFormula(maxVarIndex); MSOFormula <BoolExpr> phi = new MSONot <BoolExpr>(phi1.First); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, phi1.Second)); } case 7: { if (maxVarIndex > 1) { int variable1 = random.Next(0, maxVarIndex - 1); int variable2 = random.Next(0, maxVarIndex - 1); if (variable1 == variable2) { if (variable1 == maxVarIndex - 1) { variable1 = variable1 - 1; } else { variable2 = variable2 + 1; } } //Successor MSOFormula <BoolExpr> phi = new MSOSuccN <BoolExpr>(varOf(variable1), varOf(variable2), random.Next(1, 4)); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, new List <BoolExpr>())); } else { int variable = random.Next(0, maxVarIndex - 1); BoolExpr b = GeneratePredicate(); List <BoolExpr> l = new List <BoolExpr>(); l.Add(b); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(new MSOPredicate <BoolExpr>(b, new Variable("x" + variable, true)), l)); } } case 8: { int variable1 = random.Next(0, maxVarIndex - 1); int variable2 = random.Next(0, maxVarIndex - 1); //less than MSOFormula <BoolExpr> phi = new MSOLe <BoolExpr>(varOf(variable1), varOf(variable2)); return(new Pair <MSOFormula <BoolExpr>, List <BoolExpr> >(phi, new List <BoolExpr>())); } } return(null); }
/// <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()); } }
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 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 MSOFormula<BDD> ConvertIsEmpty(MonaExpr set, MapStack<string, MonaParam> locals) { MSOFormula<BDD> psi_X; Variable X = ConvertTerm2(set, locals, out psi_X); MSOFormula<BDD> isempty = new MSOIsEmpty<BDD>(X); if (psi_X != null) isempty = new MSOExists<BDD>(X, new MSOAnd<BDD>(psi_X, isempty)); return isempty; }
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; } case Tokens.NAME: { var name = expr as MonaName; if (name != null) { //must be a nullary predicate application (var0 is not supported) var tmpPredApp = new MonaPredApp(name.symbol, Cons<MonaExpr>.Empty); return ConvertPredApp(tmpPredApp, locals); } var predApp = expr as MonaPredApp; if (predApp != null) { return ConvertPredApp(predApp, locals); } throw new NotImplementedException(expr.ToString()); } default: throw new NotImplementedException(expr.ToString()); } }
public static void RunPOPLTests() { //// all x1...xn. xi<xi+1 List<Pair<MSOFormula<BDD>, CharSetSolver>> phis = new List<Pair<MSOFormula<BDD>, CharSetSolver>>(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(); MSOFormula<BDD> phi = new MSOTrue<BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt<BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); phi = new MSOAnd<BDD>(phi, leq); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists<BDD>(new Variable("x" + k, true), phi); } phis.Add(new Pair<MSOFormula<BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"popl14-1.csv"), phis); // all x1...xn. xi<xi+1 and a(xi) phis = new List<Pair<MSOFormula<BDD>, CharSetSolver>>(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula<BDD> phi = new MSOTrue<BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt<BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); phi = new MSOAnd<BDD>(phi, leq); } for (int k = 0; k < to; k++) { var axk = new MSOPredicate<BDD>( solver.MkCharConstraint('a', false), new Variable("x" + k, true)); phi = new MSOAnd<BDD>(phi, axk); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists<BDD>(new Variable("x" + k, true), phi); } phis.Add(new Pair<MSOFormula<BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"popl14-2.csv"), phis); // all x1...xn. (xi<xi+1 and a(xi)) and ex y. c(y) phis = new List<Pair<MSOFormula<BDD>, CharSetSolver>>(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula<BDD> phi = new MSOTrue<BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt<BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); phi = new MSOAnd<BDD>(phi, leq); } for (int k = 0; k < to; k++) { var axk = new MSOPredicate<BDD>(solver.MkCharConstraint('a', false), new Variable("x" + k, true)); phi = new MSOAnd<BDD>(phi, axk); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists<BDD>(new Variable("x" + k, true), phi); } var exycy = new MSOExists<BDD>(new Variable("y", true), new MSOPredicate<BDD>(solver.MkCharConstraint('c', false), new Variable("y", true))); phi = new MSOAnd<BDD>(phi, exycy); phis.Add(new Pair<MSOFormula<BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"popl14-3.csv"), phis); // all x1...xn. (xi<xi+1 and a(xi) \/ c(xi)) phis = new List<Pair<MSOFormula<BDD>, CharSetSolver>>(); for (int to = 2; to < kpopl; to++) { var solver = new CharSetSolver(BitWidth.BV64); MSOFormula<BDD> phi = new MSOTrue<BDD>(); for (int k = 1; k < to; k++) { var leq = new MSOLt<BDD>(new Variable("x" + (k - 1), true), new Variable("x" + k, true)); var axk = new MSOPredicate<BDD>(solver.MkCharConstraint('a', false), new Variable("x" + (k - 1), true)); var cxk = new MSOPredicate<BDD>(solver.MkCharConstraint('c', false), new Variable("x" + (k - 1), true)); var inter = new MSOOr<BDD>(new MSOAnd<BDD>(leq, axk), cxk); phi = new MSOAnd<BDD>(phi, inter); } for (int k = to - 1; k >= 0; k--) { phi = new MSOExists<BDD>(new Variable("x" + k, true), phi); } MSOFormula<BDD> exycy = new MSOExists<BDD>(new Variable("y", true), new MSOPredicate<BDD>(solver.MkCharConstraint('c', false), new Variable("y", true))); phi = new MSOAnd<BDD>(phi, exycy); phis.Add(new Pair<MSOFormula<BDD>, CharSetSolver>(phi, solver)); } RunTest(new StreamWriter(@"popl14-4.csv"), phis, 11, 11, 11); }
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); }