/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="expression">Expression.</param>
/// <returns>True if the expression is logically true, false otherwise.</returns>
public virtual bool Visit(PredicateLiteralCNF expression)
{
IAtom groundedPredicateAtom = GroundingManager.GroundAtomDeep(expression.PredicateAtom, Substitution, ReferenceState);
bool evaluationResult = (RigidRelations.Contains(groundedPredicateAtom) || ReferenceState.HasPredicate(groundedPredicateAtom));
return(!expression.IsNegated == evaluationResult);
}
/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public Tuple <bool, bool> Visit(PredicateLiteralCNF expression)
{
bool hasPositive = Effects.GroundedPositivePredicateEffects.Contains(GroundingManager.GroundAtom(expression.PredicateAtom, ExpressionSubstitution));
bool hasNegative = Effects.GroundedNegativePredicateEffects.Contains(GroundingManager.GroundAtom(expression.PredicateAtom, ExpressionSubstitution));
bool positiveCondition = (expression.IsNegated) ? hasNegative : hasPositive;
bool negativeCondition = !((expression.IsNegated) ? hasPositive : hasNegative);
return(Tuple.Create(positiveCondition, negativeCondition));
}
/// <summary>
/// Visits and performs a property count on predicate expression.
/// </summary>
/// <param name="expression">Predicate expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <double, double> Visit(PredicateLiteralCNF expression)
{
var groundedAtom = GroundingManager.GroundAtom(expression.PredicateAtom, Substitution);
double value;
if (StateLabels.TryGetValue(groundedAtom, out value))
{
return((expression.IsNegated) ? Tuple.Create(0.0, value) : Tuple.Create(value, 0.0));
}
return(Tuple.Create(0.0, 0.0));
}
/// <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;
}
PredicateLiteralCNF other = obj as PredicateLiteralCNF;
if (other == null)
{
return false;
}
return (PredicateAtom.Equals(other.PredicateAtom) && IsNegated == other.IsNegated);
}
/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="expression">Expression.</param>
/// <returns>True if the expression is logically true, false otherwise.</returns>
public override bool Visit(PredicateLiteralCNF expression)
{
IAtom groundedPredicateAtom = GroundingManager.GroundAtomDeep(expression.PredicateAtom, Substitution, ReferenceState);
if (RigidRelations.Contains(groundedPredicateAtom))
{
// satisfied or failed by rigid relation
return(!expression.IsNegated);
}
bool hasPredicate = ReferenceState.HasPredicate(groundedPredicateAtom);
if (hasPredicate == expression.IsNegated)
{
// failed by state predicate
return(false);
}
// satisfied by state predicate -> store this atom
Atoms.Add(groundedPredicateAtom);
return(true);
}
/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public IElementCNF Visit(PredicateLiteralCNF expression)
{
var positivePredicateEffects = Effects.GroundedPositivePredicateEffects;
var negativePredicateEffects = Effects.GroundedNegativePredicateEffects;
if ((!expression.IsNegated && positivePredicateEffects.Count == 0) || (expression.IsNegated && negativePredicateEffects.Count == 0))
{
return(expression.Clone());
}
IAtom atom = GroundAtom(expression.PredicateAtom);
bool positivelyContributing = (expression.IsNegated) ? negativePredicateEffects.Contains(atom) : positivePredicateEffects.Contains(atom);
if (positivelyContributing)
{
UsedGroundedPredicates.Add(atom);
return(null);
}
return(expression.Clone());
}
/// <summary>
/// Generates all possible PDDL relative states meeting given CNF conditions (in the form of a list of conjuncts). Lazy generated recursively via yield return.
/// </summary>
/// <param name="index">Current index in the conjuncts list.</param>
/// <param name="conjuncts">List of conjuncts of the CNF conditions.</param>
/// <param name="result">Current relative state being built.</param>
/// <returns>All possible PDDL relative states meeting the CNF conditions.</returns>
private static IEnumerable <IRelativeState> EnumerateRelativeStatesByCNF(int index, List <IConjunctCNF> conjuncts, IRelativeState result)
{
if (index == 0)
{
// the constructed state can have trailing values from the previous unfinished enumeration!
result.ClearContent();
}
Action <IRelativeState, LiteralCNF> addLiteral = (state, literal) =>
{
// Note: At the moment, there is limited support for object and numeric function assignments.
// For example, numeric comparison literals like (< (numFunc) 5) will be omitted in the resulting relative state.
PredicateLiteralCNF predicateLiteral = literal as PredicateLiteralCNF;
if (predicateLiteral != null)
{
if (literal.IsNegated)
{
state.AddNegatedPredicate(predicateLiteral.PredicateAtom.Clone());
}
else
{
state.AddPredicate(predicateLiteral.PredicateAtom.Clone());
}
return;
}
EqualsLiteralCNF equalsLiteral = literal as EqualsLiteralCNF;
if (equalsLiteral != null)
{
var assignment = equalsLiteral.TryGetObjectFunctionAssignment();
if (assignment != null)
{
if (!literal.IsNegated)
{
state.AssignObjectFunction(assignment.Item1.FunctionAtom.Clone(), assignment.Item2.NameId);
}
}
return;
}
NumericCompareLiteralCNF compareLiteral = literal as NumericCompareLiteralCNF;
if (compareLiteral != null)
{
var assignment = compareLiteral.TryGetNumericFunctionAssignment();
if (assignment != null)
{
if (!compareLiteral.IsNegated)
{
state.AssignNumericFunction(assignment.Item1.FunctionAtom.Clone(), assignment.Item2.Value);
}
}
}
};
Action <IRelativeState, LiteralCNF> removeLiteral = (state, literal) =>
{
PredicateLiteralCNF predicateLiteral = literal as PredicateLiteralCNF;
if (predicateLiteral != null)
{
if (literal.IsNegated)
{
state.RemoveNegatedPredicate(predicateLiteral.PredicateAtom.Clone());
}
else
{
state.RemovePredicate(predicateLiteral.PredicateAtom.Clone());
}
return;
}
EqualsLiteralCNF equalsLiteral = literal as EqualsLiteralCNF;
if (equalsLiteral != null)
{
var assignment = equalsLiteral.TryGetObjectFunctionAssignment();
if (assignment != null)
{
if (!literal.IsNegated)
{
state.AssignObjectFunction(assignment.Item1.FunctionAtom.Clone(), ObjectFunctionTerm.UndefinedValue);
}
}
return;
}
NumericCompareLiteralCNF compareLiteral = literal as NumericCompareLiteralCNF;
if (compareLiteral != null)
{
var assignment = compareLiteral.TryGetNumericFunctionAssignment();
if (assignment != null)
{
if (!compareLiteral.IsNegated)
{
state.AssignNumericFunction(assignment.Item1.FunctionAtom.Clone(), NumericFunction.UndefinedValue);
}
}
}
};
if (index >= conjuncts.Count)
{
yield return((IRelativeState)result.Clone());
}
else
{
var conjunct = conjuncts[index];
ClauseCNF clause = conjunct as ClauseCNF;
if (clause != null)
{
foreach (var literal in clause)
{
addLiteral(result, literal);
foreach (var item in EnumerateRelativeStatesByCNF(index + 1, conjuncts, result))
{
yield return(item);
}
removeLiteral(result, literal);
}
}
else
{
LiteralCNF literal = conjunct as LiteralCNF;
Debug.Assert(literal != null);
addLiteral(result, literal);
foreach (var item in EnumerateRelativeStatesByCNF(index + 1, conjuncts, result))
{
yield return(item);
}
removeLiteral(result, literal);
}
}
}
/// <summary>
/// Visits and performs a property count on predicate expression.
/// </summary>
/// <param name="expression">Predicate expression.</param>
/// <returns>Tuple (property satisfied count, property not satisfied count).</returns>
public Tuple <int, int> Visit(PredicateLiteralCNF expression)
{
return(ProcessPrimitiveExpression(expression));
}
/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public void Visit(PredicateLiteralCNF expression)
{
Atoms.Add(expression.PredicateAtom);
}
/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public void Visit(PredicateLiteralCNF expression)
{
CheckAndRenameAtom(expression.PredicateAtom);
}
/// <summary>
/// Processes a single CNF literal of operator preconditions.
/// </summary>
/// <param name="literal">CNF literal.</param>
/// <param name="state">Relative state to be applied to.</param>
private static void ProcessPreconditionLiteral(LiteralCNF literal, IRelativeState state)
{
PredicateLiteralCNF predicateLiteral = literal as PredicateLiteralCNF;
if (predicateLiteral != null)
{
if (predicateLiteral.IsNegated)
{
state.AddNegatedPredicate(predicateLiteral.PredicateAtom);
}
else
{
state.AddPredicate(predicateLiteral.PredicateAtom);
}
return;
}
EqualsLiteralCNF equalsLiteral = literal as EqualsLiteralCNF;
if (equalsLiteral != null)
{
ObjectFunctionTerm objFunc = equalsLiteral.LeftArgument as ObjectFunctionTerm;
ConstantTerm constTerm = equalsLiteral.RightArgument as ConstantTerm;
if (objFunc == null || constTerm == null)
{
objFunc = equalsLiteral.RightArgument as ObjectFunctionTerm;
constTerm = equalsLiteral.LeftArgument as ConstantTerm;
}
if (objFunc != null && constTerm != null)
{
if (equalsLiteral.IsNegated)
{
if (state.GetObjectFunctionValue(objFunc.FunctionAtom) == constTerm.NameId)
{
state.AssignObjectFunction(objFunc.FunctionAtom, IdManager.InvalidId);
}
}
else
{
state.AssignObjectFunction(objFunc.FunctionAtom, constTerm.NameId);
}
}
return;
}
NumericCompareLiteralCNF compareLiteral = literal as NumericCompareLiteralCNF;
if (compareLiteral != null)
{
if (compareLiteral.Operator != NumericCompareExpression.RelationalOperator.EQ)
{
return;
}
NumericFunction numFunc = compareLiteral.LeftArgument as NumericFunction;
Number number = compareLiteral.RightArgument as Number;
if (numFunc == null || number == null)
{
numFunc = compareLiteral.RightArgument as NumericFunction;
number = compareLiteral.LeftArgument as Number;
}
if (numFunc != null && number != null)
{
if (compareLiteral.IsNegated)
{
if (state.GetNumericFunctionValue(numFunc.FunctionAtom).Equals(number.Value))
{
state.AssignNumericFunction(numFunc.FunctionAtom, NumericFunction.DefaultValue);
}
}
else
{
state.AssignNumericFunction(numFunc.FunctionAtom, number.Value);
}
}
}
}