public void store(String sentence) { String splitSent[] = parseString(sentence); Sentence sent = new Sentence(); if (splitSent.length == 1) sent.setlhsrhs("", splitSent[0]); else sent.setlhsrhs(splitSent[0], splitSent[1]); String key = sent.rhs.fnName; if (KB.containsKey(key)) { Rule temp = KB.get(key); temp.sentences.add(sent); KB.put(key, temp); } else { Rule r = new Rule(); r.sentences.add(sent); KB.put(key, r); } }
public void FOL_BC_ASK() { for (Predicate predicate : queries) { try { for (Map.Entry<String, Rule> entry : KBObj.KB.entrySet()) { for (Sentence sent : entry.getValue().sentences) { sent.allSubst = null; } } AllSubstitution obj = FOL_BC_OR(predicate, null, 0); if (obj == null) System.out.println("FALSE"); else System.out.println(obj.status ? "TRUE" : "FALSE"); // substList = new LinkedHashMap<String, LinkedList<AllSubstitution>>(); } catch (Exception e) { System.out.println("FALSE"); } } }
/** * Turns a sentence into a flat phrasal tree. The structure is S -> tag*. And then each tag goes * to a word. The tag is either found from the label or made "WD". The tag and phrasal node have a * StringLabel. * * @param s The Sentence to make the Tree from * @param lf The LabelFactory with which to create the new Tree labels * @return The one phrasal level Tree */ public static Tree toFlatTree(Sentence<?> s, LabelFactory lf) { List<Tree> daughters = new ArrayList<Tree>(s.length()); for (HasWord word : s) { Tree wordNode = new LabeledScoredTreeLeaf(lf.newLabel(word.word())); if (word instanceof TaggedWord) { TaggedWord taggedWord = (TaggedWord) word; wordNode = new LabeledScoredTreeNode( new StringLabel(taggedWord.tag()), Collections.singletonList(wordNode)); } else { wordNode = new LabeledScoredTreeNode(lf.newLabel("WD"), Collections.singletonList(wordNode)); } daughters.add(wordNode); } return new LabeledScoredTreeNode(new StringLabel("S"), daughters); }
public AllSubstitution UNIFY(Predicate x, Predicate y, Sentence sent) { // 1. Find an array of substitutiion tsubstList // 2. Now the linked hashmap contains all the array of substitution. // 3. If 1 is contained in 2 then return false and delete from hash map // else add in the map. // This is the returned value. AllSubstitution tAllSubst = new AllSubstitution(); // This is part of return value. This is part of tAllSubst. List<Substitution> tSubstList = new LinkedList<Substitution>(); // Current subst. Substitution s = null; // Unification success or failure. // 1. Fails when same sentence comes with same substitution. boolean tStatus = false; boolean available = true; // Just make sure length of args of x and y are same. Also just check if they are same fnName. for (int i = 0; i < x.args.size(); i++) { // x and y both can be variable. I don't know what to do. if (isVariable(x, i)) { s = new Substitution(x.args.get(i), y.args.get(i)); tStatus = true; } // x and y both can be variable. I don't know what to do. else if (isVariable(y, i)) { s = new Substitution(y.args.get(i), x.args.get(i)); // tSubstList.add(s); tStatus = true; } // x and y both are not variables. Just make status as true. else if (x.args.get(i).equals(y.args.get(i))) { s = new Substitution(y.args.get(i), x.args.get(i)); // tSubstList.add(s); tStatus = true; } else { s = null; tStatus = false; break; } /* for(int j=0; j<tlist.size();j++) { Substitution tSub = tlist.get(j); if(tSub!=null && tSub.var.equals(s.var) && tSub.val.equals(s.val)) { tStatus = false; available = true; tlist.remove(j); break; } } */ if (s != null) { tSubstList.add(s); } /* if(!available) { tlist.add(s); } */ } // AllSubstitution temp = new AllSubstitution(); // temp.SubstList = tlist; // LinkedList<AllSubstitution> tglobalSubst = substList.get(x.fnName); // if(tglobalSubst == null) // tglobalSubst = new AllSubstitution(); // List<Substitution> tlist=tglobalSubst.SubstList; // check tstatus is true or false. If false return. if (tStatus) { Map<String, String> temp = new HashMap<String, String>(); // for (Substitution substitution : tSubstList) { String match = temp.get(substitution.var); if (match != null && !match.equals("") && !substitution.val.equals(match)) { tStatus = false; break; } else { temp.put(substitution.var, substitution.val); } } // now check if all elements of tSubstList are present in global hashmap. if (sent.allSubst == null || sent.allSubst.size() == 0) { if (sent.allSubst == null) { sent.allSubst = new LinkedList<AllSubstitution>(); } tAllSubst.SubstList = tSubstList; tAllSubst.status = tStatus; if (sent.lhs.size() != 0) sent.allSubst.add(tAllSubst); } else { for (AllSubstitution lsubst : sent.allSubst) { available = true; for (int i = 0; i < tSubstList.size(); i++) { if (!tSubstList.get(i).var.equals(lsubst.SubstList.get(i).var) || !tSubstList.get(i).val.equals(lsubst.SubstList.get(i).val)) { available = false; break; } } if (available) { tStatus = false; // sent.allSubst.remove(lsubst); break; } } if (!available) { tAllSubst.SubstList = tSubstList; tAllSubst.status = tStatus; sent.allSubst.add(tAllSubst); } } } else { tAllSubst.SubstList = tSubstList; tAllSubst.status = tStatus; } return tAllSubst; }