// Predicate
// [~] Label '(' ArgList ')'
public Predicate ParsePredicate(bool query)
{
Predicate p = new Predicate();
if (currentToken.Type == TokenType.Not)
{
p.Not = true;
Advance();
}
p.Not ^= query;
p.Label = currentToken.Lexeme;
Advance();
Advance(); // '('
p.Rules = ParseArgList();
Advance(); // ')'
return p;
}
/// <summary>
/// This method will attempt to resolve two sentences passed in as parameters. If the sentence cannot be resolved
/// then the return value will be null. Otherwise it will return the resolved sentence.
/// </summary>
/// <param name="Ci"> One of the sentences to compare for resolution. </param>
/// <param name="Cj"> The other sentence to compare for resolution. </param>
/// <returns> null if the sentence couldn't be resolved or the resolved sentence. </returns>
private Sentence Resolve(Sentence Ci, Sentence Cj)
{
Sentence newSentence = new Sentence();
List<Predicate> resolvedPreds = new List<Predicate>();
bool resolvedSentence = false;
foreach (Predicate cIPred in Ci.Predicates) {
foreach (Predicate cJPred in Cj.Predicates) {
if ((cIPred.Label == cJPred.Label) && (cIPred.Not != cJPred.Not) && RulesMatch(cIPred.Rules, cJPred.Rules)) {
// Dictionary <Rule from cJPred being replaced, the value it will be replaced with in cIPred>
Dictionary<string, Rule> unifyI = new Dictionary<string, Rule>();
Dictionary<string, Rule> unifyJ = new Dictionary<string, Rule>();
resolvedPreds.Add(cIPred);
resolvedPreds.Add(cJPred);
// Find the rules that unify in Cj sentence
for (int i = 0; i < cJPred.Rules.Count(); ++i) {
if (!unifyJ.ContainsKey(cJPred.Rules[i].ToString()))
unifyJ.Add(cJPred.Rules[i].ToString(), cIPred.Rules[i]);
}
// Find the rules that unify in Cj sentence
for (int i = 0; i < cIPred.Rules.Count(); ++i) {
if (!unifyI.ContainsKey(cIPred.Rules[i].ToString()))
unifyI.Add(cIPred.Rules[i].ToString(), cJPred.Rules[i]);
}
// Replace the rules in the Ci sentence that unify.
Sentence cISentence = new Sentence();
foreach (Predicate pred in Ci.Predicates) {
if (!resolvedPreds.Contains(pred)) {
Predicate newPredicate = new Predicate();
newPredicate.Label = pred.Label;
newPredicate.Not = pred.Not;
for (int i = 0; i < pred.Rules.Count(); ++i) {
string key = pred.Rules[i].Label;
if (unifyI.ContainsKey(key))
newPredicate.Rules.Add(unifyI[key]);
else
newPredicate.Rules.Add(pred.Rules[i]);
}
cISentence.Predicates.Add(newPredicate);
}
}
// Replace the rules in the Cj sentence that unify.
Sentence cJSentence = new Sentence();
foreach (Predicate pred in Cj.Predicates) {
if (!resolvedPreds.Contains(pred)) {
Predicate newPredicate = new Predicate();
newPredicate.Label = pred.Label;
newPredicate.Not = pred.Not;
for (int i = 0; i < pred.Rules.Count(); ++i) {
string key = pred.Rules[i].ToString();
if (unifyJ.ContainsKey(key))
newPredicate.Rules.Add(unifyJ[key]);
else
newPredicate.Rules.Add(pred.Rules[i]);
}
cJSentence.Predicates.Add(newPredicate);
}
}
newSentence.Predicates.AddRange(cISentence.Predicates);
newSentence.Predicates.AddRange(cJSentence.Predicates);
resolvedSentence = true;
break;
}
}
if (resolvedSentence) {
solutionPath.Add(Ci.ToString() + " [and] " + Cj.ToString() + " -> " + newSentence.ToString());
break;
}
}
// Factor out duplicates if they exist.
//Factoring(newSentence);
return (resolvedSentence) ? newSentence : null;
}
