private IEnumerable <BoolExpr <T_To> > VisitChildren(TreeExpr <T_From> expression)
{
foreach (var child in expression.Children)
{
yield return(child.Accept(this));
}
}
private bool VisitTree(TreeExpr <T_Identifier> expression)
{
foreach (var child in expression.Children)
{
child.Accept(this);
}
return(true);
}
private bool VisitTree(TreeExpr <T_Identifier> expression)
{
foreach (BoolExpr <T_Identifier> child in expression.Children)
{
child.Accept <bool>((Visitor <T_Identifier, bool>) this);
}
return(true);
}
private int VisitTree(TreeExpr <T_Identifier> expression)
{
var sum = 0;
foreach (var child in expression.Children)
{
sum += child.Accept(this);
}
return(sum);
}
private BoolExpr <T_Identifier> SimplifyTree(TreeExpr <T_Identifier> tree)
{
var isAnd = ExprType.And == tree.ExprType;
Debug.Assert(isAnd || ExprType.Or == tree.ExprType);
// Get list of simplified children, flattening nested And/Or expressions
var simplifiedChildren = new List <BoolExpr <T_Identifier> >(tree.Children.Count);
foreach (var child in tree.Children)
{
var simplifiedChild = child.Accept(this);
// And(And(A, B), C) iff. And(A, B, C)
// Or(Or(A, B), C) iff. Or(A, B, C)
if (simplifiedChild.ExprType
== tree.ExprType)
{
simplifiedChildren.AddRange(((TreeExpr <T_Identifier>)simplifiedChild).Children);
}
else
{
simplifiedChildren.Add(simplifiedChild);
}
}
// Track negated children separately to identify tautologies and contradictions
var negatedChildren = new Dictionary <BoolExpr <T_Identifier>, bool>(tree.Children.Count);
var otherChildren = new List <BoolExpr <T_Identifier> >(tree.Children.Count);
foreach (var simplifiedChild in simplifiedChildren)
{
switch (simplifiedChild.ExprType)
{
case ExprType.Not:
negatedChildren[((NotExpr <T_Identifier>)simplifiedChild).Child] = true;
break;
case ExprType.False:
// False And A --> False
if (isAnd)
{
return(FalseExpr <T_Identifier> .Value);
}
// False || A --> A (omit False from child collections)
break;
case ExprType.True:
// True Or A --> True
if (!isAnd)
{
return(TrueExpr <T_Identifier> .Value);
}
// True And A --> A (omit True from child collections)
break;
default:
otherChildren.Add(simplifiedChild);
break;
}
}
var children = new List <BoolExpr <T_Identifier> >();
foreach (var child in otherChildren)
{
if (negatedChildren.ContainsKey(child))
{
// A && !A --> False, A || !A --> True
if (isAnd)
{
return(FalseExpr <T_Identifier> .Value);
}
else
{
return(TrueExpr <T_Identifier> .Value);
}
}
children.Add(child);
}
foreach (var child in negatedChildren.Keys)
{
children.Add(child.MakeNegated());
}
if (0 == children.Count)
{
// And() iff. True
if (isAnd)
{
return(TrueExpr <T_Identifier> .Value);
}
// Or() iff. False
else
{
return(FalseExpr <T_Identifier> .Value);
}
}
else if (1 == children.Count)
{
// Or(A) iff. A, And(A) iff. A
return(children[0]);
}
else
{
// Construct simplified And/Or expression
TreeExpr <T_Identifier> result;
if (isAnd)
{
result = new AndExpr <T_Identifier>(children);
}
else
{
result = new OrExpr <T_Identifier>(children);
}
return(result);
}
}
private BoolExpr <T_Identifier> SimplifyTree(TreeExpr <T_Identifier> tree)
{
bool flag = ExprType.And == tree.ExprType;
List <BoolExpr <T_Identifier> > boolExprList1 = new List <BoolExpr <T_Identifier> >(tree.Children.Count);
foreach (BoolExpr <T_Identifier> child in tree.Children)
{
BoolExpr <T_Identifier> boolExpr = child.Accept <BoolExpr <T_Identifier> >((Visitor <T_Identifier, BoolExpr <T_Identifier> >) this);
if (boolExpr.ExprType == tree.ExprType)
{
boolExprList1.AddRange((IEnumerable <BoolExpr <T_Identifier> >)((TreeExpr <T_Identifier>)boolExpr).Children);
}
else
{
boolExprList1.Add(boolExpr);
}
}
Dictionary <BoolExpr <T_Identifier>, bool> dictionary = new Dictionary <BoolExpr <T_Identifier>, bool>(tree.Children.Count);
List <BoolExpr <T_Identifier> > boolExprList2 = new List <BoolExpr <T_Identifier> >(tree.Children.Count);
foreach (BoolExpr <T_Identifier> boolExpr in boolExprList1)
{
switch (boolExpr.ExprType)
{
case ExprType.Not:
dictionary[((NotExpr <T_Identifier>)boolExpr).Child] = true;
continue;
case ExprType.True:
if (!flag)
{
return((BoolExpr <T_Identifier>)TrueExpr <T_Identifier> .Value);
}
continue;
case ExprType.False:
if (flag)
{
return((BoolExpr <T_Identifier>)FalseExpr <T_Identifier> .Value);
}
continue;
default:
boolExprList2.Add(boolExpr);
continue;
}
}
List <BoolExpr <T_Identifier> > boolExprList3 = new List <BoolExpr <T_Identifier> >();
foreach (BoolExpr <T_Identifier> key in boolExprList2)
{
if (dictionary.ContainsKey(key))
{
if (flag)
{
return((BoolExpr <T_Identifier>)FalseExpr <T_Identifier> .Value);
}
return((BoolExpr <T_Identifier>)TrueExpr <T_Identifier> .Value);
}
boolExprList3.Add(key);
}
foreach (BoolExpr <T_Identifier> key in dictionary.Keys)
{
boolExprList3.Add(key.MakeNegated());
}
if (boolExprList3.Count == 0)
{
if (flag)
{
return((BoolExpr <T_Identifier>)TrueExpr <T_Identifier> .Value);
}
return((BoolExpr <T_Identifier>)FalseExpr <T_Identifier> .Value);
}
if (1 == boolExprList3.Count)
{
return(boolExprList3[0]);
}
return(!flag ? (BoolExpr <T_Identifier>) new OrExpr <T_Identifier>((IEnumerable <BoolExpr <T_Identifier> >)boolExprList3) : (BoolExpr <T_Identifier>) new AndExpr <T_Identifier>((IEnumerable <BoolExpr <T_Identifier> >)boolExprList3));
}
