Example #1
0
 private Dictionary<ISentenceForm, ISentenceFormDomain> GetCartesianDomainsFromModel()
 {
     var results = new Dictionary<ISentenceForm, ISentenceFormDomain>();
     foreach (NameAndArity sentenceEntry in _sentencesModel.SentencesModel.Keys)
     {
         List<TermModel> bodyModels = _sentencesModel.SentencesModel[sentenceEntry];
         // We'll end up taking the Cartesian product of the different types of terms we have available
         if (sentenceEntry.Arity == 0)
         {
             Fact sentence = new GroundFact(sentenceEntry.Name);
             var form = new SimpleSentenceForm(sentence);
             results[form] = new CartesianSentenceFormDomain(form, new MultiDictionary<int, TermObject>(false));
         }
         else
         {
             IEnumerable<HashSet<Term>> sampleTerms = ToSampleTerms(bodyModels);
             foreach (IEnumerable<Term> terms in sampleTerms.CartesianProduct())
             {
                 Fact sentence = new VariableFact(true, sentenceEntry.Name, terms.ToArray());
                 var form = new SimpleSentenceForm(sentence);
                 results[form] = GetDomain(form, sentence);
             }
         }
     }
     return results;
 }
Example #2
0
        private static List<Implication> ApplyCondensation(ICollection<Expression> condensationSet, Implication rule,
            UnusedSentenceNameSource sentenceNameSource)
        {
            var varsInCondensationSet = new HashSet<TermVariable>();
            foreach (Expression literal in condensationSet)
                foreach (var variable in literal.VariablesOrEmpty)
                    varsInCondensationSet.Add(variable);
            var varsToKeep = new HashSet<TermVariable>();
            //Which vars do we "keep" (put in our new condensed literal)?
            //Vars that are both:
            //1) In the condensation set, in a non-mutex literal
            //2) Either in the head or somewhere else outside the condensation set
            foreach (Expression literal in condensationSet)
                foreach (var variable in literal.VariablesOrEmpty)
                    varsToKeep.Add(variable);

            var varsToKeep2 = new HashSet<TermVariable>();
            foreach (var variable in rule.Consequent.VariablesOrEmpty)
                varsToKeep2.Add(variable);
            foreach (Expression literal in rule.Antecedents.Conjuncts)
                if (!condensationSet.Contains(literal))
                    foreach (var variable in literal.VariablesOrEmpty)
                        varsToKeep2.Add(variable);

            varsToKeep.IntersectWith(varsToKeep2);

            //Now we're ready to split it apart
            //Let's make the new rule
            var orderedVars = new List<Term>(varsToKeep);
            int condenserName = sentenceNameSource.GetNameWithPrefix(rule.Consequent.RelationName);
            //Make the rule head
            var condenserHead = new VariableFact(false, condenserName, orderedVars.ToArray());
            var condenserBody = new List<Expression>(condensationSet);
            var condenserRule = new Implication(condenserHead, condenserBody.ToArray());

            //TODO: Look for existing rules matching the new one
            var remainingLiterals = rule.Antecedents.Conjuncts.Where(literal => !condensationSet.Contains(literal)).ToList();

            remainingLiterals.Add(condenserHead);
            var modifiedRule = new Implication(rule.Consequent, remainingLiterals.ToArray());

            var newRules = new List<Implication>(2) { condenserRule, modifiedRule };
            return newRules;
        }