/// <summary>
/// Computes the ratio of two dfas
/// </summary>
/// <returns>size of dfa2/ size of dfa1</returns>
internal static double GetDFARatio(Automaton<BDD> dfa1, Automaton<BDD> dfa2, HashSet<char> al, CharSetSolver solver, bool isSolDense)
{
var n = dfa1.StateCount;
double multiplier = 3;
int k = Math.Min(13, (int)(n * multiplier));
int finalDivider = k;
double[] paths1 = GetPathsUpToN(dfa1, al, solver, k);
double[] paths2 = GetPathsUpToN(dfa2, al, solver, k);
double sum = 0;
for (int i = 0; i <= k; i++)
{
//TODO check grading still works
double divider = Math.Min(paths1[i], Math.Pow(al.Count, i) - paths1[i]);
if (divider != 0)
sum += (paths2[i] / divider);
else
{
sum += paths2[i];
if (paths2[i] == 0)
finalDivider--;
}
}
return sum / (finalDivider + 1);
}
public void intEq2()
{
var solver = new CharSetSolver(BitWidth.BV64);
List<char> alph = new List<char> { 'a', 'b', 'c' };
HashSet<char> al = new HashSet<char>(alph);
PDLPred phi = new PDLIntEq(new PDLAllPos(), 2);
StringBuilder sb = new StringBuilder();
phi.ToMSO(new FreshGen()).ToString(sb);
System.Console.WriteLine(sb);
var dfa = phi.GetDFA(al, solver);
var test = solver.Convert(@"^(a|b|c){2}$");
Assert.IsTrue(dfa.IsEquivalentWith(test, solver));
////string file = "../../../TestPDL/DotFiles/IntEq2";
//solver.SaveAsDot(dfa, "aut", file);
}
public void TestGroups()
{
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var regex = @"\W*(?<key>\w{1,3})\s*(?<value>\d{2,3})\D*";
bool b;
var captures = css.ConvertCaptures(regex, out b);
Assert.IsTrue(captures.Length == 5);
for (int i = 0; i < captures.Length; i++ )
{
var aut = captures[i].Item2;
var name = captures[i].Item1;
if (name == "")
name = "skip" + i;
//css.ShowGraph(aut, name);
}
string s = "foobar";
s.StartsWith("foo");
s.EndsWith("bar");
s.Equals("foobar");
for (int i = 0; i < captures.Length; i++)
{
}
}
public static Pair<HashSet<char>, Automaton<BDD>> parseDFAFromString(string str, CharSetSolver solver)
{
var lines = Regex.Split(str, "\r\n|\r|\n");
HashSet<char> al = new HashSet<char>();
var line = lines[0];
var tokens = line.Split(new char[] { ' ' });
for (int i = 1; i < tokens.Length; i++)
al.Add(tokens[i].ToCharArray()[0]);
var finalStates = new List<int>();
line = lines[2];
tokens = line.Split(new char[] { ' ' });
for (int i = 2; i < tokens.Length; i++)
finalStates.Add(Convert.ToInt32(tokens[i]));
var moves = new List<Move<BDD>>();
for (int i = 3; i < lines.Length; i++)
{
tokens = lines[i].Split(new char[] { ',' });
if (tokens.Length > 1)
moves.Add(new Move<BDD>(Convert.ToInt32(tokens[0]), Convert.ToInt32(tokens[1]), solver.MkCharConstraint(false, tokens[2].ToCharArray()[0])));
}
return new Pair<HashSet<char>, Automaton<BDD>>(al, Automaton<BDD>.Create(0, finalStates, moves));
}
public DFAFeedback(FeedbackLevel level, HashSet<char> alphabet, double utility, CharSetSolver solver)
{
this.alphabet = alphabet;
this.level = level;
this.solver = solver;
this.utility = Math.Round(Math.Max(1-utility,0)*100);
}
public void ChooseUnifromlyTest()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD set1 = solver.MkRangeConstraint('\0', '\x01', true);
BDD set2 = solver.MkRangeConstraint( '\u0FFF', '\u0FFF');
string set2str = solver.PrettyPrint(set2);
BDD set3 = solver.MkRangeConstraint( '\u00FF', '\u00FF');
BDD set4 = solver.MkRangeConstraint( '\u000F', '\u000F');
BDD set = solver.MkOr(new BDD[]{set2, set3, set4, set1});
string setstr = solver.PrettyPrint(set);
set.ToDot(@"foo.dot");
var map = new Dictionary<char, int>();
map['\0'] = 0;
map['\x01'] = 0;
map['\u0FFF'] = 0;
map['\u00FF'] = 0;
map['\u000F'] = 0;
for (int i = 0; i < 50000; i++)
{
var c = solver.ChooseUniformly(set);
map[c] += 1;
}
foreach (var kv in map)
Assert.IsTrue(kv.Value > 9700);
}
public void MyTest()
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
var solver = new CharSetSolver(BitWidth.BV64);
List<char> alph = new List<char> { 'a', 'b' };
HashSet<char> al = new HashSet<char>(alph);
var a = solver.MkCharConstraint(false, 'a');
var b = solver.MkCharConstraint(false, 'b');
var moves = new List<Move<BDD>>();
moves.Add(new Move<BDD>(0, 1, a));
moves.Add(new Move<BDD>(0, 3, b));
moves.Add(new Move<BDD>(1,2, b));
moves.Add(new Move<BDD>(2, 1, a));
moves.Add(new Move<BDD>(1, 1, a));
moves.Add(new Move<BDD>(2, 2, b));
moves.Add(new Move<BDD>(3, 4, a));
moves.Add(new Move<BDD>(4, 3, b));
moves.Add(new Move<BDD>(3, 3, b));
moves.Add(new Move<BDD>(4, 4, a));
var dfa1 = Automaton<BDD>.Create(0, new int[] { 0,1,3 }, moves).Determinize(solver).Minimize(solver);
foreach (var v in pdlEnumerator.SynthesizePDL(al, dfa1, solver, new StringBuilder(), 5000))
{
Console.WriteLine(PDLUtil.ToEnglishString(v));
break;
}
}
public void MSOFirstLastSucc()
{
var solver = new CharSetSolver(BitWidth.BV64); //new solver using ASCII encoding
List<char> alph = new List<char> { 'a', 'b' };
HashSet<char> al = new HashSet<char>(alph);
//ex x. first(x)
MSOFormula first = new MSOFirst("x");
MSOFormula last = new MSOLast("y");
MSOFormula succ = new MSOSucc("x", "y");
MSOFormula and = new MSOAnd(new MSOAnd(first, last), succ);
MSOFormula formula = new MSOExistsFO("x", new MSOExistsFO("y", and));
Assert.IsTrue(formula.CheckUseOfVars());
var dfa = formula.getDFA(al, solver);
var test = solver.Convert(@"^(a|b){2}$");
Assert.IsTrue(dfa.IsEquivalentWith(test, solver));
string file = "../../../MSOZ3Test/DotFiles/ab";
solver.SaveAsDot(dfa, "aut", file); //extension .dot is added automatically when missing
}
public static Automaton<BDD> ReadFromString(CharSetSolver solver, string automaton)
{
var lines = automaton.Split(new char[] { '\n','\r' }, StringSplitOptions.RemoveEmptyEntries);
int initialState = int.Parse(lines[0]);
var moves = new Dictionary<Pair<int, int>, BDD>();
var allmoves = new List<Move<BDD>>();
int[] finals = Array.ConvertAll(lines[1].TrimEnd(' ').Split(' '), s => int.Parse(s));
for (int i = 2; i < lines.Length; i++)
{
int[] elems = Array.ConvertAll(lines[i].TrimEnd(' ').Split(' '), s => int.Parse(s));
var key = new Pair<int, int>(elems[0], elems[3]);
if (elems[1] == -1)
allmoves.Add(Move<BDD>.Epsilon(elems[0], elems[3]));
else
{
var pred = solver.MkCharSetFromRange((char)elems[1], (char)elems[2]);
if (moves.ContainsKey(key))
moves[key] = solver.MkOr(moves[key], pred);
else
moves[key] = pred;
}
}
foreach (var kv in moves)
allmoves.Add(Move<BDD>.Create(kv.Key.First, kv.Key.Second, kv.Value));
var aut = Automaton<BDD>.Create(solver, initialState, finals, allmoves);
return aut;
}
/// <summary>
/// Each transition has the form int[]{fromState, intervalStart, intervalEnd, toState}.
/// If intervalStart = intervalEnd = -1 then this is an epsilon move.
/// </summary>
public static Automaton<BDD> ReadFromRanges(CharSetSolver solver, int initialState, int[] finalStates, IEnumerable<int[]> transitions)
{
var moves = new Dictionary<Pair<int, int>, BDD>();
var allmoves = new List<Move<BDD>>();
int[] finals = finalStates;
foreach (var elems in transitions)
{
var key = new Pair<int, int>(elems[0], elems[3]);
if (elems[1] == -1)
allmoves.Add(Move<BDD>.Epsilon(elems[0], elems[3]));
else
{
var pred = solver.MkCharSetFromRange((char)elems[1], (char)elems[2]);
if (moves.ContainsKey(key))
moves[key] = solver.MkOr(moves[key], pred);
else
moves[key] = pred;
}
}
foreach (var kv in moves)
allmoves.Add(Move<BDD>.Create(kv.Key.First, kv.Key.Second, kv.Value));
var aut = Automaton<BDD>.Create(solver, initialState, finals, allmoves);
return aut;
}
public void DileepTest1()
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
var solver = new CharSetSolver(BitWidth.BV64);
List<char> alph = new List<char> { 'a', 'b' };
HashSet<char> al = new HashSet<char>(alph);
PDLPred phi = new PDLModSetEq(new PDLIndicesOf("a"), 2, 1);
phi = new PDLAnd(new PDLStartsWith("a"), phi);
var dfa1 = phi.GetDFA(al, solver);
var a = solver.MkCharConstraint(false, 'a');
var b = solver.MkCharConstraint(false, 'b');
var moves = new List<Move<BDD>>();
moves.Add(new Move<BDD>(0, 0, a));
moves.Add(new Move<BDD>(0, 5, a));
moves.Add(new Move<BDD>(5, 0, a));
moves.Add(new Move<BDD>(5, 5, b));
var dfa2 = Automaton<BDD>.Create(0, new int[] { 5 }, moves);
var feedbackGrade = DFAGrading.GetGrade(dfa1, dfa2, al, solver, timeout, 10, FeedbackLevel.Solution, true, false, false);
var feedString = "<ul>";
foreach (var feed in feedbackGrade.Second)
feedString += string.Format("<li>{0}</li>", feed);
feedString += "</ul>";
Console.Write( string.Format("<div>Grade: {0} <br /> Feedback: {1}</div>", feedbackGrade.First, feedString));
}
public void Feedback2()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
var al = new HashSet<char>(new char[] { 'a', 'b' });
var dfa1 = new PDLModSetEq(new PDLIndicesOf("a"), 2, 1).GetDFA(al, solver);
var a = solver.MkCharConstraint(false, 'a');
var b = solver.MkCharConstraint(false, 'b');
var movescorrect = new List<Move<BDD>>();
movescorrect.Add(new Move<BDD>(0, 0, b));
movescorrect.Add(new Move<BDD>(0, 1, a));
movescorrect.Add(new Move<BDD>(1, 0, a));
movescorrect.Add(new Move<BDD>(1, 0, b));
var dfa2 = Automaton<BDD>.Create(0, new int[] { 1 }, movescorrect);
var v4 = DFAGrading.GetGrade(dfa1, dfa2, al, solver, timeout, 10, FeedbackLevel.Hint);
Console.WriteLine("Grade: {0}", v4.First);
foreach (var v in v4.Second)
Console.WriteLine("Feedback: {0}", v);
}
public void TextP48()
{
var solver = new CharSetSolver(CharacterEncoding.Unicode);
var alph = new List<char> { 'a', 'b' };
var al = new HashSet<char>(alph);
var moves = new List<Move<CharSet>>();
var a = solver.MkCharConstraint(false, 'a');
var b = solver.MkCharConstraint(false, 'b');
moves.Add(new Move<CharSet>(0, 1, a));
moves.Add(new Move<CharSet>(0, 4, b));
moves.Add(new Move<CharSet>(1, 4, a));
moves.Add(new Move<CharSet>(1, 2, b));
moves.Add(new Move<CharSet>(2, 3, a));
moves.Add(new Move<CharSet>(2, 3, b));
moves.Add(new Move<CharSet>(3, 2, a));
moves.Add(new Move<CharSet>(3, 2, b));
moves.Add(new Move<CharSet>(4, 4, a));
moves.Add(new Move<CharSet>(4, 4, b));
var dfa = Automaton<CharSet>.Create(0, new int[] { 2 }, moves).Determinize(solver).Minimize(solver);
var sb = new StringBuilder();
DFAUtilities.printDFA(dfa, al, sb);
System.Console.WriteLine(sb);
}
public MoveSequence(string regex)
{
solver = new CharSetSolver(BitWidth.BV7);
moveAutomaton = solver.Convert("^(" + regex + ")$").Determinize(solver).Minimize(solver);
currentState = 0;
//solver.ShowGraph(moveAutomaton, "D");
//ComputeDeadStates();
}
public HelperPredicates(CharSetSolver solver, bool OptimzeForAsciiInput)
{
this.solver = solver;
helper_predicates = new List<string>();
predicate_cache = new Dictionary<BDD, string>();
ascii = solver.MkRangeConstraint('\0', '\x7F');
this.OptimzeForASCIIinput = OptimzeForAsciiInput;
}
public RegexToSMTConverter(BitWidth encoding)
{
css = new CharSetSolver(encoding);
automConverter = css.RegexConverter;
maxChar = (encoding == BitWidth.BV16 ? '\uFFFF' :
(encoding == BitWidth.BV8 ? '\u00FF' : '\u007F'));
CHAR = string.Format("(_ BitVec {0})", (int)encoding);
}
public RegexToSMTConverter(BitWidth encoding, string charSortAlias)
{
css = new CharSetSolver(encoding);
automConverter = css.RegexConverter;
maxChar = (encoding == BitWidth.BV16 ? '\uFFFF' :
(encoding == BitWidth.BV8 ? '\u00FF' : '\u007F'));
CHAR = charSortAlias;
}
public CSharpGenerator(Automaton<BDD> automaton, CharSetSolver solver, string classname, string namespacename, bool OptimzeForAsciiInput = true)
{
this.solver = solver;
this.automaton = automaton;
this.namespacename = namespacename;
this.classname = classname;
ASCII = solver.MkCharSetFromRange('\0', '\x7F');
helper_predicates = new HelperPredicates(solver, OptimzeForAsciiInput);
}
public static Pair<HashSet<char>, Automaton<BDD>> parseNFAFromXML(XElement Automaton1, CharSetSolver solver)
{
HashSet<char> al = new HashSet<char>();
var moves = new List<Move<BDD>>();
var finalStates = new List<int>();
int start = 0;
XElement Automaton = XElement.Parse(RemoveAllNamespaces(Automaton1.ToString()));
XElement xmlAlphabet = Automaton.Element("alphabet");
foreach (XElement child in xmlAlphabet.Elements())
{
char element = Convert.ToChar(child.Value);
if (element != 'ε' && element != '?')
al.Add(element);
}
XElement trans = Automaton.Element("transitionSet");
foreach (XElement child in trans.Elements())
{
if (child.Name == "transition")
{
char element = Convert.ToChar(child.Element("read").Value);
if (element != 'ε' && element != '?')
moves.Add(new Move<BDD>(Convert.ToInt32(child.Element("from").Value), Convert.ToInt32(child.Element("to").Value),
solver.MkCharConstraint(false, element)));
else
moves.Add(Move<BDD>.Epsilon(Convert.ToInt32(child.Element("from").Value), Convert.ToInt32(child.Element("to").Value)));
}
}
XElement acc = Automaton.Element("acceptingSet");
foreach (XElement child in acc.Elements())
{
if (child.Name == "state")
{
finalStates.Add((int)child.Attribute("sid"));
}
}
XElement states = Automaton.Element("initState");
foreach (XElement child in states.Elements())
{
if (child.Name == "state")
{
start = (int)child.Attribute("sid");
}
}
return new Pair<HashSet<char>, Automaton<BDD>>(al, Automaton<BDD>.Create(start, finalStates, moves));
}
/// <summary>
/// Returns the minimum PDL edit distance ratio between all the PDL A1 and A2 inferred for dfa1 and dfa2
/// in less than timeout. For every min_ij(d(A1i,A2j)/|A1i)
/// </summary>
/// <param name="dfa1"></param>
/// <param name="dfa2"></param>
/// <param name="al"></param>
/// <param name="solver"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public static double GetMinimalFormulaEditDistanceRatio(Automaton<BDD> dfa1, Automaton<BDD> dfa2, HashSet<char> al, CharSetSolver solver, long timeout, PDLEnumerator pdlEnumerator)
{
var v = GetMinimalFormulaEditDistanceTransformation(dfa1, dfa2, al, solver, timeout, pdlEnumerator);
if(v!=null){
var transformation = v.First;
var scaling = 1.0;
return transformation.totalCost / (transformation.minSizeForTreeA * scaling);
}
return 10;
}
public XElement ComputeFeedbackXML(XElement dfaCorrectDesc, XElement dfaAttemptDesc, XElement maxGrade, XElement feedbackLevel, XElement enabledFeedbacks)
{
#region Check if item is in cache
StringBuilder key = new StringBuilder();
key.Append("feed");
key.Append(dfaCorrectDesc.ToString());
key.Append(dfaAttemptDesc.ToString());
key.Append(feedbackLevel.ToString());
key.Append(enabledFeedbacks.ToString());
string keystr = key.ToString();
var cachedValue = HttpContext.Current.Cache.Get(key.ToString());
if (cachedValue != null)
{
HttpContext.Current.Cache.Remove(keystr);
HttpContext.Current.Cache.Add(keystr, cachedValue, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromDays(30), System.Web.Caching.CacheItemPriority.Normal, null);
return (XElement)cachedValue;
}
#endregion
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
//Read input
var dfaCorrectPair = DFAUtilities.parseDFAFromXML(dfaCorrectDesc, solver);
var dfaAttemptPair = DFAUtilities.parseDFAFromXML(dfaAttemptDesc, solver);
var level = (FeedbackLevel) Enum.Parse(typeof(FeedbackLevel), feedbackLevel.Value, true);
var enabList = (enabledFeedbacks.Value).Split(',').ToList<String>();
//bool dfaedit = enabList.Contains("dfaedit"), moseledit = enabList.Contains("moseledit"), density = enabList.Contains("density");
bool dfaedit =true, moseledit = true, density = true;
var maxG = int.Parse(maxGrade.Value);
//Compute feedback
var feedbackGrade = DFAGrading.GetGrade(dfaCorrectPair.Second, dfaAttemptPair.Second, dfaCorrectPair.First, solver, 1500, maxG, level, dfaedit, density, moseledit);
//Pretty print feedback
var feedString = "<ul>";
foreach (var feed in feedbackGrade.Second)
{
feedString += string.Format("<li>{0}</li>", feed);
break;
}
feedString += "</ul>";
//var output = string.Format("<result><grade>{0}</grade><feedString>{1}</feedString></result>", feedbackGrade.First, feedString);
var outXML = new XElement("result",
new XElement("grade", feedbackGrade.First),
new XElement("feedString", XElement.Parse(feedString)));
//XElement outXML = XElement.Parse(output);
//Add this element to chace and return it
HttpContext.Current.Cache.Add(key.ToString(), outXML, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromDays(30), System.Web.Caching.CacheItemPriority.Normal, null);
return outXML;
}
public void TestLoopThatStartsWith0()
{
string regex = @"(w(a|bc){0,2})";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(regex,RegexOptions.Singleline,true);
//css.ShowGraph(aut, "CornerCase");
var str = "w.-J_";
var actual = css.Accepts(aut, str);
var expected = Regex.IsMatch(str, regex);
Assert.AreEqual(expected, actual);
}
public NFANotMinimalFeedback (
FeedbackLevel level, HashSet<char> alphabet,
int stateDiff, int transitionDiff,
NFAEditScript script,
CharSetSolver solver)
: base(level, alphabet, solver)
{
this.transitionDiff = transitionDiff;
this.stateDiff = stateDiff;
this.script = script;
}
/// <summary>
/// Compute the DFA corresponding to the Monapred, null if it can't find it
/// </summary>
/// <param name="alphabet">DFA alphabet</param>
/// <param name="solver">Char solver</param>
/// <returns>the DFA corresponding to the Monapred, null if it can't find it</returns>
public virtual Automaton<BDD> GetDFA(HashSet<Char> alphabet, CharSetSolver solver)
{
try
{
return ToPDL(null, null).GetDFA(alphabet, solver);
}
catch (Exception e)
{
throw e;
}
}
public void TestMSO_Eq()
{
var solver = new CharSetSolver(BitWidth.BV16);
//var phi = new MSOTrue();
MSOFormula <BDD> phi = new MSOExists <BDD>(V1("x"), new MSOExists <BDD>(V1("y"), new MSONot <BDD>(new MSOEq <BDD>(V1("x"), V1("y")))));
var aut = phi.GetAutomaton(solver);
var aut2 = solver.RegexConverter.Convert(".{2,}", System.Text.RegularExpressions.RegexOptions.Singleline);
Assert.IsTrue(aut.IsEquivalentWith(aut2, solver));
}
public void TestIgnoreCaseTransformer()
{
CharSetSolver solver = new CharSetSolver();
int t = System.Environment.TickCount;
IgnoreCaseTransformer ic = new IgnoreCaseTransformer(solver);
//simple test first:
BDD a2c = solver.MkRangeConstraint('a', 'c');
BDD a2cA2C = ic.Apply(a2c);
BDD a2cA2C_expected = a2c.Or(solver.MkRangeConstraint('A', 'C'));
Assert.AreEqual<BDD>(a2cA2C, a2cA2C_expected);
//
//comprehensive test:
//
//test that the whole array is correct:
// Microsoft.Automata.Internal.Generated.IgnoreCaseRelation.ignorecase
// (generated by:)
//
// IgnoreCaseRelationGenerator.Generate(
// "Microsoft.Automata.Internal.Generated",
// "IgnoreCaseRelation",
// @"C:\GitHub\AutomataDotNet\Automata\src\Automata\Internal\Generated");
//
//test that all characters in it are truly equivalent wrt the igore-case option of regex
//
for (int i = 0; i <= 0xFFFF; i++)
{
char c = (char)i;
if (ic.IsInDomain(c))
{
BDD cC = ic.Apply(solver.MkCharConstraint(c));
foreach (char d in solver.GenerateAllCharacters(cC))
{
Assert.IsTrue(Regex.IsMatch(d.ToString(), "^(?i:" + StringUtility.Escape(c) + ")$"));
}
}
}
//
//second, test that all characters outside the domain are only equivalent (up-to-case) to themsevles
//
// for some reson this does not succeed, ??? some characters, e.g. '\xF7', are
// equivalent to some other characters in the below test, but not when tested individually
// there is a bug in Regex.IsMatch with ignore-case combined with intervals
//
//for (int i = 2; i <= 0xFFFD; i++)
//{
// char c = (char)i;
// if (!ic.IsInDomain(c))
// {
// if (Regex.IsMatch(c.ToString(), @"^([\0-" + StringUtility.Escape((char)(i - 1)) + StringUtility.Escape((char)(i + 1)) + @"-\uFFFF])$", RegexOptions.IgnoreCase))
// Console.WriteLine(StringUtility.Escape(c));
// }
//}
}
public void TestMSO_FirstC()
{
var solver = new CharSetSolver(BitWidth.BV16);
//var phi = new MSOTrue();
var x = new Variable("x", true);
MSOFormula<BDD> phi = new MSOExists<BDD>(x,
new MSOAnd<BDD>(new MSOPredicate<BDD>(solver.MkCharConstraint('C'), x), new MSOeqN<BDD>(x,0)));
var aut = phi.GetAutomaton(solver);
var aut2 = solver.RegexConverter.Convert("^C");
Assert.IsTrue(aut2.IsEquivalentWith(aut));
}
public void CheckComplement()
{
CharSetSolver solver = new CharSetSolver();
var moves = new List<Move<BDD>>();
moves.Add(new Move<BDD>(0, 1, solver.True));
moves.Add(new Move<BDD>(1, 2, solver.True));
var sfa = ThreeAutomaton<BDD>.Create(solver, 0, new int[] { 0 }, new int[] { 2 }, moves);
var csfa = sfa.MkComplement();
Assert.IsFalse(sfa.GetBiggestLanguageSFA().Intersect(csfa.GetBiggestLanguageSFA()).IsEmpty);
Assert.IsTrue(sfa.GetSmallestLanguageSFA().Intersect(csfa.GetSmallestLanguageSFA()).IsEmpty);
}
public void TestSymbolicRegex_Matches_abc()
{
var regex = new Regex("abc", RegexOptions.IgnoreCase);
var solver = new CharSetSolver();
var sr = regex.Compile(solver);
var input = "xbxabcabxxxxaBCabcxx";
Func <int, int, Tuple <int, int> > f = (x, y) => new Tuple <int, int>(x, y);
var expectedMatches = new Sequence <Tuple <int, int> >(f(3, 3), f(12, 3), f(15, 3));
var matches = new Sequence <Tuple <int, int> >(sr.Matches(input));
Assert.AreEqual <Sequence <Tuple <int, int> > >(expectedMatches, matches);
}
public void TestWS1S_Member()
{
var solver = new CharSetSolver(BitWidth.BV7);
var ca = new CartesianAlgebraBDD <BDD>(solver);
var x = new WS1SVariable <BDD>("x");
var y = new WS1SVariable <BDD>("y");
var fo_x = !x;
WS1SFormula <BDD> xSy = new WS1SSubset <BDD>(x, y);
var mem = new WS1SAnd <BDD>(xSy, fo_x);
var aut_mem = mem.GetAutomaton(ca, x, y);
//aut_mem.ShowGraph("aut_mem");
}
// returns the state reached from currState when reading c
private static int GetNextState(int currState, char c, Automaton <BDD> dfa, CharSetSolver solver)
{
foreach (var move in dfa.GetNonepsilonMovesFrom(currState))
{
if (solver.IsSatisfiable(solver.MkAnd(move.Label, solver.MkCharConstraint(false, c))))
{
return(move.TargetState);
}
}
return(-1);
}
public void TestSymbolicRegex_Matches_simple_loops()
{
var regex = new Regex("bcd|(cc)+|e+");
var solver = new CharSetSolver();
var sr = regex.Compile(solver);
var input = "cccccbcdeeeee";
Func <int, int, Tuple <int, int> > f = (x, y) => new Tuple <int, int>(x, y);
var expectedMatches = new Sequence <Tuple <int, int> >(f(0, 4), f(5, 3), f(8, 5));
var matches = new Sequence <Tuple <int, int> >(sr.Matches(input));
Assert.AreEqual <Sequence <Tuple <int, int> > >(expectedMatches, matches);
}
public static bool canRemoveState(Automaton <BDD> nfa, int state, CharSetSolver solver, Pair <IEnumerable <string>, IEnumerable <string> > tests, HashSet <char> al)
{
var newNfa = Automaton <BDD> .Create(nfa.InitialState, nfa.GetFinalStates(), nfa.GetMoves());
newNfa.RemoveTheState(state);
if (DFAUtilities.ApproximateMNEquivalent(tests, 0.5, newNfa, al, solver))
{
return(nfa.IsEquivalentWith(newNfa, solver));
}
return(false);
}
public void TestBVAlgebraMintermization()
{
var css = new CharSetSolver();
var regex = new Regex(@"^\w\d$");
var minterms = css.RegexConverter.ConvertToSymbolicRegex(regex).ComputeMinterms();
Assert.IsTrue(minterms.Length == 3);
BVAlgebra bva = new BVAlgebra(css, minterms);
var relativeminterms = new List <Tuple <bool[], BV> >(bva.GenerateMinterms(bva.atoms));
Assert.AreEqual <int>(3, relativeminterms.Count);
}
public Automaton<BDD> getDFA(BDD alphabet, CharSetSolver solver)
{
var opt = this.Normalize(solver).PushQuantifiers();
var dfa1= opt.getDFA(new List<string>(), alphabet, solver);
var moves = new List<Move<BDD>>();
foreach (var move in dfa1.GetMoves())
{
moves.Add(new Move<BDD>(move.SourceState, move.TargetState, solver.MkAnd(move.Label, alphabet)));
}
return Automaton<BDD>.Create(dfa1.InitialState, dfa1.GetFinalStates(), moves, true, true).Determinize(solver).Minimize(solver);
}
public void TestRegexComplement()
{
CharSetSolver css = new CharSetSolver();
Regex L1 = new Regex("^(([^>]|><)*(>|>[^<].*))$", RegexOptions.Singleline);
var A1 = css.Convert(L1.ToString(), L1.Options);
Regex L1n = new Regex("^([^>]([^>]|><)*(>|>[^<].*))$", RegexOptions.Singleline);
var A1n = css.Convert(L1n.ToString(), L1n.Options);
var A3 = A1.Minus(A1n).Minimize();
var L3 = css.ConvertToRegex(A3);
Console.WriteLine(L3);
}
public void TestStateDistinguisher_BugRepo2()
{
var solver = new CharSetSolver();
var regex = @"(^(?:\w\:)?(?:/|\\\\){1}[^/|\\]*(?:/|\\){1})";
var A = solver.Convert(regex).Determinize();
var states = new List <int>(A.GetStates());
var dist = new StateDistinguisher <BDD>(A);
var distmap = new List <Tuple <Tuple <int, int>, List <ConsList <BDD> > > >(dist.EnumerateAllDistinguishingSequences());
var AMin = A.Minimize();
ValidateDistinguishers(A, AMin, dist, 0, regex);
}
public void TestLoopThatStartsWith0()
{
string regex = @"(w(a|bc){0,2})";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(regex, RegexOptions.Singleline, true);
//css.ShowGraph(aut, "CornerCase");
var str = "w.-J_";
var actual = css.Accepts(aut, str);
var expected = Regex.IsMatch(str, regex);
Assert.AreEqual(expected, actual);
}
public void MkRegexFromAutomatonTest2()
{
string regex1 = @"^([\w-[\d]]|3)$";
var solver = new CharSetSolver(BitWidth.BV16);
var aut1 = solver.Convert(regex1);
//this will be a pretty large regex where the classes have been expanded
var regex2 = solver.ConvertToRegex(aut1);
var aut2 = solver.Convert(regex2);
bool equiv = aut1.IsEquivalentWith(aut2);
Assert.IsTrue(equiv);
}
private static void WriteSerializedBDDs(StreamWriter sw)
{
int maxChar = 0xFFFF;
var catMap = new Dictionary <UnicodeCategory, Ranges>();
foreach (UnicodeCategory c in Enum.GetValues <UnicodeCategory>())
{
catMap[c] = new Ranges();
}
Ranges whitespace = new Ranges();
Regex whitespaceRegex = new(@"\s");
for (int i = 0; i <= maxChar; i++)
{
char ch = (char)i;
catMap[char.GetUnicodeCategory(ch)].Add(i);
if (whitespaceRegex.IsMatch(ch.ToString()))
{
whitespace.Add(i);
}
}
//generate bdd reprs for each of the category ranges
BDD[] catBDDs = new BDD[catMap.Count];
CharSetSolver bddb = new CharSetSolver();
for (int c = 0; c < catBDDs.Length; c++)
{
catBDDs[c] = bddb.CreateBddForIntRanges(catMap[(UnicodeCategory)c].ranges);
}
BDD whitespaceBdd = bddb.CreateBddForIntRanges(whitespace.ranges);
sw.WriteLine(" /// <summary>Serialized BDD representations of all the Unicode categories.</summary>");
sw.WriteLine(" public static readonly byte[][] AllCategoriesSerializedBDD = new byte[][]");
sw.WriteLine(" {");
for (int i = 0; i < catBDDs.Length; i++)
{
sw.WriteLine(" // {0}({1}):", (UnicodeCategory)i, i);
sw.Write(" ");
GeneratorHelper.WriteByteArrayInitSyntax(sw, catBDDs[i].SerializeToBytes());
sw.WriteLine(",");
}
sw.WriteLine(" };");
sw.WriteLine();
sw.WriteLine(" /// <summary>Serialized BDD representation of the set of all whitespace characters.</summary>");
sw.Write($" public static readonly byte[] WhitespaceSerializedBDD = ");
GeneratorHelper.WriteByteArrayInitSyntax(sw, whitespaceBdd.SerializeToBytes());
sw.WriteLine(";");
}
public void GenerateMintermsTest1()
{
CharSetSolver bddb = new CharSetSolver(BitWidth.BV16);
BDD a = bddb.MkRangeConstraint('a', 'a');
BDD b = bddb.MkRangeConstraint('b', 'b');
BDD c = bddb.MkRangeConstraint('c', 'c');
var combinations = new List <Pair <bool[], BDD> >(bddb.GenerateMinterms(new BDD[] { a, b, c }));
Assert.AreEqual <int>(4, combinations.Count);
}
public void TestMSO_Member()
{
var solver = new CharSetSolver(BitWidth.BV7);
var ca = new CartesianAlgebraBDD<BDD>(solver);
var x = new Variable("x", false);
var y = new Variable("y", false);
var fo_x = new MSOIsSingleton<BDD>(x);
MSOFormula<BDD> xSy = new MSOSubset<BDD>(x, y);
var mem = new MSOAnd<BDD>(xSy, fo_x);
var aut_mem = mem.GetAutomaton(ca);
//aut_mem.ShowGraph("aut_mem");
}
public void TestNFA1()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV7);
var nfa = Automaton<BDD>.Create(solver, 0, new int[] { 1 }, new Move<BDD>[] { new Move<BDD>(0, 1, solver.True), new Move<BDD>(0, 2, solver.True), new Move<BDD>(2, 1, solver.True) });
var min_nfa = nfa.Minimize();
nfa.isDeterministic = true; //pretend that nfa is equivalent, causes the deterministic version to be executed that provides the wrong result
var min_nfa_wrong = nfa.Minimize();
nfa.isDeterministic = false;
min_nfa_wrong.isDeterministic = false;
Assert.IsFalse(min_nfa.IsEquivalentWith(min_nfa_wrong));
Assert.IsTrue(min_nfa.IsEquivalentWith(nfa));
}
private static Dictionary<char, BDD> ComputeIgnoreCaseDistionary(CharSetSolver solver)
{
var ignoreCase = new Dictionary<char, BDD>();
for (uint i = 0; i <= 0xFFFF; i++)
{
char c = (char)i;
char cU = char.ToUpper(c); // (char.IsLetter(char.ToUpper(c)) ? char.ToUpper(c) : c);
char cL = char.ToLower(c); // (char.IsLetter(char.ToLower(c)) ? char.ToLower(c) : c);
if (c != cU || c != cL || cU != cL)
{
//make sure that the regex engine considers c as being equivalent to cU and cL, else ignore c
//in some cases c != cU but the regex engine does not consider the chacarters equivalent wrt the ignore-case option.
//These characters are:
//c=\xB5,cU=\u039C
//c=\u0131,cU=I
//c=\u017F,cU=S
//c=\u0345,cU=\u0399
//c=\u03C2,cU=\u03A3
//c=\u03D0,cU=\u0392
//c=\u03D1,cU=\u0398
//c=\u03D5,cU=\u03A6
//c=\u03D6,cU=\u03A0
//c=\u03F0,cU=\u039A
//c=\u03F1,cU=\u03A1
//c=\u03F5,cU=\u0395
//c=\u1E9B,cU=\u1E60
//c=\u1FBE,cU=\u0399
if (System.Text.RegularExpressions.Regex.IsMatch(cU.ToString() + cL.ToString(), "^(?i:" + StringUtility.Escape(c) + ")+$"))
{
BDD equiv = solver.False;
if (ignoreCase.ContainsKey(c))
equiv = equiv.Or(ignoreCase[c]);
if (ignoreCase.ContainsKey(cU))
equiv = equiv.Or(ignoreCase[cU]);
if (ignoreCase.ContainsKey(cL))
equiv = equiv.Or(ignoreCase[cL]);
equiv = equiv.Or(solver.MkCharSetFromRange(c, c)).Or(solver.MkCharSetFromRange(cU, cU)).Or(solver.MkCharSetFromRange(cL, cL));
foreach (char d in solver.GenerateAllCharacters(equiv))
ignoreCase[d] = equiv;
}
//else
//{
// outp += "c=" + StringUtility.Escape(c) + "," + "cU=" + StringUtility.Escape(cU);
// Console.WriteLine("c=" + StringUtility.Escape(c) + "," + "cL=" + StringUtility.Escape(cL) + "," + "cU=" + StringUtility.Escape(cU));
//}
}
}
return ignoreCase;
}
public void TestRegexFromTodd()
{
var regex = @"^.*[a-zA-Z][a-zA-Z0-9.\-_]{5,10}$";
var solver = new CharSetSolver(BitWidth.BV16);
var fat = solver.Convert(regex, System.Text.RegularExpressions.RegexOptions.Singleline);
//solver.ShowGraph(fat, "fat");
var fat1 = fat.Determinize();
//solver.ShowGraph(fat1, "fat1");
var fat2 = fat1.Minimize();
//solver.ShowGraph(fat2, "fat2");
Assert.IsTrue(fat1.IsEquivalentWith(fat2));
}
public Automaton <BDD> getDFA(BDD alphabet, CharSetSolver solver)
{
var opt = this.Normalize(solver).PushQuantifiers();
var dfa1 = opt.getDFA(new List <string>(), alphabet, solver);
var moves = new List <Move <BDD> >();
foreach (var move in dfa1.GetMoves())
{
moves.Add(new Move <BDD>(move.SourceState, move.TargetState, solver.MkAnd(move.Label, alphabet)));
}
return(Automaton <BDD> .Create(dfa1.InitialState, dfa1.GetFinalStates(), moves, true, true).Determinize(solver).Minimize(solver));
}
public void TestCharClassRepetitionToSFA()
{
var regex = @"^.*\d\w{5,7}$";
var solver = new CharSetSolver(BitWidth.BV7);
var fat = solver.Convert(regex, System.Text.RegularExpressions.RegexOptions.Singleline);
//solver.ShowGraph(fat, "fat");
var fat1 = fat.Determinize();
//solver.ShowGraph(fat1, "fat1");
var fat2 = fat1.Minimize();
//solver.ShowGraph(fat2, "fat2");
Assert.IsTrue(fat1.IsEquivalentWith(fat2));
}
public static Pair <List <string>, List <string> > GetTestSets(
Automaton <BDD> dfa, HashSet <char> alphabet, CharSetSolver solver)
{
List <string> positive = new List <string>();
List <string> negative = new List <string>();
var finalStates = dfa.GetFinalStates().ToList();
ComputeModels("", dfa.InitialState, dfa, finalStates, alphabet, solver, positive, negative);
positive.Sort();
negative.Sort();
return(new Pair <List <string>, List <string> >(positive, negative));
}
public override WS1SFormula Normalize(CharSetSolver solver)
{
if (phi is WS1SNot)
{
return((phi as WS1SNot).phi.Normalize(solver));
}
if (phi is WS1SUnaryPred)
{
var cphi = phi as WS1SUnaryPred;
return(new WS1SUnaryPred(cphi.set, solver.MkNot(cphi.pred)));
}
return(new WS1SNot(phi.Normalize(solver)));;
}
public void TestHardRegex1()
{
//string regex = @".*MRU.*|.*FilledAppTile.*|.*System.*Tiles.*|.*SnappedAppTile.*|.*Installed.*|.*Installing.*|.*ReadyToInstall.*";
string regex = @".*viewingoption.*|.*gameclips.*|.*seasons.*|.*rottentomatocriticreview.*|.*rottentomatorating.*|.*showtimes.*|.*purchaseoptions.*|.*broadcasts.*|.*buttons.*|.*episodes.*";
//string regex = @"MRU|FilledAppTile|System.*Tiles|SnappedAppTile|Installed|Installing|ReadyToInstall";
CharSetSolver solver = new CharSetSolver();
var aut = solver.Convert(regex, RegexOptions.Singleline);
//var autEpsFree = aut.RemoveEpsilons(solver.MkOr);
//autEpsFree.ShowGraph("autEpsFree");
var autDet = aut.Determinize();
var autMin = autDet.Minimize();
//autMin.ShowGraph("autMin");
}
public void CheckMinimization()
{
CharSetSolver solver = new CharSetSolver();
var moves = new List <Move <BDD> >();
moves.Add(new Move <BDD>(0, 1, solver.True));
moves.Add(new Move <BDD>(1, 2, solver.True));
var sfa1 = ThreeAutomaton <BDD> .Create(solver, 0, new int[] { 0 }, new int[] { 2 }, moves);
var min = sfa1.Minimize(solver);
Assert.IsTrue(min.StateCount == 4);
}
public void ParseRegex()
{
try
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
var al = new HashSet <char>(new char[] { 'a', 'b' });
DFAUtilities.parseRegexFromXML(XElement.Parse("<reg>-?</reg>"), XElement.Parse("<alphabet><symbol>a</symbol><symbol>b</symbol></alphabet>"), solver);
}
catch (PDLException e)
{
Console.WriteLine(e.Message);
}
}
//private static void Grade
private static int GradeSingle(string file1, string file2)
{
List <char> alph = new List <char> {
'a', 'b'
};
HashSet <char> al = new HashSet <char>(alph);
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
var aut1 = DFAUtilities.parseDFAfromTutor(file1, solver);
var aut2 = DFAUtilities.parseDFAfromEvent(file2, solver);
var dfa1 = aut1.Second; var dfa2 = aut2.Second;
return(Grading.GetGrade(dfa1, dfa2, al, solver, 20000, 10).First);
}
/// <summary>
/// Computes the ratio of the symmetric difference to the size of dfa1 enumerating paths up to length n (uses the complement if density is high)
/// </summary>
/// <returns>size of ((dfa2-dfa1)+(dfa1-dfa2))/dfa1</returns>
public static double GetDFADifferenceRatio(Automaton<BDD> dfa1, Automaton<BDD> dfa2, HashSet<char> al, CharSetSolver solver)
{
var solutionDensity = DFADensity.GetDFADensity(dfa1, al, solver);
//Symmetric difference
var dfadiff1 = dfa1.Minus(dfa2, solver);
var dfadiff2 = dfa2.Minus(dfa1, solver);
var dfatrue = Automaton<BDD>.Create(0, new int[] { 0 }, new Move<BDD>[] { new Move<BDD>(0, 0, solver.True) });
var dfadiff = dfatrue.Minus(dfatrue.Minus(dfadiff1, solver).Intersect(dfatrue.Minus(dfadiff2, solver), solver), solver).Determinize(solver).Minimize(solver);
//Use smallest of |dfa1| and complement of |dfa1| for cardinality base
return GetDFARatio(dfa1.Determinize(solver).Minimize(solver), dfadiff, al, solver, solutionDensity > 0.5);
}
public void TestSymbolicRegex_Matches_bounded_loops()
{
var regex = new Regex("a{2,4}");
var solver = new CharSetSolver();
var sr = regex.Compile(solver);
var input = "..aaaaaaaaaaa..";
Func <int, int, Tuple <int, int> > f = (x, y) => new Tuple <int, int>(x, y);
var expectedMatches = new Sequence <Tuple <int, int> >(f(2, 4), f(6, 4), f(10, 3));
var matches = new Sequence <Tuple <int, int> >(sr.Matches(input));
Assert.AreEqual <int>(3, matches.Length);
Assert.AreEqual <Sequence <Tuple <int, int> > >(expectedMatches, matches);
}
public void TestWordBoundaryCase()
{
string s = "abc";
string r = @"\b";
CharSetSolver css = new CharSetSolver(BitWidth.BV7);
var aut = css.Convert(r, RegexOptions.Singleline, true);
//css.ShowGraph(aut, "test1");
css.RegexConverter.EliminateBoundaryStates(aut);
//css.ShowGraph(aut,"test2");
Assert.IsTrue(css.Accepts(aut, s));
Assert.IsTrue(Regex.IsMatch(s, r, RegexOptions.Singleline));
}
public void GradingNFAEps()
{
var solver = new CharSetSolver(BitWidth.BV64);
List <char> alph = new List <char> {
'a', 'b'
};
HashSet <char> al = new HashSet <char>(alph);
var a = solver.MkCharConstraint(false, 'a');
var b = solver.MkCharConstraint(false, 'b');
var movesSol = new List <Move <BDD> >();
movesSol.Add(new Move <BDD>(5, 0, null));
movesSol.Add(new Move <BDD>(0, 0, a));
movesSol.Add(new Move <BDD>(0, 0, b));
movesSol.Add(new Move <BDD>(0, 1, a));
movesSol.Add(new Move <BDD>(1, 2, b));
var nfa1 = Automaton <BDD> .Create(5, new int[] { 2 }, movesSol);
var movesAtt = new List <Move <BDD> >();
movesAtt.Add(new Move <BDD>(0, 0, a));
movesAtt.Add(new Move <BDD>(0, 1, b));
movesAtt.Add(new Move <BDD>(1, 1, b));
movesAtt.Add(new Move <BDD>(1, 2, a));
movesAtt.Add(new Move <BDD>(2, 2, a));
movesAtt.Add(new Move <BDD>(2, 3, b));
movesAtt.Add(new Move <BDD>(3, 3, b));
movesAtt.Add(new Move <BDD>(3, 4, a));
movesAtt.Add(new Move <BDD>(4, 4, a));
movesAtt.Add(new Move <BDD>(4, 4, b));
var nfa2 = Automaton <BDD> .Create(0, new int[] { 4 }, movesAtt);
List <Pair <int, IEnumerable <NFAFeedback> > > tests = new List <Pair <int, IEnumerable <NFAFeedback> > >();
tests.Insert(0, NFAGrading.GetGrade(nfa1, nfa2, al, solver, timeout, 10, FeedbackLevel.Hint));
tests.Insert(0, NFAGrading.GetGrade(nfa2, nfa1, al, solver, timeout, 10, FeedbackLevel.Hint));
tests.Insert(0, NFAGrading.GetGrade(nfa1, nfa1, al, solver, timeout, 10, FeedbackLevel.Hint));
tests.Insert(0, NFAGrading.GetGrade(nfa2, nfa2, al, solver, timeout, 10, FeedbackLevel.Hint));
foreach (var test in tests)
{
Console.WriteLine("grade: {0}, ", test.First);
foreach (var f in test.Second)
{
Console.WriteLine(f.ToString());
}
}
}
public void FlabioNFA2()
{
var solver = new CharSetSolver(BitWidth.BV64);
List <char> alph = new List <char> {
'1', '0'
};
HashSet <char> al = new HashSet <char>(alph);
var o = solver.MkCharConstraint(false, '1');
var z = solver.MkCharConstraint(false, '0');
var movesSolution = new List <Move <BDD> >();
movesSolution.Add(new Move <BDD>(0, 1, null));
movesSolution.Add(new Move <BDD>(0, 2, null));
movesSolution.Add(new Move <BDD>(1, 1, z));
movesSolution.Add(new Move <BDD>(1, 1, o));
movesSolution.Add(new Move <BDD>(1, 3, z));
movesSolution.Add(new Move <BDD>(2, 2, o));
var dfaSolution = Automaton <BDD> .Create(0, new int[] { 2, 3 }, movesSolution);
var movesAttempt = new List <Move <BDD> >();
movesAttempt.Add(new Move <BDD>(0, 1, null));
movesAttempt.Add(new Move <BDD>(0, 3, null));
movesAttempt.Add(new Move <BDD>(1, 2, z));
movesAttempt.Add(new Move <BDD>(2, 1, o));
movesAttempt.Add(new Move <BDD>(2, 2, z));
movesAttempt.Add(new Move <BDD>(1, 1, o));
movesAttempt.Add(new Move <BDD>(3, 4, o));
movesAttempt.Add(new Move <BDD>(4, 4, o));
var dfaAttempt = Automaton <BDD> .Create(0, new int[] { 4, 2 }, movesAttempt);
var gr = NFAGrading.GetGrade(dfaSolution, dfaAttempt, al, solver, 1500, 10, FeedbackLevel.Hint);
Console.WriteLine(gr.First);
foreach (var f in gr.Second)
{
Console.WriteLine(f.ToString());
}
gr = NFAGrading.GetGrade(dfaAttempt, dfaSolution, al, solver, 1500, 10, FeedbackLevel.Hint);
Console.WriteLine(gr.First);
foreach (var f in gr.Second)
{
Console.WriteLine(f.ToString());
}
}
public void CheckComplement()
{
CharSetSolver solver = new CharSetSolver();
var moves = new List <Move <BDD> >();
moves.Add(new Move <BDD>(0, 1, solver.True));
moves.Add(new Move <BDD>(1, 2, solver.True));
var sfa = ThreeAutomaton <BDD> .Create(solver, 0, new int[] { 0 }, new int[] { 2 }, moves);
var csfa = sfa.MkComplement();
Assert.IsFalse(sfa.GetBiggestLanguageSFA().Intersect(csfa.GetBiggestLanguageSFA(), solver).IsEmpty);
Assert.IsTrue(sfa.GetSmallestLanguageSFA().Intersect(csfa.GetSmallestLanguageSFA(), solver).IsEmpty);
}
public void TestMSO_FirstLastZ3()
{
var solver = new CharSetSolver(BitWidth.BV16);
var x = new Variable("x", true);
MSOFormula<BDD> phi = new MSOExists<BDD>(x, new MSOAnd<BDD>(new MSOeqN<BDD>(x,0), new MSOLast<BDD>(x)));
var aut = phi.GetAutomaton(solver);
var res = solver.Convert("^[\0-\uFFFF]$");
//solver.ShowGraph(res,"res");
//solver.SaveAsDgml(res, "res");
var eq = aut.IsEquivalentWith(res);
Assert.IsTrue(eq);
}
