public Substitution Copy(Substitution add)
{
Substitution result = Copy();
result.Add(add);
return result;
}
public override Term ApplySubstitution(Substitution sigma)
{
var args = new Term[Arguments.Length];
for (int i = 0; i < Arguments.Length; i++)
args[i] = Arguments[i].ApplySubstitution(sigma);
return new TermFunction(false, FunctionName, args);
}
public override Expression ApplySubstitution(Substitution sigma)
{
var newSentences = new Expression[_sentences.Length];
for (int i = 0; i < _sentences.Length; i++)
newSentences[i] = _sentences[i].ApplySubstitution(sigma);
return new Disjunction(newSentences);
}
public override Expression ApplySubstitution(Substitution sigma)
{
var newSentences = new Expression[Conjuncts.Length];
for (int i = 0; i < Conjuncts.Length; i++)
newSentences[i] = Conjuncts[i].ApplySubstitution(sigma);
// TODO: remove duplicates if any were created during application of substitution
return new Conjunction(false, newSentences);
}
public override Term ApplySubstitution(Substitution sigma)
{
// Does sigma apply to our variable?
Term replacement = sigma.GetMapping(this);
if (replacement == null)
return this; // nothing to change!
// Otherwise, return the variable's replacement
return replacement;
}
private static void ExitUnificationLevel(Substitution subs)
{
if (!Logger.IsDebugEnabled) return;
_unificationLevel--;
if (_unificationLevel < 0)
throw new Exception("Unification level < 0!!");
Logger.Debug(subs == null
? string.Format("{0}Unifier: failed to unify.", Util.MakeIndent(_unificationLevel))
: string.Format("{0}Unifier: mgu = {1}", Util.MakeIndent(_unificationLevel), subs));
}
public static Substitution Mgu(Fact f1, Fact f2)
{
// Make sure this is even worth our time to check
if (f1.RelationName != f2.RelationName)
return null;
if (f1.Arity != f2.Arity)
return null;
EnterUnificationLevel(f1, f2);
var subs = new Substitution();
if (Mgu(f1, f2, subs))
{
ExitUnificationLevel(subs);
return subs;
}
ExitUnificationLevel(null);
return null;
}
private static bool Mgu(Term t1, Term t2, Substitution subsSoFar)
{
return t1.Mgu(t2, subsSoFar);
}
private static Implication RemoveNotDistinctLiteral(Implication rule, Negation notDistinctLiteral)
{
//Figure out the substitution we want...
//If we have two constantsin Either Remove one or
//maybe get rid of the ___?
//One is a variablein Replace the variable with the other thing
//throughout the rule
var distinct = (Fact)notDistinctLiteral.Negated;
Term arg1 = distinct.GetTerm(0);
Term arg2 = distinct.GetTerm(1);
if (arg1 == arg2)
{
//Just Remove that literal
var newBody = new List<Expression>();
newBody.AddRange(rule.Antecedents.Conjuncts);
newBody.Remove(notDistinctLiteral);
return new Implication(rule.Consequent, newBody.ToArray());
}
var p1 = arg1 as TermVariable;
if (p1 != null)
{
//What we return will still have the not-distinct literal,
//but it will get replaced in the next pass.
//(Even if we have two variables, they will be equal next time through.)
var sub = new Substitution();
sub.AddMapping(p1, arg2);
return (Implication)rule.ApplySubstitution(sub);
}
var variable = arg2 as TermVariable;
if (variable != null)
{
var sub = new Substitution();
sub.AddMapping(variable, arg1);
return (Implication)rule.ApplySubstitution(sub);
}
if (arg1 is TermObject || arg2 is TermObject)
{
//We have two non-equal constants, or a constant and a function.
//The rule should have no effect.
return null;
}
//We have two functions. Complicated! (Have to replace them with unified version.)
//We pass on this case for now.
//TODO: Implement correctly.
throw new Exception("We can't currently handle (not (distinct <function> <function>)).");
}
private static Substitution Mgu(Disjunction dis1, Disjunction dis2)
{
List<Expression> contents1 = dis1.GetDisjuncts().ToList();
List<Expression> contents2 = dis2.GetDisjuncts().ToList();
if (contents1.Count != contents2.Count)
return null;
var subs = new Substitution();
return contents1.Where((t, i) => Mgu(t, contents2[i], subs) == false).Any() ? null : subs;
}
private static bool Mgu(Fact f1, Fact f2, Substitution subsSoFar)
{
// Make sure this is even worth our time to check
if (f1.RelationName != f2.RelationName)
return false;
if (f1.Arity != f2.Arity)
return false;
// Find the mgu for each column of the facts
for (int i = 0; i < f1.Arity; i++)
{
// If there is no mgu, just die
if (Mgu(f1.GetTerm(i), f2.GetTerm(i), subsSoFar) == false)
return false;
}
return true;
}
internal Substitution Reverse()
{
var result = new Substitution();
foreach (var kv in Substitutions)
{
var newKey = kv.Value as TermVariable;
if (newKey == null)
return null;
result.Substitutions[newKey] = kv.Key;
}
return result;
}
public abstract Expression ApplySubstitution(Substitution sigma);
public override Term ApplySubstitution(Substitution sigma)
{
// Nothing to do here -- no variables in object constants.
return this;
}
public override bool Mgu(Term t, Substitution subsSoFar)
{
if (t is TermObject)// Cannot map functions to constants.
return false;
var variable = t as TermVariable;
if (variable != null)// Reverse the problem; the TermVariable class handles this
return variable.Mgu(this, subsSoFar);
var function = t as TermFunction;
if (function != null)
{
TermFunction f = function;
// Make sure that our function names are equal
if (FunctionName != f.FunctionName)
return false;
// Make sure arities are the same
if (Arity != f.Arity)
return false;
// Finally, make sure we can get the mgu of all arguments
for (int i = 0; i < Arity; i++)
if (Arguments[i].Mgu(f.Arguments[i], subsSoFar) == false)
return false;
// All good!
return true;
}
throw new Exception("TermFunction.mgu: Don't know how to handle term of type " + t.GetType().Name);
}
public abstract override Expression ApplySubstitution(Substitution sigma);
public override bool Mgu(Term t, Substitution subsSoFar)
{
if (t is TermObject)
return Equals(t);
var variable = t as TermVariable;
if (variable != null) // Reverse the problem; the TermVariable class handles this
return variable.Mgu(this, subsSoFar);
if (t is TermFunction) // Can't unify a function and a constant.
return false;
throw new ApplicationException("TermObject.mgu: Don't know how to handle term of type " + t.GetType().Name);
}
protected bool Equals(Substitution other)
{
if (other.NumMappings() != NumMappings())
return false;
List<TermVariable> subs = Substitutions.Keys.ToList();
//this cannot be a foreach as GetMapping possibly modifies the collection
for (int i = 0; i < subs.Count; i++)
{
TermVariable currrentKey = subs[i];
if (!GetMapping(currrentKey).Equals(other.GetMapping(currrentKey)))
return false;
}
return true;
//return other.NumMappings() == NumMappings() && _substitutions.All(kv => GetMapping(kv.Key).Equals(other.GetMapping(kv.Key)));
}
private Substitution Copy()
{
var result = new Substitution();
foreach (var kv in Substitutions)
result.Substitutions[kv.Key] = kv.Value.Clone();
return result;
}
public void Add(Substitution add)
{
foreach (var kv in add.Substitutions)
AddMapping(kv.Key, kv.Value);
}
public override bool Mgu(Term t, Substitution subsSoFar)
{
if (t is TermObject)
{
Term replacement = subsSoFar.GetMapping(this);
if (replacement != null)
{
TermVariable termVariable = replacement as TermVariable;
if (termVariable != null)
{
subsSoFar.AddMapping(this, t);
subsSoFar.AddMapping(termVariable, t);
return true;
}
return replacement.Equals(t);
}
// There was no replacement:
// Add a mapping for the variable to this term-object
subsSoFar.AddMapping(this, t);
return true;
}
var variable = t as TermVariable;
if (variable != null)
{
TermVariable it = variable;
Term myReplacement = subsSoFar.GetMapping(this);
Term itsReplacement = subsSoFar.GetMapping(it);
if (itsReplacement == null)
{
// just map 'it' to me (or my replacement)
if (myReplacement == null)
{
if (!Equals(it))
subsSoFar.AddMapping(it, this);
}
else
{
if (!(myReplacement is TermVariable) || !myReplacement.Equals(it))
subsSoFar.AddMapping(it, myReplacement);
}
return true;
}
// At this point, 'it' has a replacement.
if (myReplacement == null)
{
// I don't have a replacement, so map me to it, or to its replacement
if (!(itsReplacement is TermVariable) || !itsReplacement.Equals(this))
subsSoFar.AddMapping(this, itsReplacement);
return true;
}
// At this point, both term variables have replacements.
// So make sure that they are the same!
return myReplacement.Equals(itsReplacement);
}
var func = t as TermFunction;
if (func != null)
{
Term myReplacement = subsSoFar.GetMapping(this);
// Case 1: I have a replacement
if (myReplacement != null)
// See if my replacement can be unified with the function
return myReplacement.Mgu(func, subsSoFar);
// Case 2: I have no replacement
TermFunction itsReplacement = subsSoFar.GetMapping(func);
if (itsReplacement.HasVariable(this))
return false;
// just set my replacement to the function
subsSoFar.AddMapping(this, itsReplacement);
return true;
}
throw new Exception("TermVariable.mgu: Don't know how to handle term of type " + t.GetType().Name);
}
public override Expression ApplySubstitution(Substitution sigma)
{
var columns = new Term[Terms.Length];
bool vars = false;
for (int i = 0; i < Terms.Length; i++)
{
columns[i] = Terms[i].ApplySubstitution(sigma);
if (columns[i].HasVariables)
vars = true;
}
if (vars)
return new VariableFact(false, RelationName, columns);
var newFact = new GroundFact(false, RelationName, columns);
//if (factQuery != null && factQuery.Contains(newFact))
//{
// usedFacts.Add(new FactMapping { ground = newFact, variable = this });
//}
return newFact;
}
private static bool Mgu(Expression exp1, Expression exp2, Substitution subsSoFar)
{
if (exp1.GetType() != exp2.GetType())
return false;
var fact1 = exp1 as Fact;
if (fact1 != null)
return Mgu(fact1, (Fact)exp2, subsSoFar);
var dis1 = exp1 as Disjunction;
if (dis1 != null)
return Mgu(dis1, (Disjunction)exp2, subsSoFar);
var neg1 = exp1 as Negation;
if (neg1 != null)
return Mgu(neg1, (Negation)exp2, subsSoFar);
throw new Exception("Unhandled type in unifier Mgu");
}
public override Expression ApplySubstitution(Substitution sigma)
{
return new Negation(Negated.ApplySubstitution(sigma));
}
