//
private void runUnderapproxTest(string testName)
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
int printLimit = 10;
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
var dfa_al = ReadDFA(testName, solver);
//PrintDFA(dfa_al.Second, "A", dfa_al.First);
StringBuilder sb = new StringBuilder();
int i = 0;
foreach (var pair in pdlEnumerator.SynthesizeUnderapproximationPDL(dfa_al.First, dfa_al.Second, solver, sb, timeout))
{
i++;
pair.First.ToString(sb);
sb.AppendLine(" ### +" + pair.Second.ToString() + " ### +" + pair.First.GetFormulaSize());
sb.AppendLine();
if (i == printLimit)
{
break;
}
}
System.Console.WriteLine(sb);
}
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 DileepTest1()
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
PDLPred phi = new PDLAtSet('a', new PDLPredSet("x", new PDLModSetEq(new PDLAllPosBefore(new PDLPosVar("x")), 2, 1)));
var solver = new CharSetSolver(BitWidth.BV64);
var alph = new List <char> {
'a', 'b'
};
var al = new HashSet <char>(alph);
var dfa = phi.GetDFA(al, solver);
//solver.SaveAsDot(dfa, "C:/Users/Dileep/Desktop/oddPos.dot");
PDLPred synthPhi = null;
StringBuilder sb = new StringBuilder();
foreach (var phi1 in pdlEnumerator.SynthesizePDL(al, dfa, solver, sb, 10000))
{
synthPhi = phi1;
break;
}
Console.WriteLine(sb);
}
private List <Pair <PDLPred, long> > SynthTimer(PDLPred phi, HashSet <char> al, StringBuilder sb)
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
var solver = new CharSetSolver(BitWidth.BV64);
Stopwatch sw = new Stopwatch();
var dfa = phi.GetDFA(al, solver);
List <Pair <PDLPred, long> > predList = new List <Pair <PDLPred, long> >();
List <PDLPred> phiList = new List <PDLPred>();
PDLPred v;
var func = new Func <PDLPred>(() =>
{
sw.Start();
foreach (var p in pdlEnumerator.SynthesizePDL(al, dfa, solver, new StringBuilder(), 5000))
{
sw.Stop();
predList.Add(new Pair <PDLPred, long>(p, sw.ElapsedMilliseconds));
sw.Start();
}
return(null);
});
var test = TryExecute(func, timeout, out v);
phi.ToString(sb);
sb.AppendLine();
sb.AppendLine("=");
foreach (var pair in predList)
{
sb.AppendLine();
pair.First.ToString(sb);
sb.AppendLine();
sb.AppendLine("Elapsed Time: " + pair.Second + " ms");
}
return(predList);
}
private void runTest(string testName)
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
CharSetSolver solver = new CharSetSolver(BitWidth.BV64);
var dfa_al = ReadDFA(testName, solver);
PDLPred synthPhi = null;
StringBuilder sb = new StringBuilder();
sb.AppendLine("*------------------------------------");
sb.AppendLine("| " + testName);
sb.AppendLine("|------------------------------------");
foreach (var phi in pdlEnumerator.SynthesizePDL(dfa_al.First, dfa_al.Second, solver, sb, timeout))
{
synthPhi = phi;
break;
}
sb.AppendLine("*------------------------------------");
sb.AppendLine();
System.Console.WriteLine(sb);
}
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 DileepTest()
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
PDLPred phi = new PDLIntGeq(new PDLIndicesOf("ab"), 2);
var solver = new CharSetSolver(BitWidth.BV64);
var alph = new List <char> {
'a', 'b'
};
var al = new HashSet <char>(alph);
var dfa = phi.GetDFA(al, solver);
PDLPred synthPhi = null;
StringBuilder sb = new StringBuilder();
foreach (var phi1 in pdlEnumerator.SynthesizePDL(al, dfa, solver, sb, 10000))
{
synthPhi = phi1;
break;
}
Console.WriteLine(sb);
}
private List <Pair <int, Pair <PDLPred, long> > > SynthTimer(PDLPred phi, HashSet <char> al, StringBuilder sb)
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
var solver = new CharSetSolver(BitWidth.BV64);
Stopwatch sw = new Stopwatch();
var dfa = DFAUtilities.normalizeDFA(phi.GetDFA(al, solver)).First;
List <Pair <int, Pair <PDLPred, long> > > predList = new List <Pair <int, Pair <PDLPred, long> > >();
List <PDLPred> phiList = new List <PDLPred>();
PDLPred v;
var func = new Func <PDLPred>(() =>
{
foreach (var state in dfa.States)
{
var dfaSt = Automaton <BDD> .Create(dfa.InitialState, new int[] { state }, dfa.GetMoves());
dfaSt = dfaSt.Determinize(solver).Minimize(solver);
sw.Reset();
sw.Start();
foreach (var p in pdlEnumerator.SynthesizePDL(al, dfaSt, solver, new StringBuilder(), 3000))
{
sw.Stop();
predList.Add(new Pair <int, Pair <PDLPred, long> >(state, new Pair <PDLPred, long>(p, sw.ElapsedMilliseconds)));
break;
}
}
return(null);
});
var test = TryExecute(func, timeout, out v);
sb.Append("Language: ");
phi.ToString(sb);
sb.AppendLine();
//sb.AppendLine("States: "+dfa.StateCount);
sb.AppendLine();
sb.AppendLine("---------------------------");
sb.AppendLine("STATE SUMMARY");
sb.AppendLine("---------------------------");
var coveredStates = new HashSet <int>();
foreach (var pair in predList)
{
sb.AppendLine();
coveredStates.Add(pair.First);
sb.AppendLine("State " + pair.First + (((dfa.GetFinalStates()).Contains(pair.First))?(" is final"):("")));
sb.AppendLine("Elapsed Time: " + pair.Second.Second + " ms");
sb.AppendLine("Formula: ");
pair.Second.First.ToString(sb);
sb.AppendLine();
}
sb.AppendLine();
foreach (var state in dfa.States)
{
if (!coveredStates.Contains(state))
{
sb.AppendLine(string.Format("description for state {0} not found", state));
}
}
return(predList);
}
public override string ToString()
{
long enumTimeout = 1000L;
#region feedback components
PDLEnumerator pdlEnumerator = new PDLEnumerator();
PDLPred symmPhi = null;
PDLPred underPhi = null;
string posWitness = null;
string negWitness = null;
//If hint or solution try computing the description of the symmdiff
if (level == FeedbackLevel.Hint || level == FeedbackLevel.Solution)
{
//Avoid formulas that are too complex
var maxSize = 7;
if (symmetricDifference.StateCount < 15)
{
foreach (var phi1 in pdlEnumerator.SynthesizePDL(alphabet, symmetricDifference, solver, new StringBuilder(), enumTimeout))
{
var sizePhi1 = phi1.GetFormulaSize();
if (sizePhi1 < maxSize && !phi1.IsComplex())
{
maxSize = sizePhi1;
symmPhi = phi1;
}
}
}
}
//Avoid empty string case and particular string
if (symmPhi is PDLEmptyString || symmPhi is PDLIsString)
{
symmPhi = null;
}
//If not minimal try computing and underapprox of symmdiff
if (symmPhi == null && level != FeedbackLevel.Minimal)
{
//Avoid formulas that are too complex
var minSize = 9;
if (symmetricDifference.StateCount < 15)
{
foreach (var phi2 in pdlEnumerator.SynthesizeUnderapproximationPDL(alphabet, symmetricDifference, solver, new StringBuilder(), enumTimeout))
{
var formula = phi2.First;
var sizeForm = formula.GetFormulaSize();
if (sizeForm < minSize && !formula.IsComplex())
{
minSize = sizeForm;
underPhi = formula;
}
break;
}
}
}
//Avoid empty string case and particular string
if (underPhi is PDLEmptyString || underPhi is PDLIsString)
{
underPhi = null;
}
if (!positiveDifference.IsEmpty)
{
posWitness = DFAUtilities.GenerateShortTerm(positiveDifference, solver);
}
else
{
negWitness = DFAUtilities.GenerateShortTerm(negativeDifference, solver);
}
#endregion
string result = ""; //string.Format("U: {0}%. ", utility);
if (symmPhi != null)
{
if (symmPhi is PDLEmptyString)
{
result += "Your solution does not behave correctly on the empty string";
}
else
{
result += string.Format("Your solution is not correct on this set of strings: <br /> <div align='center'>{0}</div>", PDLUtil.ToEnglishString(symmPhi));
}
}
else
if (underPhi != null)
{
if (underPhi is PDLEmptyString)
{
result += "Your solution does not behave correctly on the empty string";
}
else
{
result += string.Format("Your solution is not correct on this set of strings: <br /> <div align='center'>{0}</div>",
PDLUtil.ToEnglishString(underPhi));
}
}
else
{
if (posWitness != null)
{
result += string.Format("Your solution does not accept the {0} while the correct solution does.",
posWitness != "" ? "string '<i>" + posWitness + "</i>'" : "empty string");
}
else
{
result += string.Format("Your solution accepts the {0} while the correct solution doesn't.",
negWitness != "" ? "string '<i>" + negWitness + "</i>'" : "empty string");
}
}
return(result);
}
/// <summary>
/// Computes the grade for attempt using all the possible metrics
/// </summary>
/// <param name="dfaGoal">minimal correct dfa</param>
/// <param name="dfaAttempt">dfa to be graded</param>
/// <param name="al">input alphabet</param>
/// <param name="solver">SMT solver for char set</param>
/// <param name="timeout">timeout for the PDL enumeration (suggested > 1000)</param>
/// <param name="maxGrade">Max grade for the homework</param>
/// <param name="enableDFAED">true to enable DFA edit distance</param>
/// <param name="enablePDLED">true to enable PDL edit distance</param>
/// <param name="enableDensity">true to enable density distance</param>
/// <returns>Grade for dfa2</returns>
public static Pair <int, IEnumerable <DFAFeedback> > GetGrade(
Automaton <BDD> dfaGoal, Automaton <BDD> dfaAttempt, HashSet <char> al,
CharSetSolver solver, long timeout,
int maxGrade, FeedbackLevel level,
bool enableDFAED, bool enablePDLED, bool enableDensity)
{
PDLEnumerator pdlEnumerator = new PDLEnumerator();
var feedList = new List <DFAFeedback>();
DFAFeedback defaultFeedback = new StringFeedback(level, StringFeedbackType.Wrong, al, solver);
#region Accessory and initial vars
//Compute minimized version of DFAs
var dfaGoalMin = dfaGoal.Determinize(solver).Minimize(solver);
var dfaAttemptMin = dfaAttempt.Determinize(solver).Minimize(solver);
//Initialize distances at high values in case they are not used
// they only produce positive grade if between 0 and 1
double pdlEditDistanceScaled = 2;
double densityRatio = 2;
double dfaED = 2;
#endregion
#region deductions on the grade based on the size of the dfa
//Deduction if DFA is smaller than it should be: used only for PDL ed and for density
var smallerDFADeduction = 0.2 * Math.Sqrt(
Math.Max(0.0, dfaGoalMin.StateCount - dfaAttemptMin.StateCount) /
((double)dfaGoalMin.StateCount));
#endregion
#region check whether the attempt is equivalent to the solution
if (dfaGoal.IsEquivalentWith(dfaAttempt, solver))
{
Console.WriteLine("Correct");
feedList.Add(new StringFeedback(level, StringFeedbackType.Correct, al, solver));
return(new Pair <int, IEnumerable <DFAFeedback> >(maxGrade, feedList));
}
#endregion
#region metrics computation
Stopwatch swPDLed = new Stopwatch();
swPDLed.Start();
#region PDL edit distance
Transformation feedbackTransformation = null;
if (enablePDLED)
{
var trpair = PDLEditDistance.GetMinimalFormulaEditDistanceTransformation(dfaGoalMin, dfaAttemptMin, al, solver, timeout, pdlEnumerator);
if (trpair != null)
{
var transformationGrade = trpair.First;
feedbackTransformation = trpair.Second;
var scaling = 1.0;
pdlEditDistanceScaled = transformationGrade.totalCost / (transformationGrade.minSizeForTreeA * scaling) + smallerDFADeduction;
}
}
#endregion
swPDLed.Stop();
Stopwatch swDensity = new Stopwatch();
swDensity.Start();
#region density distance
if (enableDensity)
{
densityRatio = DFADensity.GetDFADifferenceRatio(dfaGoalMin, dfaAttemptMin, al, solver);
densityRatio += smallerDFADeduction;
}
#endregion
swDensity.Stop();
Stopwatch swDFAed = new Stopwatch();
swDFAed.Start();
#region DFA edit distance
DFAEditScript dfaEditScript = null;
if (enableDFAED)
{
//limit the depth of the DFA edit distance search
var maxMoves = Math.Max(1, 6 - (int)Math.Sqrt(dfaAttempt.MoveCount + dfaAttempt.StateCount));
dfaEditScript = DFAEditDistance.GetDFAOptimalEdit(dfaGoal, dfaAttempt, al, solver, timeout, new StringBuilder());
if (dfaEditScript != null)
{
dfaED = ((double)(dfaEditScript.GetCost())) / ((double)((dfaGoalMin.StateCount + 1) * al.Count));
}
}
#endregion
swDFAed.Stop();
#endregion
#region metrics scaling
var scalingSquarePDLED = 1.005;
var scalingSquareDensity = 1; var multv2 = 0.5;
var scalingSquareDFAED = 1.03;
var scaledPdlED = (0.9 * (scalingSquarePDLED + pdlEditDistanceScaled) * (scalingSquarePDLED + pdlEditDistanceScaled)) - scalingSquarePDLED * scalingSquarePDLED;
var scaledDensityRatio = (scalingSquareDensity + (multv2 * densityRatio)) * (scalingSquareDensity + (multv2 * densityRatio)) - scalingSquareDensity * scalingSquareDensity;
var scaledDfaED = (scalingSquareDFAED + dfaED) * (scalingSquareDFAED + dfaED) - scalingSquareDFAED * scalingSquareDFAED;
//Select dominating Feedback based on grade
double unscaledGrade = Math.Min(Math.Min(scaledPdlED, scaledDensityRatio), scaledDfaED);
var pdledwins = scaledPdlED <= Math.Min(scaledDensityRatio, scaledDfaED);
var dfaedwins = scaledDfaED <= Math.Min(scaledDensityRatio, scaledPdlED);
var densitywins = scaledDensityRatio <= Math.Min(scaledDfaED, scaledPdlED);
#endregion
#region Feedback Selection
if (pdledwins && feedbackTransformation != null && feedbackTransformation.pdlB.GetFormulaSize() < 10)
{
feedList.Add(new PDLEDFeedback(level, al, feedbackTransformation, scaledPdlED, solver));
}
if ((dfaedwins || feedList.Count == 0) && dfaEditScript != null && !dfaEditScript.IsComplex())
{
feedList = new List <DFAFeedback>();
feedList.Add(new DFAEDFeedback(dfaGoal, dfaAttempt, level, al, dfaEditScript, scaledDfaED, solver));
}
if (densitywins || feedList.Count == 0)
{
feedList = new List <DFAFeedback>();
feedList.Add(new DensityFeedback(level, al, dfaGoal, dfaAttempt, scaledDensityRatio, solver));
}
if (feedList.Count == 0)
{
Console.WriteLine("Why no feedback!!");
feedList.Add(defaultFeedback);
}
#endregion
#region normalize grade
var scaledGrade = maxGrade - (int)Math.Round(unscaledGrade * (double)(maxGrade));
//If rounding yields maxgrade deduct 1 point by default
if (scaledGrade == maxGrade)
{
scaledGrade = maxGrade - 1;
}
//Remove possible deduction
scaledGrade = scaledGrade < 0 ? 0 : scaledGrade;
return(new Pair <int, IEnumerable <DFAFeedback> >(scaledGrade, feedList));
#endregion
}
