internal BoolExpr <T_Identifier> ExpensiveSimplify(out Converter <T_Identifier> converter)
{
ConversionContext <T_Identifier> conversionContext = IdentifierService <T_Identifier> .Instance.CreateConversionContext();
converter = new Converter <T_Identifier>(this, conversionContext);
if (converter.Vertex.IsOne())
{
return((BoolExpr <T_Identifier>)TrueExpr <T_Identifier> .Value);
}
if (converter.Vertex.IsZero())
{
return((BoolExpr <T_Identifier>)FalseExpr <T_Identifier> .Value);
}
return(BoolExpr <T_Identifier> .ChooseCandidate(this, converter.Cnf.Expr, converter.Dnf.Expr));
}
internal override BoolExpr <T_Identifier> VisitNot(NotExpr <T_Identifier> expression)
{
BoolExpr <T_Identifier> boolExpr = expression.Child.Accept <BoolExpr <T_Identifier> >((Visitor <T_Identifier, BoolExpr <T_Identifier> >) this);
switch (boolExpr.ExprType)
{
case ExprType.Not:
return(((NotExpr <T_Identifier>)boolExpr).Child);
case ExprType.True:
return((BoolExpr <T_Identifier>)FalseExpr <T_Identifier> .Value);
case ExprType.False:
return((BoolExpr <T_Identifier>)TrueExpr <T_Identifier> .Value);
default:
return(base.VisitNot(expression));
}
}
private static BoolExpr <T_Identifier> ChooseCandidate(
params BoolExpr <T_Identifier>[] candidates)
{
int num1 = 0;
int num2 = 0;
BoolExpr <T_Identifier> boolExpr1 = (BoolExpr <T_Identifier>)null;
foreach (BoolExpr <T_Identifier> candidate in candidates)
{
BoolExpr <T_Identifier> boolExpr2 = candidate.Simplify();
int num3 = boolExpr2.GetTerms().Distinct <TermExpr <T_Identifier> >().Count <TermExpr <T_Identifier> >();
int num4 = boolExpr2.CountTerms();
if (boolExpr1 == null || num3 < num1 || num3 == num1 && num4 < num2)
{
boolExpr1 = boolExpr2;
num1 = num3;
num2 = num4;
}
}
return(boolExpr1);
}
protected override bool EquivalentTypeEquals(BoolExpr <T_Identifier> other)
{
return(((TreeExpr <T_Identifier>)other).Children.SetEquals(Children));
}
protected abstract bool EquivalentTypeEquals(BoolExpr <T_Identifier> other);
internal static IEnumerable <T_Identifier> GetLeaves(BoolExpr <T_Identifier> expression)
{
return(LeafVisitor <T_Identifier> .GetTerms(expression).Select <TermExpr <T_Identifier>, T_Identifier>((Func <TermExpr <T_Identifier>, T_Identifier>)(term => term.Identifier)));
}
/// <summary> /// Performs local simplification appropriate to the current identifier. /// </summary> internal abstract BoolExpr <T_Identifier> LocalSimplify(BoolExpr <T_Identifier> expression);
/// <summary>
/// Initialize a new Not expression with the given child.
/// </summary>
/// <param name="child"> </param>
internal NotExpr(BoolExpr <T_Identifier> child)
: base(new[] { child })
{
}
/// <summary>
/// Adds an equivalence to this KB, of the form:
/// left iff. right
/// </summary>
/// <param name="left"> Left operand </param>
/// <param name="right"> Right operand </param>
internal void AddEquivalence(BoolExpr <T_Identifier> left, BoolExpr <T_Identifier> right)
{
AddFact(new Equivalence(left, right));
}
// (left iff. right) iff. (left --> right AND right --> left)
internal Equivalence(BoolExpr <T_Identifier> left, BoolExpr <T_Identifier> right)
: base(new Implication(left, right), new Implication(right, left))
{
_left = left;
_right = right;
}
internal Equivalence(BoolExpr <T_Identifier> left, BoolExpr <T_Identifier> right)
: base((BoolExpr <T_Identifier>) new KnowledgeBase <T_Identifier> .Implication(left, right), (BoolExpr <T_Identifier>) new KnowledgeBase <T_Identifier> .Implication(right, left))
{
this._left = left;
this._right = right;
}
internal Converter(BoolExpr <T_Identifier> expr, ConversionContext <T_Identifier> context)
{
_context = context ?? IdentifierService <T_Identifier> .Instance.CreateConversionContext();
_vertex = ToDecisionDiagramConverter <T_Identifier> .TranslateToRobdd(expr, _context);
}
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));
}
protected override bool EquivalentTypeEquals(BoolExpr <T_Identifier> other)
{
return(this._comparer.Equals(this._identifier, ((TermExpr <T_Identifier>)other)._identifier));
}
internal virtual void AddFact(BoolExpr <T_Identifier> fact)
{
this._facts.Add(fact);
this._knowledge = this._context.Solver.And(this._knowledge, new Converter <T_Identifier>(fact, this._context).Vertex);
}
// (condition --> implies) iff. (!condition OR implies)
internal Implication(BoolExpr <T_Identifier> condition, BoolExpr <T_Identifier> implies)
: base(condition.MakeNegated(), implies)
{
_condition = condition;
_implies = implies;
}
internal void AddImplication(BoolExpr <T_Identifier> condition, BoolExpr <T_Identifier> implies)
{
this.AddFact((BoolExpr <T_Identifier>) new KnowledgeBase <T_Identifier> .Implication(condition, implies));
}
/// <summary>
/// Adds the given implication to this KB, where implication is of the form:
/// condition --> implies
/// </summary>
/// <param name="condition"> Condition </param>
/// <param name="implies"> Entailed expression </param>
internal void AddImplication(BoolExpr <T_Identifier> condition, BoolExpr <T_Identifier> implies)
{
AddFact(new Implication(condition, implies));
}
internal void AddEquivalence(BoolExpr <T_Identifier> left, BoolExpr <T_Identifier> right)
{
this.AddFact((BoolExpr <T_Identifier>) new KnowledgeBase <T_Identifier> .Equivalence(left, right));
}
internal static IEnumerable <T_Identifier> GetLeaves(BoolExpr <T_Identifier> expression)
{
return(GetTerms(expression).Select(term => term.Identifier));
}
internal static BoolExpr <DomainConstraint <T_Variable, T_Element> > EliminateNot <T_Variable, T_Element>(
BoolExpr <DomainConstraint <T_Variable, T_Element> > expression)
{
return(expression.Accept(NonNegatedDomainConstraintTreeVisitor <T_Variable, T_Element> .Instance));
}
internal override BoolExpr <DomainConstraint <T_Variable, T_Element> > LocalSimplify(
BoolExpr <DomainConstraint <T_Variable, T_Element> > expression)
{
expression = NegationPusher.EliminateNot(expression);
return(expression.Accept(Simplifier <DomainConstraint <T_Variable, T_Element> > .Instance));
}
public bool Equals(BoolExpr <T_Identifier> other)
{
return(null != other && ExprType == other.ExprType &&
EquivalentTypeEquals(other));
}
internal override BoolExpr <T_Identifier> LocalSimplify(BoolExpr <T_Identifier> expression)
{
return(expression.Accept(Simplifier <T_Identifier> .Instance));
}
internal static int CountTerms(BoolExpr <T_Identifier> expression)
{
DebugCheck.NotNull(expression);
return(expression.Accept(_instance));
}
