public AllSubstitution FOL_BC_AND(List<Predicate> goal, AllSubstitution theta) {
//
if (theta.status == false) return theta;
else if (goal.size() == 0) return theta;
else {
Predicate first = goal.get(0); // n
first = substFromTheata(theta, first);
int index = 0;
int tSize =
(KBObj.KB.get(first.fnName) == null)
? 0
: (KBObj.KB.get(first.fnName).sentences.size() - 1);
while (index <= tSize) {
AllSubstitution thetaPrime = FOL_BC_OR(first, theta, index++);
if (thetaPrime.status && goal.size() > 1) {
List<Predicate> rest =
new ArrayList<Predicate>(((ArrayList<Predicate>) goal).subList(1, goal.size()));
AllSubstitution thetaDoublePrime = FOL_BC_AND(rest, sumUpTheta(theta, thetaPrime));
if (thetaDoublePrime.status) return thetaDoublePrime;
} else return thetaPrime;
}
AllSubstitution t = new AllSubstitution();
t.status = false;
return t;
}
}
public AllSubstitution sumUpTheta(AllSubstitution x, AllSubstitution y) {
List<Substitution> newList = new LinkedList<Substitution>(x.SubstList);
newList.addAll(y.SubstList);
AllSubstitution newObj = new AllSubstitution();
newObj.SubstList = newList;
newObj.status = y.status;
return newObj;
}
public AllSubstitution FOL_BC_OR(Predicate goal, AllSubstitution theta, int index) {
// the key is the function name of query. H(x), H is key.
String key = goal.fnName;
// get all the sentence which has conclusion as goal.
List<Sentence> sents = (KBObj.KB.get(key) == null) ? null : KBObj.KB.get(key).sentences;
if (sents != null) {
// Iterate through all the sentence which have conclusion as sentence.
// for (Sentence sentence : sents) {
for (int i = index; i < sents.size(); i++) {
Sentence sentence = sents.get(i);
AllSubstitution subst = UNIFY(sentence.rhs, goal, sentence);
AllSubstitution thetaPrime = FOL_BC_AND(sentence.lhs, subst);
if (thetaPrime != null && thetaPrime.status) {
return thetaPrime;
}
}
}
AllSubstitution t = new AllSubstitution();
t.status = false;
return t;
}
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;
}
