/// <summary>
/// Extracts a minimal necessary operator substitution needed for the backward application (other parameters remain lifted).
/// </summary>
/// <returns>Minimal substitution.</returns>
public ISubstitution ExtractMinimalOperatorSubstitution()
{
// we need to determine, which effects were actually used for the backwards application (i.e. have to be grounded).
ISubstitution substitution = new Substitution();
foreach (var predicate in UsedGroundedPredicates)
{
IAtom liftedPredicate;
if (Effects.OriginalLiftedPredicates.TryGetValue(predicate, out liftedPredicate))
{
var unification = liftedPredicate.GetUnificationWith(predicate);
substitution.AddLocalSubstitution(unification);
}
}
foreach (var function in UsedGroundedFunctions)
{
IAtom liftedFunction;
if (Effects.OriginalLiftedFunctions.TryGetValue(function, out liftedFunction))
{
var unification = liftedFunction.GetUnificationWith(function);
substitution.AddLocalSubstitution(unification);
}
}
return(substitution);
}
/// <summary>
/// Creates a deep copy of the substitution.
/// </summary>
/// <returns>A copy of the substitution.</returns>
public ISubstitution Clone()
{
Substitution newSubstitution = new Substitution();
foreach (var item in this)
{
newSubstitution.Add(item.Key, item.Value);
}
return(newSubstitution);
}
/// <summary>
/// Transforms the term.
/// </summary>
/// <param name="term">Term.</param>
/// <returns>Transformed term.</returns>
public ITerm Visit(VariableTerm term)
{
ConstantID substitutedValue;
if (Substitution.TryGetValue(term.NameId, out substitutedValue))
{
return(new ConstantTerm(substitutedValue, IdManager));
}
return(term.Clone());
}
/// <summary>
/// Visits and handles the effect.
/// </summary>
/// <param name="effect">Effect.</param>
public void Visit(ForallEffect effect)
{
IEnumerable <ISubstitution> localSubstitutions = GroundingManager.GenerateAllLocalSubstitutions(effect.Parameters);
foreach (var localSubstitution in localSubstitutions)
{
Substitution.AddLocalSubstitution(localSubstitution);
foreach (var localEffect in effect.Effects)
{
localEffect.Accept(this);
}
Substitution.RemoveLocalSubstitution(localSubstitution);
}
}
/// <summary>
/// Creates a substitution from the given parameters and substituted constants.
/// </summary>
/// <param name="parameters">Parameters.</param>
/// <param name="constNames">Constant names.</param>
/// <returns>New substitution.</returns>
public ISubstitution CreateSubstitution(Parameters parameters, params string[] constNames)
{
Debug.Assert(parameters.Count == constNames.Length);
ISubstitution substitution = new Substitution();
for (int i = 0; i < parameters.Count; ++i)
{
if (!string.IsNullOrEmpty(constNames[i]))
{
substitution.Add(parameters[i].ParameterNameId, CreateConstant(constNames[i]));
}
}
return(substitution);
}
/// <summary>
/// Checks the equality of objects.
/// </summary>
/// <param name="obj">Object to be checked.</param>
/// <returns>True if the objects are equal, false otherwise.</returns>
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
Substitution other = obj as Substitution;
if (other == null)
{
return(false);
}
return(CollectionsEquality.Equals(this, other));
}
/// <summary>
/// Visits and evaluates forall expression.
/// </summary>
/// <param name="expression">Forall expression.</param>
/// <returns>True if the specified expression evaluates as true, false otherwise.</returns>
public bool Visit(ForallExpression expression)
{
IEnumerable <ISubstitution> localSubstitutions = GroundingManager.GenerateAllLocalSubstitutions(expression.Parameters);
foreach (var localSubstitution in localSubstitutions)
{
Substitution.AddLocalSubstitution(localSubstitution);
bool subExpressionResult = expression.Child.Accept(this);
Substitution.RemoveLocalSubstitution(localSubstitution);
if (!subExpressionResult)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Visits and performs a property count on exists expression.
/// </summary>
/// <param name="expression">Exists expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <double, double> Visit(ExistsExpression expression)
{
double positiveValue = 0.0;
double negativeValue = 0.0;
IEnumerable <ISubstitution> localSubstitutions = GroundingManager.GenerateAllLocalSubstitutions(expression.Parameters);
foreach (var localSubstitution in localSubstitutions)
{
Substitution.AddLocalSubstitution(localSubstitution);
var childPropertyCounts = expression.Child.Accept(this);
Substitution.RemoveLocalSubstitution(localSubstitution);
positiveValue = Math.Max(positiveValue, childPropertyCounts.Item1);
negativeValue = Math.Max(negativeValue, childPropertyCounts.Item2);
}
return(Tuple.Create(positiveValue, negativeValue));
}
/// <summary>
/// Visits and performs a property count on forall expression.
/// </summary>
/// <param name="expression">Forall expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <int, int> Visit(ForallExpression expression)
{
int fulfilled = 0;
int notFulfilled = 0;
IEnumerable <ISubstitution> localSubstitutions = GroundingManager.GenerateAllLocalSubstitutions(expression.Parameters);
foreach (var localSubstitution in localSubstitutions)
{
Substitution.AddLocalSubstitution(localSubstitution);
var childPropertyCounts = expression.Child.Accept(this);
Substitution.RemoveLocalSubstitution(localSubstitution);
fulfilled += childPropertyCounts.Item1;
notFulfilled += childPropertyCounts.Item2;
}
return(Tuple.Create(fulfilled, notFulfilled));
}
/// <summary>
/// Visits and performs a property count on exists expression.
/// </summary>
/// <param name="expression">Exists expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <int, int> Visit(ExistsExpression expression)
{
int minFulfilled = int.MaxValue;
int minNotFulfilled = int.MaxValue;
IEnumerable <ISubstitution> localSubstitutions = GroundingManager.GenerateAllLocalSubstitutions(expression.Parameters);
foreach (var localSubstitution in localSubstitutions)
{
Substitution.AddLocalSubstitution(localSubstitution);
var childPropertyCounts = expression.Child.Accept(this);
Substitution.RemoveLocalSubstitution(localSubstitution);
minFulfilled = Math.Min(minFulfilled, childPropertyCounts.Item1);
minNotFulfilled = Math.Min(minNotFulfilled, childPropertyCounts.Item2);
}
return(Tuple.Create(minFulfilled, minNotFulfilled));
}
/// <summary>
/// Gets the unification with the specified atom, i.e. calculates the variable substitution required to ground variable terms of the
/// current atom with the grounded terms (i.e. constants) of the other atom.
/// </summary>
/// <param name="referenceAtom">Reference atom.</param>
/// <returns>Unification in the form of variable substitution.</returns>
public ISubstitution GetUnificationWith(IAtom referenceAtom)
{
Debug.Assert(GetNameId() == referenceAtom.GetNameId() && GetTerms().Count == referenceAtom.GetTerms().Count, "Unification of incompatible atoms!");
ISubstitution unification = new Substitution();
int termIndex = 0;
foreach (var term in GetTerms())
{
VariableTerm variableTerm = term as VariableTerm;
if (variableTerm != null)
{
ConstantTerm valueTerm = referenceAtom.GetTerms()[termIndex] as ConstantTerm;
if (valueTerm != null)
{
unification.Add(variableTerm.NameId, valueTerm.NameId);
}
}
++termIndex;
}
return(unification);
}
/// <summary>
/// Constructs the counter.
/// </summary>
/// <param name="groundingManager">Grounding manager.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
public NotAccomplishedConstraintsCounter(GroundingManager groundingManager, Lazy <ExpressionEvaluator> expressionEvaluator)
{
GroundingManager = groundingManager;
ExpressionEvaluator = expressionEvaluator;
Substitution = new Substitution();
}
