package aima.core.logic.fol.kb;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import aima.core.logic.fol.CNFConverter;
import aima.core.logic.fol.StandardizeApart;
import aima.core.logic.fol.StandardizeApartIndexical;
import aima.core.logic.fol.StandardizeApartIndexicalFactory;
import aima.core.logic.fol.StandardizeApartResult;
import aima.core.logic.fol.SubstVisitor;
import aima.core.logic.fol.Unifier;
import aima.core.logic.fol.VariableCollector;
import aima.core.logic.fol.domain.FOLDomain;
import aima.core.logic.fol.inference.FOLOTTERLikeTheoremProver;
import aima.core.logic.fol.inference.InferenceProcedure;
import aima.core.logic.fol.inference.InferenceResult;
import aima.core.logic.fol.inference.proof.Proof;
import aima.core.logic.fol.inference.proof.ProofStepClauseClausifySentence;
import aima.core.logic.fol.kb.data.CNF;
import aima.core.logic.fol.kb.data.Chain;
import aima.core.logic.fol.kb.data.Clause;
import aima.core.logic.fol.kb.data.Literal;
import aima.core.logic.fol.parsing.FOLParser;
import aima.core.logic.fol.parsing.ast.FOLNode;
import aima.core.logic.fol.parsing.ast.Predicate;
import aima.core.logic.fol.parsing.ast.Sentence;
import aima.core.logic.fol.parsing.ast.Term;
import aima.core.logic.fol.parsing.ast.Variable;
/**
* A First Order Logic (FOL) Knowledge Base.
*
* @author Ciaran O'Reilly
*
*/
public class FOLKnowledgeBase {
private FOLParser parser;
private InferenceProcedure inferenceProcedure;
private Unifier unifier;
private SubstVisitor substVisitor;
private VariableCollector variableCollector;
private StandardizeApart standardizeApart;
private CNFConverter cnfConverter;
//
// Persistent data structures
//
// Keeps track of the Sentences in their original form as added to the
// Knowledge base.
private List<Sentence> originalSentences = new ArrayList<Sentence>();
// The KB in clause form
private Set<Clause> clauses = new LinkedHashSet<Clause>();
// Keep track of all of the definite clauses in the database
// along with those that represent implications.
private List<Clause> allDefiniteClauses = new ArrayList<Clause>();
private List<Clause> implicationDefiniteClauses = new ArrayList<Clause>();
// All the facts in the KB indexed by Atomic Sentence name (Note: pg. 279)
private Map<String, List<Literal>> indexFacts = new HashMap<String, List<Literal>>();
// Keep track of indexical keys for uniquely standardizing apart sentences
private StandardizeApartIndexical variableIndexical = StandardizeApartIndexicalFactory
.newStandardizeApartIndexical('v');
private StandardizeApartIndexical queryIndexical = StandardizeApartIndexicalFactory
.newStandardizeApartIndexical('q');
//
// PUBLIC METHODS
//
public FOLKnowledgeBase(FOLDomain domain) {
// Default to Full Resolution if not set.
this(domain, new FOLOTTERLikeTheoremProver());
}
public FOLKnowledgeBase(FOLDomain domain,
InferenceProcedure inferenceProcedure) {
this(domain, inferenceProcedure, new Unifier());
}
public FOLKnowledgeBase(FOLDomain domain,
InferenceProcedure inferenceProcedure, Unifier unifier) {
this.parser = new FOLParser(new FOLDomain(domain));
this.inferenceProcedure = inferenceProcedure;
this.unifier = unifier;
//
this.substVisitor = new SubstVisitor();
this.variableCollector = new VariableCollector();
this.standardizeApart = new StandardizeApart(variableCollector,
substVisitor);
this.cnfConverter = new CNFConverter(parser);
}
public void clear() {
this.originalSentences.clear();
this.clauses.clear();
this.allDefiniteClauses.clear();
this.implicationDefiniteClauses.clear();
this.indexFacts.clear();
}
public InferenceProcedure getInferenceProcedure() {
return inferenceProcedure;
}
public void setInferenceProcedure(InferenceProcedure inferenceProcedure) {
if (null != inferenceProcedure) {
this.inferenceProcedure = inferenceProcedure;
}
}
public Sentence tell(String sentence) {
Sentence s = parser.parse(sentence);
tell(s);
return s;
}
public void tell(List<? extends Sentence> sentences) {
for (Sentence s : sentences) {
tell(s);
}
}
public void tell(Sentence sentence) {
store(sentence);
}
/**
*
* @param querySentence
* @return an InferenceResult.
*/
public InferenceResult ask(String querySentence) {
return ask(parser.parse(querySentence));
}
public InferenceResult ask(Sentence query) {
// Want to standardize apart the query to ensure
// it does not clash with any of the sentences
// in the database
StandardizeApartResult saResult = standardizeApart.standardizeApart(
query, queryIndexical);
// Need to map the result variables (as they are standardized apart)
// to the original queries variables so that the caller can easily
// understand and use the returned set of substitutions
InferenceResult infResult = getInferenceProcedure().ask(this,
saResult.getStandardized());
for (Proof p : infResult.getProofs()) {
Map<Variable, Term> im = p.getAnswerBindings();
Map<Variable, Term> em = new LinkedHashMap<Variable, Term>();
for (Variable rev : saResult.getReverseSubstitution().keySet()) {
em.put((Variable) saResult.getReverseSubstitution().get(rev),
im.get(rev));
}
p.replaceAnswerBindings(em);
}
return infResult;
}
public int getNumberFacts() {
return allDefiniteClauses.size() - implicationDefiniteClauses.size();
}
public int getNumberRules() {
return clauses.size() - getNumberFacts();
}
public List<Sentence> getOriginalSentences() {
return Collections.unmodifiableList(originalSentences);
}
public List<Clause> getAllDefiniteClauses() {
return Collections.unmodifiableList(allDefiniteClauses);
}
public List<Clause> getAllDefiniteClauseImplications() {
return Collections.unmodifiableList(implicationDefiniteClauses);
}
public Set<Clause> getAllClauses() {
return Collections.unmodifiableSet(clauses);
}
// Note: pg 278, FETCH(q) concept.
public synchronized Set<Map<Variable, Term>> fetch(Literal l) {
// Get all of the substitutions in the KB that p unifies with
Set<Map<Variable, Term>> allUnifiers = new LinkedHashSet<Map<Variable, Term>>();
List<Literal> matchingFacts = fetchMatchingFacts(l);
if (null != matchingFacts) {
for (Literal fact : matchingFacts) {
Map<Variable, Term> substitution = unifier.unify(
l.getAtomicSentence(), fact.getAtomicSentence());
if (null != substitution) {
allUnifiers.add(substitution);
}
}
}
return allUnifiers;
}
// Note: To support FOL-FC-Ask
public Set<Map<Variable, Term>> fetch(List<Literal> literals) {
Set<Map<Variable, Term>> possibleSubstitutions = new LinkedHashSet<Map<Variable, Term>>();
if (literals.size() > 0) {
Literal first = literals.get(0);
List<Literal> rest = literals.subList(1, literals.size());
recursiveFetch(new LinkedHashMap<Variable, Term>(), first, rest,
possibleSubstitutions);
}
return possibleSubstitutions;
}
public Map<Variable, Term> unify(FOLNode x, FOLNode y) {
return unifier.unify(x, y);
}
public Sentence subst(Map<Variable, Term> theta, Sentence aSentence) {
return substVisitor.subst(theta, aSentence);
}
public Literal subst(Map<Variable, Term> theta, Literal l) {
return substVisitor.subst(theta, l);
}
public Term subst(Map<Variable, Term> theta, Term term) {
return substVisitor.subst(theta, term);
}
// Note: see page 277.
public Sentence standardizeApart(Sentence sentence) {
return standardizeApart.standardizeApart(sentence, variableIndexical)
.getStandardized();
}
public Clause standardizeApart(Clause clause) {
return standardizeApart.standardizeApart(clause, variableIndexical);
}
public Chain standardizeApart(Chain chain) {
return standardizeApart.standardizeApart(chain, variableIndexical);
}
public Set<Variable> collectAllVariables(Sentence sentence) {
return variableCollector.collectAllVariables(sentence);
}
public CNF convertToCNF(Sentence sentence) {
return cnfConverter.convertToCNF(sentence);
}
public Set<Clause> convertToClauses(Sentence sentence) {
CNF cnf = cnfConverter.convertToCNF(sentence);
return new LinkedHashSet<Clause>(cnf.getConjunctionOfClauses());
}
public Literal createAnswerLiteral(Sentence forQuery) {
String alName = parser.getFOLDomain().addAnswerLiteral();
List<Term> terms = new ArrayList<Term>();
Set<Variable> vars = variableCollector.collectAllVariables(forQuery);
for (Variable v : vars) {
// Ensure copies of the variables are used.
terms.add(v.copy());
}
return new Literal(new Predicate(alName, terms));
}
// Note: see pg. 281
public boolean isRenaming(Literal l) {
List<Literal> possibleMatches = fetchMatchingFacts(l);
if (null != possibleMatches) {
return isRenaming(l, possibleMatches);
}
return false;
}
// Note: see pg. 281
public boolean isRenaming(Literal l, List<Literal> possibleMatches) {
for (Literal q : possibleMatches) {
if (l.isPositiveLiteral() != q.isPositiveLiteral()) {
continue;
}
Map<Variable, Term> subst = unifier.unify(l.getAtomicSentence(),
q.getAtomicSentence());
if (null != subst) {
int cntVarTerms = 0;
for (Term t : subst.values()) {
if (t instanceof Variable) {
cntVarTerms++;
}
}
// If all the substitutions, even if none, map to Variables
// then this is a renaming
if (subst.size() == cntVarTerms) {
return true;
}
}
}
return false;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (Sentence s : originalSentences) {
sb.append(s.toString());
sb.append("\n");
}
return sb.toString();
}
//
// PROTECTED METHODS
//
protected FOLParser getParser() {
return parser;
}
//
// PRIVATE METHODS
//
// Note: pg 278, STORE(s) concept.
private synchronized void store(Sentence sentence) {
originalSentences.add(sentence);
// Convert the sentence to CNF
CNF cnfOfOrig = cnfConverter.convertToCNF(sentence);
for (Clause c : cnfOfOrig.getConjunctionOfClauses()) {
c.setProofStep(new ProofStepClauseClausifySentence(c, sentence));
if (c.isEmpty()) {
// This should not happen, if so the user
// is trying to add an unsatisfiable sentence
// to the KB.
throw new IllegalArgumentException(
"Attempted to add unsatisfiable sentence to KB, orig=["
+ sentence + "] CNF=" + cnfOfOrig);
}
// Ensure all clauses added to the KB are Standardized Apart.
c = standardizeApart.standardizeApart(c, variableIndexical);
// Will make all clauses immutable
// so that they cannot be modified externally.
c.setImmutable();
if (clauses.add(c)) {
// If added keep track of special types of
// clauses, as useful for query purposes
if (c.isDefiniteClause()) {
allDefiniteClauses.add(c);
}
if (c.isImplicationDefiniteClause()) {
implicationDefiniteClauses.add(c);
}
if (c.isUnitClause()) {
indexFact(c.getLiterals().iterator().next());
}
}
}
}
// Only if it is a unit clause does it get indexed as a fact
// see pg. 279 for general idea.
private void indexFact(Literal fact) {
String factKey = getFactKey(fact);
if (!indexFacts.containsKey(factKey)) {
indexFacts.put(factKey, new ArrayList<Literal>());
}
indexFacts.get(factKey).add(fact);
}
private void recursiveFetch(Map<Variable, Term> theta, Literal l,
List<Literal> remainingLiterals,
Set<Map<Variable, Term>> possibleSubstitutions) {
// Find all substitutions for current predicate based on the
// substitutions of prior predicates in the list (i.e. SUBST with
// theta).
Set<Map<Variable, Term>> pSubsts = fetch(subst(theta, l));
// No substitutions, therefore cannot continue
if (null == pSubsts) {
return;
}
for (Map<Variable, Term> psubst : pSubsts) {
// Ensure all prior substitution information is maintained
// along the chain of predicates (i.e. for shared variables
// across the predicates).
psubst.putAll(theta);
if (remainingLiterals.size() == 0) {
// This means I am at the end of the chain of predicates
// and have found a valid substitution.
possibleSubstitutions.add(psubst);
} else {
// Need to move to the next link in the chain of substitutions
Literal first = remainingLiterals.get(0);
List<Literal> rest = remainingLiterals.subList(1,
remainingLiterals.size());
recursiveFetch(psubst, first, rest, possibleSubstitutions);
}
}
}
private List<Literal> fetchMatchingFacts(Literal l) {
return indexFacts.get(getFactKey(l));
}
private String getFactKey(Literal l) {
StringBuilder key = new StringBuilder();
if (l.isPositiveLiteral()) {
key.append("+");
} else {
key.append("-");
}
key.append(l.getAtomicSentence().getSymbolicName());
return key.toString();
}
}