Beispiel #1
0
		public ArrayList GetPreconditionChildren(Implication parentImplication) {
			ArrayList result = new ArrayList();
			
			foreach(Implication implication in implications)
				if (implication.PreconditionImplication == parentImplication)
					result.Add(implication);
			
			return result;
		}
Beispiel #2
0
        public void Agenda()
        {
            Agenda a = new Agenda();

            Implication impLow = new Implication("impLow", ImplicationPriority.Minimum, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            Implication impLowMed = new Implication("impLowMed", 25, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            Implication impMed = new Implication("impMed", ImplicationPriority.Medium, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            Implication impMedSaLo = new Implication("impMedSaLo", ImplicationPriority.Medium, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            impMedSaLo.Salience = 1;
            Assert.AreEqual(5101, impMedSaLo.Weight, "Weight impMedSaLo");
            Implication impMedSaHi = new Implication("impMedSaHi", ImplicationPriority.Medium, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            impMedSaHi.Salience = 99;
            Assert.AreEqual(5199, impMedSaHi.Weight, "Weight impMedSaLo");
            Implication impMedHi = new Implication("impMedHi", 75, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            Implication impHi = new Implication("impHi", ImplicationPriority.Maximum, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));

            // schedule in any order
            a.Schedule(impMedSaHi);
            a.Schedule(impLow);
            a.Schedule(impMed);
            a.Schedule(impMedHi);
            a.Schedule(impMedSaLo);
            a.Schedule(impLowMed);
            a.Schedule(impHi);

            // prepare for execution, which should sort this mess out
            a.PrepareExecution();
            Implication[] expected = new Implication[] {impHi, impMedHi, impMedSaHi, impMedSaLo, impMed, impLowMed, impLow};
            int i = 0;
            Implication implicationParser;
            while (a.HasMoreToExecute) {
                implicationParser = a.NextToExecute;
                Assert.IsTrue(implicationParser.Equals(expected[i]),
                              "Agenda not ordered: " +
                              implicationParser.Label +
                              "::" +
                              implicationParser.Weight +
                              " != " +
                              expected[i].Label +
                              "::" +
                              expected[i].Weight);
                i++;
            }
        }
Beispiel #3
0
		public void Add(Implication implication) {
			if (implications.Contains(implication))
				throw new BREException("The knowledge base already contains an implication labeled: " + implication.Label);			    
			
			implications.Add(implication);
			
			ArrayList typeListeners;
			
			foreach(Atom atom in implication.AtomGroup.AllAtoms) {
				if (!implicationsMap.ContainsKey(atom.Type)) {
					typeListeners = new ArrayList();
					implicationsMap.Add(atom.Type, typeListeners);
				}
				else
					typeListeners = (ArrayList) implicationsMap[atom.Type];
				
				if (!typeListeners.Contains(implication))	typeListeners.Add(implication);
			}
		}
Beispiel #4
0
        public void Add(Implication implication)
        {
            int indexOfDuplicate = implications.IndexOf(implication);

            if (indexOfDuplicate >= 0)
                throw new BREException("When adding: " + implication +
                                       " the knowledge base detected a duplicated with: " + implications[indexOfDuplicate]);

            implications.Add(implication);

            ArrayList typeListeners;

            foreach(Atom atom in implication.AtomGroup.AllAtoms) {
                if (!implicationsMap.ContainsKey(atom.Type)) {
                    typeListeners = new ArrayList();
                    implicationsMap.Add(atom.Type, typeListeners);
                }
                else
                    typeListeners = (ArrayList) implicationsMap[atom.Type];

                if (!typeListeners.Contains(implication))	typeListeners.Add(implication);
            }
        }
Beispiel #5
0
        private int RunImplication(Implication implication)
        {
            int implicationResultsCount = 0;

            FactBase.ProcessResultSet processResults = WM.FB.ProcessAtomGroup(implication.AtomGroup);

            if (implication.Action == ImplicationAction.Count)
            {
                if (HasLogListener) ForceDispatchLog("Counting Implication '" + implication.Label + "' counted: " + processResults.Count, LogEventImpl.DEBUG);

                bool variableFound = false;
                IPredicate[] members = (IPredicate[])implication.Deduction.Members.Clone();
                for(int i=0; !variableFound && i<members.Length; i++) {
                    if (members[i] is Variable) {
                        members[i] = new Individual(processResults.Count);
                        variableFound = true;
                        break;
                    }
                }

                if ((IEImpl.StrictImplication) && (!variableFound))
                    throw new BREException("Strict counting implication rejected the assertion due to lack of variable predicate: " + implication.Deduction);

                Fact deductedFact = new Fact(implication.Deduction.Type, members);
                implicationResultsCount++;

                // counting implication factbase action
                bool result = WM.FB.Assert(deductedFact);
                if ((result) && (NewFactHandler != null)) NewFactHandler(new NewFactEventArgs(deductedFact));
                if (HasLogListener) ForceDispatchLog((result?"Asserted":"Ignored Assertion of ") + " Fact: " + deductedFact.ToString(), LogEventImpl.DEBUG);
            }
            else if ((implication.Action == ImplicationAction.Assert)
              		|| (implication.Action == ImplicationAction.Retract))
            {
                // loop on each result and try to build a new fact out of the predicates coming for each result
                foreach(ArrayList processResult in processResults) {
                    Fact deductedFact = BuildFact(implication.Deduction, processResult);

                    if (deductedFact != null) {
                        implicationResultsCount++;

                        if (implication.Action == ImplicationAction.Retract) {
                            // retracting implication factbase action
                            bool result = WM.FB.Retract(deductedFact);
                            if ((result) && (DeleteFactHandler != null)) DeleteFactHandler(new NewFactEventArgs(deductedFact));
                            if (HasLogListener) ForceDispatchLog((result?"Retracted":"Ignored Retraction of ") + " Fact: " + deductedFact.ToString(), LogEventImpl.DEBUG);
                        }
                        else {
                            // asserting implication factbase action
                            bool result = WM.FB.Assert(deductedFact);
                            if ((result) && (NewFactHandler != null)) NewFactHandler(new NewFactEventArgs(deductedFact));
                            if (HasLogListener) ForceDispatchLog((result?"Asserted":"Ignored Assertion of ") + " Fact: " + deductedFact.ToString(), LogEventImpl.DEBUG);
                        }
                    }
                }
            }
            else if (implication.Action == ImplicationAction.Modify)
            {
              foreach(ArrayList processResult in processResults) {
                  // look for facts to modify by:
                  //  - resolving variable predicates of the deduction
                  //  - replacing formulas with variables
                  // and performing a search in the fact base
                  Atom modificationTargetLookup = FactBase.BuildQueryFromDeduction(implication.Deduction, processResult);

                  if (HasLogListener) ForceDispatchLog("Modifying Implication '" + implication.Label + "' will target matches of: " + modificationTargetLookup, LogEventImpl.DEBUG);

                 	foreach(Fact factToModify in FactBase.ExtractFacts(WM.FB.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, modificationTargetLookup)))) {
                      if (HasLogListener) ForceDispatchLog("-> found target: " + factToModify, LogEventImpl.DEBUG);

                      // for each fact, perform the modification
                  	Fact deductedFact = BuildFact(implication.Deduction,
                  	                              FactBase.EnrichResults(processResult, modificationTargetLookup, factToModify));

                      if (HasLogListener) ForceDispatchLog("-> modified target: " + deductedFact, LogEventImpl.DEBUG);

                      if ((deductedFact != null) && (!factToModify.Equals(deductedFact))) {
                            implicationResultsCount++;
                            bool result = WM.FB.Modify(factToModify, deductedFact);
                            if ((result) && (ModifyFactHandler != null))ModifyFactHandler(new NewFactEventArgs(factToModify, deductedFact));
                            if (HasLogListener) ForceDispatchLog((result?"Modified":"Ignored Modification of ") + " Fact: " + factToModify.ToString(), LogEventImpl.DEBUG);
                        }
                  }
                }
            }
            else
                throw new BREException("Implication action not supported: " + implication.Action);

            return implicationResultsCount;
        }
        private void WriteImplication(XmlElement target, Implication implication)
        {
            XmlElement implicationElement = Document.CreateElement("Implies", DatalogNamespaceURL);

            // action mapping
            String action = String.Empty;
            if (implication.Action != ImplicationAction.Assert)	action = implication.Action.ToString().ToLower();

            ImplicationProperties ip = new ImplicationProperties(implication.Label,
                                                                 implication.Priority,
                                                                 implication.Mutex,
                                                                 implication.Precondition,
                                                                 action);

            WriteLabel(implicationElement, ip.ToString());

            if (syntax == SaveFormatAttributes.Compact) {
                // in compact mode, the order is forced to body,head (equivalent to if,then)
                WriteAtomGroup(implicationElement, implication.AtomGroup);
                WriteAtom(implicationElement, implication.Deduction, false);
            }
            else {
                XmlElement body = Document.CreateElement("body", DatalogNamespaceURL);
                WriteAtomGroup(body, implication.AtomGroup);
                implicationElement.AppendChild(body);

                XmlElement head = Document.CreateElement("head", DatalogNamespaceURL);
                WriteAtom(head, implication.Deduction, false);
                implicationElement.AppendChild(head);
            }

            if (syntax == SaveFormatAttributes.Expanded) {
                XmlElement formula = Document.CreateElement("formula", DatalogNamespaceURL);
                formula.AppendChild(implicationElement);
                target.AppendChild(formula);
            }
            else {
                target.AppendChild(implicationElement);
            }
        }
Beispiel #7
0
 /// <summary>
 /// Schedule a single implication.
 /// </summary>
 /// <remarks>
 /// This method is public just for unit test purposes.
 /// </remarks>
 /// <param name="implication">The implication to schedule.</param>
 public void Schedule(Implication implication)
 {
     if (!agenda.Contains(implication))
         agenda.Add(implication);
 }
        private void WriteImplication(XmlElement target, Implication implication)
        {
            XmlElement eImplication = Document.CreateElement("imp", DatalogNamespaceURL);

            // action mapping
            String action = String.Empty;
            if (implication.Action != ImplicationAction.Assert)
                action = implication.Action.ToString().ToLower();

            ImplicationProperties ip = new ImplicationProperties(implication.Label,
                                                                 implication.Priority,
                                                                 implication.Mutex,
                                                                 implication.Precondition,
                                                                 action);
            WriteLabel(eImplication, ip.ToString());
            XmlElement head = Document.CreateElement("_head", DatalogNamespaceURL);
            WriteAtom(head, implication.Deduction, false);
            eImplication.AppendChild(head);
            XmlElement body = Document.CreateElement("_body", DatalogNamespaceURL);
            WriteAtomGroup(body, implication.AtomGroup);
            eImplication.AppendChild(body);
            target.AppendChild(eImplication);
        }
Beispiel #9
0
 public void WrongImplicationLowSalience()
 {
     Implication i = new Implication(null, ImplicationPriority.Medium, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
     i.Salience = -1;
     Assert.Fail("Should never reach me!");
 }
Beispiel #10
0
        public void QueryIsNotImplication()
        {
            Query query = new Query("get spending",
                                  new AtomGroup(AtomGroup.LogicalOperator.And, new Atom("spending",
                                                      new Variable("customer"),
                                                      new Individual("min(5000,EUR)"),
                                                      new Individual("previous year"))));

            Implication implication = new Implication("get spending",
                                                      ImplicationPriority.Medium,
                                                      String.Empty,
                                                      String.Empty,
                                                      atom2_2,
                                                      query.AtomGroup);

            Assert.IsFalse(query.Equals(implication), "QueryIsNotImplication");
        }
Beispiel #11
0
 public void PreconditionMissing()
 {
     ImplicationBase ib = new ImplicationBase();
     Implication impMedLow = new Implication("impMedLow", 25, String.Empty, "missing", imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
     ib.Add(impMedLow);
     ib.Add(new Implication("impMedHi", 25, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3)));
     new PreconditionManager(ib).AnalyzeImplications();
     Assert.Fail("Should never reach me!");
 }
Beispiel #12
0
 public void ImplicationBase()
 {
     ImplicationBase ib = new ImplicationBase();
     Implication imp = new Implication("impMedLow", 25, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
     ib.Add(imp);
     ib.Add(new Implication("impMedHi", 75, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3)));
     Assert.AreEqual(imp, ib.Get("impMedLow"), "Get");
     Assert.IsNull(ib.Get("missing bit"), "Failed Get");
 }
Beispiel #13
0
        public void GetPreconditionChildren()
        {
            ImplicationBase ib = new ImplicationBase();
            Implication impMedLow = new Implication("impMedLow", 25, String.Empty, String.Empty, imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            ib.Add(impMedLow);
            Implication impMedHi = new Implication("impMedHi", 25, String.Empty, "impMedLow", imp2, new AtomGroup(AtomGroup.LogicalOperator.And, atom2_2, atom3));
            ib.Add(impMedHi);
            new PreconditionManager(ib).AnalyzeImplications();

            ArrayList preconditionChildren = ib.GetPreconditionChildren(impMedLow);
            Assert.AreEqual(1, preconditionChildren.Count, "preconditionChildren size");
            Assert.IsTrue(preconditionChildren.Contains(impMedHi), "preconditionChildren content");
        }