public void MkRegexFromAutomatonOf_3_Divisibility()
{
var solver = new CharSetSolver(BitWidth.BV7);
var _0 = solver.MkCharConstraint('a');
var _3 = solver.MkCharConstraint('d');
var _03 = solver.MkOr(_0, _3);
var _1 = solver.MkCharConstraint('b');
var _2 = solver.MkCharConstraint('c');
var moves = new Move <BDD>[] {
Move <BDD> .Create(0, 0, _03),
Move <BDD> .Create(0, 1, _2),
Move <BDD> .Create(0, 2, _1),
Move <BDD> .Create(1, 1, _03),
Move <BDD> .Create(1, 0, _1),
Move <BDD> .Create(1, 2, _2),
Move <BDD> .Create(2, 2, _03),
Move <BDD> .Create(2, 0, _2),
Move <BDD> .Create(2, 1, _1)
};
var aut = Automaton <BDD> .Create(solver, 0, new int[] { 0 }, moves);
//solver.ShowGraph(aut, "div3a");
string regex = solver.ConvertToRegex(aut).Replace("[ad]", "(a|d)").Replace("[b]", "b").Replace("[c]", "c");
var aut2 = solver.Convert(regex).Determinize().MinimizeHopcroft();
// solver.ShowGraph(aut2, "div3b");
bool equiv = aut.IsEquivalentWith(aut2);
Assert.IsTrue(equiv);
//binary version of the regex
string regex01 = regex.Replace("a", "00").Replace("b", "01").Replace("c", "10").Replace("d", "11");
var bits30 = solver.Convert("^[01]{10,30}\\z");
var aut01_ = solver.Convert(regex01).Determinize();
//solver.ShowGraph(aut01_, "aut01_");
var aut01 = aut01_.MinimizeHopcroft();
//solver.ShowGraph(aut01, "aut01");
string regex01small = solver.ConvertToRegex(aut01);
aut01 = aut01.Intersect(bits30);
//genarate some random paths in this automaton and check that the binary representation is a numer that is divisible by 3.
for (int i = 0; i < 1000; i++)
{
string sample = solver.ChooseString(aut01.ChoosePathToSomeFinalState(solver.Chooser));
int m = 0;
for (int j = sample.Length - 1; j >= 0; j--)
{
if (sample[j] == '0')
{
m = m << 1;
}
else
{
m = (m << 1) | 1;
}
}
bool div3 = ((m % 3) == 0);
Assert.IsTrue(div3);
}
}
public static XElement getTwoWordsInstructorFeedback(XElement regex, XElement xAlphabet, XElement first, XElement second)
{
string firstString = (XElement.Parse(DFAUtilities.RemoveAllNamespaces(first.ToString()))).Value.Trim();
string secondString = (XElement.Parse(DFAUtilities.RemoveAllNamespaces(second.ToString()))).Value.Trim();
HashSet <char> alphabet = parseAlphabet(xAlphabet);
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
var dfaPair = DFAUtilities.parseRegexFromXML(regex, xAlphabet, solver);
var dfa = dfaPair.Second.Determinize(solver).Minimize(solver);
firstString = firstString.decodeEpsilon();
secondString = secondString.decodeEpsilon();
int firstState = DFAUtilities.GetStateAfterString(dfa.InitialState, firstString, dfa, solver);
int secondState = DFAUtilities.GetStateAfterString(dfa.InitialState, secondString, dfa, solver);
bool areEquivalent = (firstState == secondState);
if (areEquivalent)
{
var suffixDfa = Automaton <BDD> .Create(firstState, dfa.GetFinalStates(), dfa.GetMoves());
var suffixRegex = solver.ConvertToRegex(suffixDfa);
suffixRegex = regexToTraditional(suffixRegex);
return(XElement.Parse(String.Format("<div><feedback> The words '{0}' and '{1}' are equivalent. The language of suffixes is '{2}'</feedback></div>", firstString, secondString, suffixRegex)));
}
else
{
var shortestDiff = DFAUtilities.GetDifferentiatingWord(firstState, secondState, dfa, alphabet, solver).Second;
return(XElement.Parse(String.Format("<div><feedback> The words '{0}' and '{1}' are NOT equivalent. The shortest differentiating word is '{2}'</feedback></div>", firstString, secondString, shortestDiff)));
}
}
public void MkRegexFromAutomatonTest1()
{
var solver = new CharSetSolver(BitWidth.BV7);
string regexA = "^abc(d|[a-ce-g])*$";
var A = solver.Convert(regexA).Determinize().MinimizeHopcroft();
string a = solver.ConvertToRegex(A);
Assert.AreEqual <string>("^(abc([a-g])*)$", a);
}
public void MkLengthAutomatonTest()
{
var solver = new CharSetSolver(BitWidth.BV7);
string regexA = "^(((((00|11)|10((00|11))*01)|(01|10((00|11))*10)(((00|11)|01((00|11))*10))*(10|01((00|11))*01)))*)$";
BDD _1 = solver.MkCharConstraint('1');
var A = solver.Convert(regexA).RelpaceAllGuards(x => (x == null ? null : _1));
var B = A.Determinize().MinimizeHopcroft();
var lengthregex = solver.ConvertToRegex(B);
Assert.AreEqual <string>("^((11)*)$", lengthregex);
}
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 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);
}
static void TestRegex(Regex regex)
{
var solver = new CharSetSolver();
string myregex = regex.ToString();
//Regex.CompileToAssembly(new RegexCompilationInfo[] { new RegexCompilationInfo(myregex, RegexOptions.None, "EvilRegex", "RegexTransfomer", true) },
// new System.Reflection.AssemblyName("EvilRegex"));
var sfa = solver.Convert(myregex, regex.Options).RemoveEpsilons();
var sfaDet = sfa.Determinize();
var sfaMin = sfaDet.Minimize();
//solver.ShowGraph(sfa, "sfa");
//solver.ShowGraph(sfaDet, "sfaDet");
//solver.ShowGraph(sfaMin, "sfaMin");
var cs = solver.ToCS(sfaMin, true, "MyRegex", "RegexTransfomer");
var regexMin = solver.ConvertToRegex(sfaMin);
Console.WriteLine("------- given regex --------");
Console.WriteLine(myregex);
Console.WriteLine("----------------------------");
Console.WriteLine("-------- regexMin ----------");
Console.WriteLine(regexMin);
Console.WriteLine("----------------------------");
Console.WriteLine("-------- cs ----------------");
// Console.WriteLine(cs.SourceCode);
Console.WriteLine("----------------------------");
string sIn = solver.GenerateMember(sfaMin);
string sOut = solver.GenerateMember(sfaMin.Complement());
string s = sIn;
int t1;
//int t2;
int t3;
for (int i = 0; i < 2; i++)
{
//original regex
t1 = System.Environment.TickCount;
bool res1 = false;
for (int j = 0; j < 100000; j++)
{
res1 = Regex.IsMatch(s, regex.ToString(), regex.Options);
}
//res1 = evilregex.IsMatch(s);
t1 = System.Environment.TickCount - t1;
////minimized regex
//t2 = System.Environment.TickCount;
//bool res2 = false;
//for (int j = 0; j < 100000; j++)
// res2 = Regex.IsMatch(s, regexMin, regex.Options);
//t2 = System.Environment.TickCount - t2;
//code from minimized regex
t3 = System.Environment.TickCount;
bool res3 = false;
for (int j = 0; j < 100000; j++)
{
res3 = cs.IsMatch(s);
}
t3 = System.Environment.TickCount - t3;
Console.WriteLine(String.Format("{0}ms({1}), {2}ms({3})", t1, res1, t3, res3));
s = sOut;
}
Console.WriteLine("done...(press any key)");
Console.ReadKey();
}
static void TestRegex(Regex regex)
{
var solver = new CharSetSolver();
string myregex = regex.ToString();
//Regex.CompileToAssembly(new RegexCompilationInfo[] { new RegexCompilationInfo(myregex, RegexOptions.None, "EvilRegex", "RegexTransfomer", true) },
// new System.Reflection.AssemblyName("EvilRegex"));
var sfa = solver.Convert(myregex, regex.Options).RemoveEpsilons();
var sfaDet = sfa.Determinize();
var sfaMin = sfaDet.Minimize();
//solver.ShowGraph(sfa, "sfa");
//solver.ShowGraph(sfaDet, "sfaDet");
//solver.ShowGraph(sfaMin, "sfaMin");
var cs = solver.ToCS(sfaMin, true, "MyRegex", "RegexTransfomer");
var regexMin = solver.ConvertToRegex(sfaMin);
Console.WriteLine("------- given regex --------");
Console.WriteLine(myregex);
Console.WriteLine("----------------------------");
Console.WriteLine("-------- regexMin ----------");
Console.WriteLine(regexMin);
Console.WriteLine("----------------------------");
Console.WriteLine("-------- cs ----------------");
Console.WriteLine(cs.SourceCode);
Console.WriteLine("----------------------------");
string sIn = solver.GenerateMember(sfaMin);
string sOut = solver.GenerateMember(sfaMin.Complement());
string s = sIn;
int t1;
int t2;
int t3;
for (int i = 0; i < 2; i++)
{
//original regex
t1 = System.Environment.TickCount;
bool res1 = false;
for (int j = 0; j < 100000; j++)
res1 = Regex.IsMatch(s, regex.ToString(), regex.Options);
//res1 = evilregex.IsMatch(s);
t1 = System.Environment.TickCount - t1;
////minimized regex
//t2 = System.Environment.TickCount;
//bool res2 = false;
//for (int j = 0; j < 100000; j++)
// res2 = Regex.IsMatch(s, regexMin, regex.Options);
//t2 = System.Environment.TickCount - t2;
//code from minimized regex
t3 = System.Environment.TickCount;
bool res3 = false;
for (int j = 0; j < 100000; j++)
res3 = cs.IsMatch(s);
t3 = System.Environment.TickCount - t3;
Console.WriteLine(String.Format("{0}ms({1}), {2}ms({3})", t1, res1, t3, res3));
s = sOut;
}
Console.WriteLine("done...(press any key)");
Console.ReadKey();
}
