private static IEnumerable<Implication> ApplyAmbiguitiesForLiteral(Expression literal, Implication rule,
IDictionary<ISentenceForm, ICollection<Ambiguity>> ambiguitiesByOriginalForm, ISentenceFormModel model)
{
var results = new List<Implication> { rule };
var varGen = new UnusedVariableGenerator(rule);
var fact = literal as Fact;
if (fact != null)
{
ISentenceForm form = model.GetSentenceForm(fact);
ICollection<Ambiguity> ambiguities;
if (ambiguitiesByOriginalForm.TryGetValue(form, out ambiguities))
{
IEnumerable<Ambiguity> applicableAmiguities = ambiguities.Where(ambiguity => ambiguity.Applies(fact));
IEnumerable<Substitution> substitutions = applicableAmiguities.Select(ambiguity => ambiguity.GetReplacementAssignment(fact, varGen));
IEnumerable<Implication> implications = substitutions.Select(substitution => (Implication)rule.ApplySubstitution(substitution));
results.AddRange(implications);
}
}
else if (literal is Negation)
{
// Do nothing. Variables must appear in a positive literal in the
// rule, and will be handled there.
}
else if (literal is Disjunction)
{
throw new Exception("ORs should have been removed");
//} else if (literal is GdlDistinct) {
// Do nothing
}
return results;
}
public Substitution GetReplacementAssignment(Fact sentence, UnusedVariableGenerator varGen)
{
Debug.Assert(Applies(sentence));
var assignment = new Substitution();
List<Term> tuple = sentence.NestedTerms.ToList();
foreach (int varIndex in _replacementsByOriginalTupleIndex.Keys)
{
TermFunction function = _replacementsByOriginalTupleIndex[varIndex];
TermFunction replacementFunction = varGen.ReplaceVariablesAndConstants(function);
assignment.AddMapping((TermVariable)tuple[varIndex], replacementFunction);
}
return assignment;
}
