private CTLFormula NegateFormula(CTLFormula formula)
{
switch (formula.Type)
{
case CTLExpressionType.Not:
return(formula.LeftFormula);
case CTLExpressionType.True:
formula.Type = CTLExpressionType.False;
return(formula);
case CTLExpressionType.False:
formula.Type = CTLExpressionType.True;
return(formula);
default:
return(new CTLFormula(CTLExpressionType.Not, formula));
}
}
public void CheckAGOperator()
{
var l = new CTLFormula ("qwe");
var f = CTLFormula.AG (l);
Assert.IsNull (f.Atomic);
Assert.IsNotNull (f.Left);
Assert.IsNull (f.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f.Operator);
var f1 = f.Left;
Assert.IsNull (f1.Atomic);
Assert.AreEqual (CTLFormula.TRUE, f1.Left);
Assert.IsNotNull (f1.Right);
Assert.AreEqual (CTLOperator.CTL_EU, f1.Operator);
var f2 = f1.Right;
Assert.IsNull (f2.Atomic);
Assert.AreEqual (l, f2.Left);
Assert.IsNull (f2.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f2.Operator);
}
public void CheckPrintAtom()
{
const string s = "zxcasd";
var f = new CTLFormula (s);
Assert.AreEqual ('{' + s + '}', f.ToString ());
}
public void CheckOrOperator2()
{
var l = new CTLFormula ("qwe");
var r = new CTLFormula ("rty");
var f = CTLFormula.Or (l, r);
Assert.IsNull (f.Atomic);
Assert.AreEqual (l, f.Left);
Assert.AreEqual (r, f.Right);
Assert.AreEqual (CTLOperator.LOGIC_OR, f.Operator);
}
public void CheckNotOperator2()
{
var l = new CTLFormula ("qwe");
var f = CTLFormula.Not (l);
Assert.IsNull (f.Atomic);
Assert.AreEqual (l, f.Left);
Assert.IsNull (f.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f.Operator);
}
public void CheckEXOperator()
{
var l = new CTLFormula ("qwe");
var f = CTLFormula.EX (l);
Assert.IsNull (f.Atomic);
Assert.AreEqual (l, f.Left);
Assert.IsNull (f.Right);
Assert.AreEqual (CTLOperator.CTL_EX, f.Operator);
}
public void CheckEUOperator()
{
var l = new CTLFormula ("qwe");
var r = new CTLFormula ("asd");
var f = CTLFormula.EU (l, r);
Assert.IsNull (f.Atomic);
Assert.AreEqual (l, f.Left);
Assert.AreEqual (r, f.Right);
Assert.AreEqual (CTLOperator.CTL_EU, f.Operator);
}
private List <bool> Marking(CTLFormula formula)
{
List <bool> toReturn;
List <bool> check1;
List <bool> check2;
List <int> toProcessStates;
int q;
switch (formula.Type)
{
case CTLExpressionType.Prop:
case CTLExpressionType.True:
case CTLExpressionType.False:
return(_automata.StatePropositions[formula.Lexeme]);
case CTLExpressionType.Not:
return(NegateBoolList(Marking(formula.LeftFormula)));
case CTLExpressionType.And:
check1 = Marking(formula.LeftFormula);
check2 = Marking(formula.RightFormula);
toReturn = new List <bool>();
for (var i = 0; i < check1.Count; i++)
{
toReturn.Add(check1[i] && check2[i]);
}
return(toReturn);
case CTLExpressionType.EX:
check1 = Marking(formula.LeftFormula);
toReturn = new List <bool>();
for (var i = 0; i < check1.Count; i++)
{
toReturn.Add(false);
}
for (var i = 0; i < _automata.Transitions.Count; i++)
{
var transition = _automata.Transitions[i];
foreach (var successor in transition)
{
if (check1[successor])
{
toReturn[i] = true;
}
}
}
return(toReturn);
case CTLExpressionType.EU:
check1 = Marking(formula.LeftFormula);
check2 = Marking(formula.RightFormula);
var seenBefore = new List <bool>();
toReturn = new List <bool>();
for (var i = 0; i < check1.Count; i++)
{
toReturn.Add(false);
seenBefore.Add(false);
}
toProcessStates = new List <int>();
for (var i = 0; i < check2.Count; i++)
{
if (check2[i])
{
toProcessStates.Add(i);
}
}
while (toProcessStates.Any())
{
q = toProcessStates[0];
toProcessStates.RemoveAt(0);
toReturn[q] = true;
foreach (var predecessor in _automata.TransitionsReversed[q])
{
if (!seenBefore[predecessor])
{
seenBefore[predecessor] = true;
if (check1[predecessor] && !toReturn[predecessor])
{
toProcessStates.Add(predecessor);
}
}
}
}
return(toReturn);
case CTLExpressionType.AU:
check1 = Marking(formula.LeftFormula);
check2 = Marking(formula.RightFormula);
var nb = new List <int>();
toProcessStates = new List <int>();
toReturn = new List <bool>();
for (var i = 0; i < check1.Count; i++)
{
toReturn.Add(false);
nb.Add(_automata.Transitions[i].Count);
if (check2[i])
{
toProcessStates.Add(i);
}
}
while (toProcessStates.Any())
{
q = toProcessStates[0];
toProcessStates.RemoveAt(0);
toReturn[q] = true;
foreach (var predecessor in _automata.TransitionsReversed[q])
{
nb[predecessor]--;
if (nb[predecessor] == 0 && check1[predecessor] && !toReturn[predecessor])
{
toProcessStates.Add(predecessor);
}
}
}
return(toReturn);
}
return(new List <bool>());
}
public void CheckAtomic()
{
const string s = "atom";
var f = new CTLFormula (s);
Assert.AreEqual (s, f.Atomic);
Assert.IsNull (f.Left);
Assert.IsNull (f.Right);
Assert.AreEqual (CTLOperator.NONE, f.Operator);
}
public void CheckAROperator()
{
var l = new CTLFormula ("qwe");
var r = new CTLFormula ("asd");
var f = CTLFormula.AR (l, r);
Assert.IsNull (f.Atomic);
Assert.IsNotNull (f.Left);
Assert.IsNull (f.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f.Operator);
var f1 = f.Left;
Assert.IsNull (f1.Atomic);
Assert.IsNotNull (f1.Left);
Assert.IsNotNull (f1.Right);
Assert.AreEqual (CTLOperator.CTL_EU, f1.Operator);
var f2 = f1.Left;
Assert.IsNull (f2.Atomic);
Assert.AreEqual (l, f2.Left);
Assert.IsNull (f2.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f2.Operator);
var f3 = f1.Right;
Assert.IsNull (f3.Atomic);
Assert.AreEqual (r, f3.Left);
Assert.IsNull (f3.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f3.Operator);
}
public void CheckAndOperator1()
{
var l = new CTLFormula ("qwe");
var r = new CTLFormula ("rty");
var f = l & r;
Assert.IsNull (f.Atomic);
Assert.AreEqual (l, f.Left);
Assert.AreEqual (r, f.Right);
Assert.AreEqual (CTLOperator.LOGIC_AND, f.Operator);
}
private CTLFormula MakeValid(CTLFormula formula)
{
if (formula.LeftFormula != null)
{
formula.LeftFormula = MakeValid(formula.LeftFormula);
}
if (formula.RightFormula != null)
{
formula.RightFormula = MakeValid(formula.RightFormula);
}
if (_validExpressionTypes.Contains(formula.Type))
{
return(formula);
}
switch (formula.Type)
{
case CTLExpressionType.Or:
formula.LeftFormula = NegateFormula(formula.LeftFormula);
formula.RightFormula = NegateFormula(formula.RightFormula);
formula.Type = CTLExpressionType.And;
return(new CTLFormula(CTLExpressionType.Not, formula));
case CTLExpressionType.Implies:
formula.LeftFormula = NegateFormula(formula.LeftFormula);
formula.Type = CTLExpressionType.Or;
return(MakeValid(formula));
case CTLExpressionType.IFF:
var newLeftFormula =
new CTLFormula(CTLExpressionType.Implies, formula.LeftFormula, formula.RightFormula);
var newRightFormula =
new CTLFormula(CTLExpressionType.Implies, formula.RightFormula, formula.LeftFormula);
newLeftFormula = MakeValid(newLeftFormula);
newRightFormula = MakeValid(newRightFormula);
formula.LeftFormula = newLeftFormula;
formula.RightFormula = newRightFormula;
formula.Type = CTLExpressionType.And;
return(formula);
case CTLExpressionType.AX:
formula.LeftFormula = NegateFormula(formula.LeftFormula);
formula.Type = CTLExpressionType.EX;
return(new CTLFormula(CTLExpressionType.Not, formula));
case CTLExpressionType.AF:
formula.RightFormula = formula.LeftFormula;
formula.LeftFormula = new CTLFormula(CTLExpressionType.True, "True");
formula.Type = CTLExpressionType.AU;
return(formula);
case CTLExpressionType.AG:
formula.LeftFormula = NegateFormula(formula.LeftFormula);
formula.RightFormula = formula.LeftFormula;
formula.LeftFormula = new CTLFormula(CTLExpressionType.True, "True");
formula.Type = CTLExpressionType.EU;
return(new CTLFormula(CTLExpressionType.Not, formula));
case CTLExpressionType.EF:
formula.RightFormula = formula.LeftFormula;
formula.LeftFormula = new CTLFormula(CTLExpressionType.True, "True");
formula.Type = CTLExpressionType.EU;
return(formula);
case CTLExpressionType.EG:
formula.LeftFormula = NegateFormula(formula.LeftFormula);
formula.RightFormula = formula.LeftFormula;
formula.LeftFormula = new CTLFormula(CTLExpressionType.True, "True");
formula.Type = CTLExpressionType.AU;
return(new CTLFormula(CTLExpressionType.Not, formula));
}
return(new CTLFormula());
}
public ModelChecker(Automata automata, CTLFormula formula, List <string> formulaPropositions)
{
_automata = automata;
_formula = MakeValid(formula);
_formulaPropositions = formulaPropositions;
}
public void CheckPrintComplexFormula()
{
const string s1 = "qwe";
const string s2 = "asd";
const string s3 = "zxc";
var f1 = (new CTLFormula (s1) & new CTLFormula (s2)) | new CTLFormula (s3);
var f2 = new CTLFormula (s1) & (new CTLFormula (s2) | new CTLFormula (s3));
Assert.AreEqual ("(({" + s1 + "}) and ({" + s2 + "})) or ({" + s3 + "})", f1.ToString ());
Assert.AreEqual ("({" + s1 + "}) and (({" + s2 + "}) or ({" + s3 + "}))", f2.ToString ());
}
public void CheckEROperator()
{
var l = new CTLFormula ("qwe");
var r = new CTLFormula ("asd");
var f = CTLFormula.ER (l, r);
Assert.IsNull (f.Atomic);
Assert.IsNotNull (f.Left);
Assert.IsNull (f.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f.Operator);
var f0 = f.Left;
Assert.IsNull (f0.Atomic);
Assert.IsNotNull (f0.Left);
Assert.IsNotNull (f0.Right);
Assert.AreEqual (CTLOperator.LOGIC_AND, f0.Operator);
var f1 = f0.Left;
Assert.IsNull (f1.Atomic);
Assert.IsNotNull (f1.Left);
Assert.IsNull (f1.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f1.Operator);
var f2 = f0.Right;
Assert.IsNull (f2.Atomic);
Assert.IsNotNull (f2.Left);
Assert.IsNull (f2.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f2.Operator);
var f3 = f1.Left;
Assert.IsNull (f3.Atomic);
Assert.IsNotNull (f3.Left);
Assert.IsNotNull (f3.Right);
Assert.AreEqual (CTLOperator.CTL_EU, f3.Operator);
var f4 = f2.Left;
Assert.IsNull (f4.Atomic);
Assert.IsNotNull (f4.Left);
Assert.IsNull (f4.Right);
Assert.AreEqual (CTLOperator.CTL_EG, f4.Operator);
var f5 = f3.Left;
Assert.IsNull (f5.Atomic);
Assert.IsNotNull (f5.Left);
Assert.IsNull (f5.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f5.Operator);
var f51 = f5.Left;
Assert.IsNull (f51.Atomic);
Assert.AreEqual (r, f51.Left);
Assert.IsNull (f51.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f51.Operator);
var f6 = f3.Right;
Assert.IsNull (f6.Atomic);
Assert.IsNotNull (f6.Left);
Assert.IsNotNull (f6.Right);
Assert.AreEqual (CTLOperator.LOGIC_AND, f6.Operator);
var f7 = f4.Left;
Assert.IsNull (f7.Atomic);
Assert.IsNotNull (f7.Left);
Assert.IsNull (f7.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f7.Operator);
var f71 = f7.Left;
Assert.IsNull (f71.Atomic);
Assert.AreEqual (r, f71.Left);
Assert.IsNull (f71.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f71.Operator);
var f8 = f6.Left;
Assert.IsNull (f8.Atomic);
Assert.IsNotNull (f8.Left);
Assert.IsNull (f8.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f8.Operator);
var f81 = f8.Left;
Assert.IsNull (f81.Atomic);
Assert.IsNotNull (f81.Left);
Assert.IsNull (f81.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f81.Operator);
var f9 = f6.Right;
Assert.IsNull (f9.Atomic);
Assert.IsNotNull (f9.Left);
Assert.IsNull (f9.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f9.Operator);
var f91 = f9.Left;
Assert.IsNull (f91.Atomic);
Assert.IsNotNull (f91.Left);
Assert.IsNull (f91.Right);
Assert.AreEqual (CTLOperator.LOGIC_NOT, f91.Operator);
}
public void CheckPrintOr()
{
const string s1 = "qwe";
const string s2 = "asd";
var f = new CTLFormula (s1) | new CTLFormula (s2);
Assert.AreEqual ("({" + s1 + "}) or ({" + s2 + "})", f.ToString ());
}
private static void Check(CTLFormula f)
{
Assert.AreEqual (f, CTLFormula.Parse (f.ToString ().Replace ('[', '(').Replace (']', ')')));
}
