public boolean verify(KnowledgeBase kb) {

    final Map<KnowledgeElement, Boolean> results = new LinkedHashMap<KnowledgeElement, Boolean>();

    KnowledgeBaseVisitor visitor =
        new AbstractKnowledgeBaseVisitor() {
          Collection<Variable> vars = null;
          Collection<Variable> varsInBody = new HashSet<Variable>();
          Collection<Variable> varsInHead = new ArrayList<Variable>();
          DerivationRule context = null;

          public boolean visit(DerivationRule r) {
            context = r;
            varsInHead.clear();
            varsInBody.clear();
            return true;
          }

          public void endVisit(DerivationRule r) {
            context = null;
            Variable var = null;
            for (Variable v : varsInHead) {
              if (!varsInBody.contains(v)) var = v;
            }
            if (var == null) reportOK(r);
            else reportViolation("variable ", var, " in ", r, " occurs only in rule head");
            results.put(r, var == null);
          }

          public boolean visit(Fact f) {
            if (context == null) {
              return false;
            } else if (context.getHead() == f) {
              vars = varsInHead;
            } else if (context.getBody().contains(f)) {
              vars = varsInBody;
            }
            return true;
          }

          public boolean visit(Variable t) {
            vars.add(t);
            return true;
          }
        };

    kb.accept(visitor);
    for (boolean b : results.values()) {
      if (!b) return false;
    }
    return true;
  }
예제 #2
0
  public void removeForwardReferences() {
    KnowledgeBase kb = this.getKnowledgeBase();
    Slot branches = kb.getSlot("branches");
    Slot followed_by = kb.getSlot("followed_by");
    // logger.debug("Slot "+branches.getName());
    // logger.debug("Slot "+followed_by.getName());
    Slot label = kb.getSlot("label");
    Collection steps = getOwnSlotValues(kb.getSlot("steps"));
    for (Iterator iterater = steps.iterator(); iterater.hasNext(); ) {
      Instance step = (Instance) iterater.next();
      // logger.debug("removeForwardReferences: node ="+step.getOwnSlotValue(label));
      /*for (Iterator slots=step.getOwnSlots().iterator(); slots.hasNext();){
      	logger.debug("has slot "+((Slot)slots.next()).getName());
      }*/
      try {
        if (step.hasOwnSlot(branches)) {
          /*logger.debug("removeForwardReferences: "+ step.getOwnSlotValue(label)+
          " has branches"); */
          step.setOwnSlotValues(branches, new ArrayList());
        } else if (step.hasOwnSlot(followed_by)) {
          /* logger.debug("removeForwardReferences: "+ step.getOwnSlotValue(label)+
          " has followed_by value "+step.getOwnSlotValue(followed_by));*/
          step.setOwnSlotValue(followed_by, null);
        } else
          logger.error(
              "removeForwardReferences: "
                  + step.getOwnSlotValue(label)
                  + "has no followed_by or branches slot");
      } catch (Exception e) {

        logger.error(
            "Exception making " + step.getOwnSlotValue(label) + " null, Message: " + e.getMessage(),
            e);
      }
    }
  }
  public void readInput(String fileName) {
    int i1 = 0;
    try {
      @SuppressWarnings("resource")
      BufferedReader br = new BufferedReader(new FileReader(fileName));
      int noOfQueries = Integer.parseInt(br.readLine());
      queries = new ArrayList<Predicate>();
      for (int i = 0; i < noOfQueries; i++) {
        queries.add(new Predicate(br.readLine()));
      }

      int noOfSentences = Integer.parseInt(br.readLine());

      for (i1 = 0; i1 < noOfSentences; i1++) {
        KBObj.store(br.readLine());
      }
    } catch (Exception e) {
      System.out.println(e.getMessage() + "sent number:" + i1);
    }
  }
예제 #4
0
 public void addForwardReferences() {
   KnowledgeBase kb = this.getKnowledgeBase();
   Collection transitions = getOwnSlotValues(kb.getSlot("transitions"));
   Slot fromSlot = kb.getSlot(":FROM");
   Slot toSlot = kb.getSlot(":TO");
   Instance from = null;
   Instance to = null;
   Slot branches = kb.getSlot("branches");
   Slot followed_by = kb.getSlot("followed_by");
   Slot label = kb.getSlot("label");
   for (Iterator transition = transitions.iterator(); transition.hasNext(); ) {
     Instance inst = (Instance) transition.next();
     from = (Instance) inst.getOwnSlotValue(fromSlot);
     if (from != null) {
       to = (Instance) inst.getOwnSlotValue(toSlot);
       if (to != null) {
         try {
           if (from.hasOwnSlot(branches)) {
             /*logger.debug("addForwardReferences: "+ from.getOwnSlotValue(label)+
             " has branches"); */
             if ((from.getOwnSlotValues(branches) == null)
                 || (!from.getOwnSlotValues(branches).contains(to)))
               from.addOwnSlotValue(branches, to);
           } else if (from.hasOwnSlot(followed_by)) {
             /*logger.debug("addForwardReferences: "+ from.getOwnSlotValue(label)+
             " has followed by");*/
             if (!(to.equals(from.getOwnSlotValue(followed_by))))
               from.setOwnSlotValue(followed_by, to);
           } else
             logger.error(
                 "addForwardReferences: "
                     + from.getOwnSlotValue(label)
                     + "has no followed_by or branches slot");
         } catch (Exception e) {
           logger.error(
               "Exception adding "
                   + to.getOwnSlotValue(label)
                   + " to "
                   + from.getOwnSlotValue(label));
         }
       }
     }
   }
 }
예제 #5
0
 public boolean useGraphWidget() {
   KnowledgeBase kb = this.getKnowledgeBase();
   return ((kb.getSlot("transitions") != null)
       && (getOwnSlotValues(kb.getSlot("transitions")) != null));
 }