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); }