/// <summary>
/// Visits the <paramref name="formula" />.
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
_builder.Append("(");
Visit(formula.LeftOperand);
switch (formula.Operator)
{
case BinaryOperator.And:
_builder.Append(" && ");
break;
case BinaryOperator.Or:
_builder.Append(" || ");
break;
case BinaryOperator.Implication:
_builder.Append(" -> ");
break;
case BinaryOperator.Equivalence:
_builder.Append(" <-> ");
break;
case BinaryOperator.Until:
_builder.Append(" U ");
break;
default:
Assert.NotReached($"Unknown or unsupported binary operator '{formula.Operator}'.");
break;
}
Visit(formula.RightOperand);
_builder.Append(")");
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
var referenceFormula = _referenceFormula as BinaryFormula;
if (referenceFormula == null)
{
IsEqual = false;
}
else
{
if (formula.Operator != referenceFormula.Operator)
{
IsEqual = false;
}
else
{
_referenceFormula = referenceFormula.LeftOperand;
Visit(formula.LeftOperand);
if (!IsEqual)
{
return;
}
_referenceFormula = referenceFormula.RightOperand;
Visit(formula.RightOperand);
}
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
Visit(formula.LeftOperand);
if (IsLtlFormula)
{
Visit(formula.RightOperand);
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
Visit(formula.LeftOperand);
var left = CurrentFormula;
Visit(formula.RightOperand);
var right = CurrentFormula;
CurrentFormula = new BinaryFormula(left, formula.Operator, right);
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
int leftMaximalNestedOnceInside;
int rightMaximalNestedOnceInside;
switch (formula.Operator)
{
case BinaryOperator.And:
case BinaryOperator.Or:
case BinaryOperator.Implication:
case BinaryOperator.Equivalence:
Visit(formula.LeftOperand);
var leftIsCompilable = IsNormalizable;
leftMaximalNestedOnceInside = MaximalNestedOnceInside;
Visit(formula.RightOperand);
var rightIsCompilable = IsNormalizable;
rightMaximalNestedOnceInside = MaximalNestedOnceInside;
if (leftIsCompilable && rightIsCompilable)
{
IsNormalizable = true;
}
else
{
if (leftIsCompilable)
{
MaximalNormalizableFormulas.Add(formula.LeftOperand);
}
if (rightIsCompilable)
{
MaximalNormalizableFormulas.Add(formula.RightOperand);
}
IsNormalizable = false;
}
MaximalNestedOnceInside = Math.Max(leftMaximalNestedOnceInside, rightMaximalNestedOnceInside);
break;
case BinaryOperator.Until:
Visit(formula.LeftOperand);
leftMaximalNestedOnceInside = MaximalNestedOnceInside;
if (IsNormalizable)
{
MaximalNormalizableFormulas.Add(formula.LeftOperand);
}
Visit(formula.RightOperand);
rightMaximalNestedOnceInside = MaximalNestedOnceInside;
if (IsNormalizable)
{
MaximalNormalizableFormulas.Add(formula.RightOperand);
}
IsNormalizable = false;
MaximalNestedOnceInside = Math.Max(leftMaximalNestedOnceInside, rightMaximalNestedOnceInside);
break;
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
switch (formula.Operator)
{
case BinaryOperator.And:
case BinaryOperator.Or:
case BinaryOperator.Implication:
case BinaryOperator.Equivalence:
Visit(formula.LeftOperand);
var leftIsCompilable = IsCompilable;
Visit(formula.RightOperand);
var rightIsCompilable = IsCompilable;
if (leftIsCompilable && rightIsCompilable)
{
IsCompilable = true;
}
else
{
if (leftIsCompilable)
{
MaximalCompilableFormulas.Add(formula.LeftOperand);
}
if (rightIsCompilable)
{
MaximalCompilableFormulas.Add(formula.RightOperand);
}
IsCompilable = false;
}
break;
case BinaryOperator.Until:
Visit(formula.LeftOperand);
if (IsCompilable)
{
MaximalCompilableFormulas.Add(formula.LeftOperand);
}
Visit(formula.RightOperand);
if (IsCompilable)
{
MaximalCompilableFormulas.Add(formula.RightOperand);
}
IsCompilable = false;
break;
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
_expression = TryToFindExpression(formula);
if (_expression != null)
{
return;
}
Visit(formula.LeftOperand);
var left = _expression;
Visit(formula.RightOperand);
var right = _expression;
switch (formula.Operator)
{
case BinaryOperator.And:
_expression = Expression.AndAlso(left, right);
break;
case BinaryOperator.Or:
_expression = Expression.OrElse(left, right);
break;
case BinaryOperator.Implication:
_expression = Expression.OrElse(Expression.Not(left), right);
break;
case BinaryOperator.Equivalence:
var leftLocal = Expression.Parameter(typeof(bool), "left");
var rightLocal = Expression.Parameter(typeof(bool), "right");
var bothHold = Expression.AndAlso(leftLocal, rightLocal);
var neitherHolds = Expression.AndAlso(Expression.Not(leftLocal), Expression.Not(rightLocal));
_expression = Expression.Block(
new[] { leftLocal, rightLocal },
Expression.Assign(leftLocal, left),
Expression.Assign(rightLocal, right),
Expression.OrElse(bothHold, neitherHolds));
break;
case BinaryOperator.Until:
throw new InvalidOperationException("Only state formulas can be evaluated.");
}
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
IsFormulaReturningBoolValue = true;
}
/// <summary>
/// Visits the <paramref name="formula." />
/// </summary>
public override void VisitBinaryFormula(BinaryFormula formula)
{
IsReturningRewardResult = false;
}
