public object VisitVariable(Variable variable, object arg)
{
if (!replaced)
{
if (toReplace.Equals(variable))
{
replaced = true;
return(replaceWith);
}
}
return(variable);
}
public override IEnumerator <Unifier> LogicalConsequence(Agent ag, Unifier un)
{
ITerm t = this.CApply(un);
if (t.Equals(this))
{
return(base.LogicalConsequence(ag, un));
}
else
{
return(((ILogicalFormula)t).LogicalConsequence(ag, un));
}
}
private bool CascadeOccurCheck(IDictionary <Variable, ITerm> theta, Variable var,
ISet <Variable> varsToCheck, ISet <Variable> varsCheckedAlready)
{
// Want to check if any of the variable to check end up
// looping back around on the new variable.
ISet <Variable> nextLevelToCheck = new HashedSet <Variable>();
foreach (Variable v in varsToCheck)
{
if (!theta.ContainsKey(v))
{
continue;
}
ITerm t = theta[v];
if (t.Equals(var))
{
// e.g.
// v1=v2
// v2=SFO(v1)
return(true);
}
if (t is Function)
{
// Need to ensure the function this variable
// is to be replaced by does not contain var.
ISet <Variable> indirectvars = _variableCollector.CollectAllVariables(t);
if (indirectvars.Contains(var))
{
return(true);
}
// Determine the next cascade/level
// of variables to check for looping
foreach (var iv in indirectvars.Where(iv => !varsCheckedAlready.Contains(iv)))
{
nextLevelToCheck.Add(iv);
}
}
}
if (nextLevelToCheck.Count > 0)
{
varsCheckedAlready.UnionWith(nextLevelToCheck);
return(this.CascadeOccurCheck(theta, var, nextLevelToCheck, varsCheckedAlready));
}
return(false);
}
/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public IElementCNF Visit(EqualsLiteralCNF expression)
{
var objectAssignEffects = Effects.GroundedObjectFunctionAssignmentEffects;
if (objectAssignEffects.Count == 0)
{
return(expression.Clone());
}
Func <ITerm, ITerm> transformArgument = null;
transformArgument = (term) =>
{
ObjectFunctionTerm objectFunction = term as ObjectFunctionTerm;
if (objectFunction != null)
{
ITerm assignmentValue;
if (objectAssignEffects.TryGetValue(GroundAtom(objectFunction.FunctionAtom), out assignmentValue))
{
UsedGroundedFunctions.Add(objectFunction.FunctionAtom);
return(transformArgument(assignmentValue));
}
}
return(term.Clone());
};
ITerm transformedLeftTerm = transformArgument(expression.LeftArgument);
ITerm transformedRightTerm = transformArgument(expression.RightArgument);
bool termsEqual = transformedLeftTerm.Equals(transformedRightTerm);
if ((termsEqual && !expression.IsNegated) || (!termsEqual && expression.IsNegated))
{
// exact constant assignment (or unassignment with negated equals) -> positively contributing, i.e. remove
return(null);
}
return(new EqualsLiteralCNF(transformedLeftTerm, transformedRightTerm, expression.IsNegated));
}
public override bool Equals(object f)
{
var fa = f as EqualityFormula;
return(fa != null && t1.Equals(fa.t1) && t2.Equals(fa.t2));
}
public bool UnifyTerms(ITerm term, ITerm term2)
{
if (term.IsArithExpr())
{
term = term.CApply(this);
}
if (term2.IsArithExpr())
{
term2 = term2.CApply(this);
}
bool termIsVar = term.IsVar();
bool term2IsVar = term2.IsVar();
// One of them is a variable
if (termIsVar || term2IsVar)
{
VarTerm termv = termIsVar ? (VarTerm)term : null;
VarTerm term2v = term2IsVar ? (VarTerm)term2 : null;
// Get their values
ITerm termvl = termIsVar ? Get(termv) : term;
ITerm term2vl = term2IsVar ? Get(term2v) : term2;
if (termvl != null && term2vl != null) // Unify the values of the two variables
{
return(UnifiesNoUndo(termvl, term2vl));
}
else if (termvl != null) // Unify a variable with a value
{
return(Bind(term2v, termvl));
}
else if (term2vl != null)
{
return(Bind(termv, term2vl));
}
else // Unify two variables
{
if (!UnifyTerms(termv.GetNS(), term2v.GetNS()))
{
return(false);
}
if (termv.Negated() != term2v.Negated())
{
return(false);
}
Bind(termv, term2v);
return(true);
}
}
// Both terms are not vars
// If any of the terms is not a literal (is a number or string), they must be equal
// For unification, lists are literals
if (!term.IsLiteral() && !term.IsList() || !term2.IsLiteral() && !term2.IsList())
{
return(term.Equals(term2));
}
// Case of plan body
if (term.IsPlanBody() && term2.IsPlanBody())
{
IPlanBody pb1 = (IPlanBody)term;
IPlanBody pb2 = (IPlanBody)term2;
if (pb1.GetBodyTerm() == null && pb2.GetBodyTerm() == null)
{
return(true);
}
if (pb1.GetBodyTerm() == null && pb2.GetBodyTerm() != null)
{
return(false);
}
if (pb1.GetBodyTerm() != null && pb2.GetBodyTerm() == null)
{
return(false);
}
if (pb1.GetBodyTerm().IsVar() && pb2.GetBodyTerm().IsVar())
{
if (UnifiesNoUndo(pb1.GetBodyTerm(), pb2.GetBodyTerm()))
{
return(UnifiesNoUndo(pb1.GetBodyNext(), pb2.GetBodyNext()));
}
else
{
return(false);
}
}
if (pb1.GetBodyTerm().IsVar())
{
if (pb1.GetBodyNext() == null)
{
return(UnifiesNoUndo(pb1.GetBodyTerm(), pb2));
}
else
{
if (pb2.GetBodyTerm() == null)
{
return(false);
}
if (UnifiesNoUndo(pb1.GetBodyTerm(), pb2.GetHead()))
{
if (pb2.GetBodyNext() == null)
{
if (pb1.GetBodyNext() != null && pb1.GetBodyNext().GetBodyTerm().IsVar() && pb1.GetBodyNext().GetBodyNext() == null)
{
return(UnifiesNoUndo(pb1.GetBodyNext().GetBodyTerm(), new PlanBodyImpl()));
}
return(false);
}
else
{
return(UnifiesNoUndo(pb1.GetBodyNext(), pb2.GetBodyNext()));
}
}
}
}
else if (pb2.GetBodyTerm().IsVar())
{
return(Unifies(pb2, pb1));
}
}
// Both terms are literal
Literal t1s = (Literal)term;
Literal t2s = (Literal)term2;
// Different arities
int ts = t1s.GetArity();
if (ts != t2s.GetArity())
{
return(false);
}
// If both are literal, they must have the same negated
if (t1s.Negated() != t2s.Negated())
{
return(false);
}
// Different functor
if (!t1s.GetFunctor().Equals(t2s.GetFunctor()))
{
return(false);
}
// Different namespace
if (!UnifiesNamespace(t1s, t2s))
{
return(false);
}
// Unify inner terms
for (int i = 0; i < ts; i++)
{
if (!UnifiesNoUndo(t1s.GetTerm(i), t2s.GetTerm(i)))
{
return(false);
}
}
// The first's annotations must be a subset of the second's annotations
if (!t1s.HasSubsetAnnot(t2s, this))
{
return(false);
}
return(true);
}
