package aima.gui.demo.logic;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;
import aima.core.logic.fol.CNFConverter;
import aima.core.logic.fol.StandardizeApartIndexicalFactory;
import aima.core.logic.fol.Unifier;
import aima.core.logic.fol.domain.DomainFactory;
import aima.core.logic.fol.domain.FOLDomain;
import aima.core.logic.fol.inference.Demodulation;
import aima.core.logic.fol.inference.FOLBCAsk;
import aima.core.logic.fol.inference.FOLFCAsk;
import aima.core.logic.fol.inference.FOLModelElimination;
import aima.core.logic.fol.inference.FOLOTTERLikeTheoremProver;
import aima.core.logic.fol.inference.FOLTFMResolution;
import aima.core.logic.fol.inference.InferenceProcedure;
import aima.core.logic.fol.inference.InferenceResult;
import aima.core.logic.fol.inference.Paramodulation;
import aima.core.logic.fol.inference.proof.Proof;
import aima.core.logic.fol.inference.proof.ProofPrinter;
import aima.core.logic.fol.kb.FOLKnowledgeBase;
import aima.core.logic.fol.kb.FOLKnowledgeBaseFactory;
import aima.core.logic.fol.kb.data.CNF;
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.AtomicSentence;
import aima.core.logic.fol.parsing.ast.Constant;
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.TermEquality;
import aima.core.logic.fol.parsing.ast.Variable;
/**
* @author Ravi Mohan
* @author Ciaran O'Reilly
*/
public class FolDemo {
public static void main(String[] args) {
unifierDemo();
fOL_fcAskDemo();
fOL_bcAskDemo();
fOL_CNFConversion();
fOL_TFMResolutionDemo();
fOL_Demodulation();
fOL_Paramodulation();
fOL_OTTERDemo();
fOL_ModelEliminationDemo();
}
private static void unifierDemo() {
FOLParser parser = new FOLParser(DomainFactory.knowsDomain());
Unifier unifier = new Unifier();
Map<Variable, Term> theta = new Hashtable<Variable, Term>();
Sentence query = parser.parse("Knows(John,x)");
Sentence johnKnowsJane = parser.parse("Knows(y,Mother(y))");
System.out.println("------------");
System.out.println("Unifier Demo");
System.out.println("------------");
Map<Variable, Term> subst = unifier.unify(query, johnKnowsJane, theta);
System.out.println("Unify '" + query + "' with '" + johnKnowsJane
+ "' to get the substitution " + subst + ".");
System.out.println("");
}
private static void fOL_fcAskDemo() {
System.out.println("---------------------------");
System.out.println("Forward Chain, Kings Demo 1");
System.out.println("---------------------------");
kingsDemo1(new FOLFCAsk());
System.out.println("---------------------------");
System.out.println("Forward Chain, Kings Demo 2");
System.out.println("---------------------------");
kingsDemo2(new FOLFCAsk());
System.out.println("---------------------------");
System.out.println("Forward Chain, Weapons Demo");
System.out.println("---------------------------");
weaponsDemo(new FOLFCAsk());
}
private static void fOL_bcAskDemo() {
System.out.println("----------------------------");
System.out.println("Backward Chain, Kings Demo 1");
System.out.println("----------------------------");
kingsDemo1(new FOLBCAsk());
System.out.println("----------------------------");
System.out.println("Backward Chain, Kings Demo 2");
System.out.println("----------------------------");
kingsDemo2(new FOLBCAsk());
System.out.println("----------------------------");
System.out.println("Backward Chain, Weapons Demo");
System.out.println("----------------------------");
weaponsDemo(new FOLBCAsk());
}
private static void fOL_CNFConversion() {
System.out.println("-------------------------------------------------");
System.out.println("Conjuctive Normal Form for First Order Logic Demo");
System.out.println("-------------------------------------------------");
FOLDomain domain = DomainFactory.lovesAnimalDomain();
FOLParser parser = new FOLParser(domain);
Sentence origSentence = parser
.parse("FORALL x (FORALL y (Animal(y) => Loves(x, y)) => EXISTS y Loves(y, x))");
CNFConverter cnfConv = new CNFConverter(parser);
CNF cnf = cnfConv.convertToCNF(origSentence);
System.out.println("Convert '" + origSentence + "' to CNF.");
System.out.println("CNF=" + cnf.toString());
System.out.println("");
}
private static void fOL_TFMResolutionDemo() {
System.out.println("----------------------------");
System.out.println("TFM Resolution, Kings Demo 1");
System.out.println("----------------------------");
kingsDemo1(new FOLTFMResolution());
System.out.println("----------------------------");
System.out.println("TFM Resolution, Kings Demo 2");
System.out.println("----------------------------");
kingsDemo2(new FOLTFMResolution());
System.out.println("----------------------------");
System.out.println("TFM Resolution, Weapons Demo");
System.out.println("----------------------------");
weaponsDemo(new FOLTFMResolution());
System.out.println("---------------------------------");
System.out.println("TFM Resolution, Loves Animal Demo");
System.out.println("---------------------------------");
lovesAnimalDemo(new FOLTFMResolution());
System.out.println("---------------------------------------");
System.out.println("TFM Resolution, ABC Equality Axiom Demo");
System.out.println("---------------------------------------");
abcEqualityAxiomDemo(new FOLTFMResolution());
}
private static void fOL_Demodulation() {
System.out.println("-----------------");
System.out.println("Demodulation Demo");
System.out.println("-----------------");
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
domain.addConstant("C");
domain.addConstant("D");
domain.addConstant("E");
domain.addPredicate("P");
domain.addFunction("F");
domain.addFunction("G");
domain.addFunction("H");
domain.addFunction("J");
FOLParser parser = new FOLParser(domain);
Predicate expression = (Predicate) parser
.parse("P(A,F(B,G(A,H(B)),C),D)");
TermEquality assertion = (TermEquality) parser.parse("B = E");
Demodulation demodulation = new Demodulation();
Predicate altExpression = (Predicate) demodulation.apply(assertion,
expression);
System.out.println("Demodulate '" + expression + "' with '" + assertion
+ "' to give");
System.out.println(altExpression.toString());
System.out.println("and again to give");
System.out.println(demodulation.apply(assertion, altExpression)
.toString());
System.out.println("");
}
private static void fOL_Paramodulation() {
System.out.println("-------------------");
System.out.println("Paramodulation Demo");
System.out.println("-------------------");
FOLDomain domain = new FOLDomain();
domain.addConstant("A");
domain.addConstant("B");
domain.addPredicate("P");
domain.addPredicate("Q");
domain.addPredicate("R");
domain.addFunction("F");
FOLParser parser = new FOLParser(domain);
List<Literal> lits = new ArrayList<Literal>();
AtomicSentence a1 = (AtomicSentence) parser.parse("P(F(x,B),x)");
AtomicSentence a2 = (AtomicSentence) parser.parse("Q(x)");
lits.add(new Literal(a1));
lits.add(new Literal(a2));
Clause c1 = new Clause(lits);
lits.clear();
a1 = (AtomicSentence) parser.parse("F(A,y) = y");
a2 = (AtomicSentence) parser.parse("R(y)");
lits.add(new Literal(a1));
lits.add(new Literal(a2));
Clause c2 = new Clause(lits);
Paramodulation paramodulation = new Paramodulation();
Set<Clause> paras = paramodulation.apply(c1, c2);
System.out.println("Paramodulate '" + c1 + "' with '" + c2
+ "' to give");
System.out.println(paras.toString());
System.out.println("");
}
private static void fOL_OTTERDemo() {
System.out.println("---------------------------------------");
System.out.println("OTTER Like Theorem Prover, Kings Demo 1");
System.out.println("---------------------------------------");
kingsDemo1(new FOLOTTERLikeTheoremProver());
System.out.println("---------------------------------------");
System.out.println("OTTER Like Theorem Prover, Kings Demo 2");
System.out.println("---------------------------------------");
kingsDemo2(new FOLOTTERLikeTheoremProver());
System.out.println("---------------------------------------");
System.out.println("OTTER Like Theorem Prover, Weapons Demo");
System.out.println("---------------------------------------");
weaponsDemo(new FOLOTTERLikeTheoremProver());
System.out.println("--------------------------------------------");
System.out.println("OTTER Like Theorem Prover, Loves Animal Demo");
System.out.println("--------------------------------------------");
lovesAnimalDemo(new FOLOTTERLikeTheoremProver());
System.out
.println("--------------------------------------------------");
System.out
.println("OTTER Like Theorem Prover, ABC Equality Axiom Demo");
System.out
.println("--------------------------------------------------");
abcEqualityAxiomDemo(new FOLOTTERLikeTheoremProver(false));
System.out
.println("-----------------------------------------------------");
System.out
.println("OTTER Like Theorem Prover, ABC Equality No Axiom Demo");
System.out
.println("-----------------------------------------------------");
abcEqualityNoAxiomDemo(new FOLOTTERLikeTheoremProver(true));
}
private static void fOL_ModelEliminationDemo() {
System.out.println("-------------------------------");
System.out.println("Model Elimination, Kings Demo 1");
System.out.println("-------------------------------");
kingsDemo1(new FOLModelElimination());
System.out.println("-------------------------------");
System.out.println("Model Elimination, Kings Demo 2");
System.out.println("-------------------------------");
kingsDemo2(new FOLModelElimination());
System.out.println("-------------------------------");
System.out.println("Model Elimination, Weapons Demo");
System.out.println("-------------------------------");
weaponsDemo(new FOLModelElimination());
System.out.println("------------------------------------");
System.out.println("Model Elimination, Loves Animal Demo");
System.out.println("------------------------------------");
lovesAnimalDemo(new FOLModelElimination());
System.out.println("------------------------------------------");
System.out.println("Model Elimination, ABC Equality Axiom Demo");
System.out.println("-------------------------------------------");
abcEqualityAxiomDemo(new FOLModelElimination());
}
private static void kingsDemo1(InferenceProcedure ip) {
StandardizeApartIndexicalFactory.flush();
FOLKnowledgeBase kb = FOLKnowledgeBaseFactory
.createKingsKnowledgeBase(ip);
String kbStr = kb.toString();
List<Term> terms = new ArrayList<Term>();
terms.add(new Constant("John"));
Predicate query = new Predicate("Evil", terms);
InferenceResult answer = kb.ask(query);
System.out.println("Kings Knowledge Base:");
System.out.println(kbStr);
System.out.println("Query: " + query);
for (Proof p : answer.getProofs()) {
System.out.print(ProofPrinter.printProof(p));
System.out.println("");
}
}
private static void kingsDemo2(InferenceProcedure ip) {
StandardizeApartIndexicalFactory.flush();
FOLKnowledgeBase kb = FOLKnowledgeBaseFactory
.createKingsKnowledgeBase(ip);
String kbStr = kb.toString();
List<Term> terms = new ArrayList<Term>();
terms.add(new Variable("x"));
Predicate query = new Predicate("King", terms);
InferenceResult answer = kb.ask(query);
System.out.println("Kings Knowledge Base:");
System.out.println(kbStr);
System.out.println("Query: " + query);
for (Proof p : answer.getProofs()) {
System.out.print(ProofPrinter.printProof(p));
}
}
private static void weaponsDemo(InferenceProcedure ip) {
StandardizeApartIndexicalFactory.flush();
FOLKnowledgeBase kb = FOLKnowledgeBaseFactory
.createWeaponsKnowledgeBase(ip);
String kbStr = kb.toString();
List<Term> terms = new ArrayList<Term>();
terms.add(new Variable("x"));
Predicate query = new Predicate("Criminal", terms);
InferenceResult answer = kb.ask(query);
System.out.println("Weapons Knowledge Base:");
System.out.println(kbStr);
System.out.println("Query: " + query);
for (Proof p : answer.getProofs()) {
System.out.print(ProofPrinter.printProof(p));
System.out.println("");
}
}
private static void lovesAnimalDemo(InferenceProcedure ip) {
StandardizeApartIndexicalFactory.flush();
FOLKnowledgeBase kb = FOLKnowledgeBaseFactory
.createLovesAnimalKnowledgeBase(ip);
String kbStr = kb.toString();
List<Term> terms = new ArrayList<Term>();
terms.add(new Constant("Curiosity"));
terms.add(new Constant("Tuna"));
Predicate query = new Predicate("Kills", terms);
InferenceResult answer = kb.ask(query);
System.out.println("Loves Animal Knowledge Base:");
System.out.println(kbStr);
System.out.println("Query: " + query);
for (Proof p : answer.getProofs()) {
System.out.print(ProofPrinter.printProof(p));
System.out.println("");
}
}
private static void abcEqualityAxiomDemo(InferenceProcedure ip) {
StandardizeApartIndexicalFactory.flush();
FOLKnowledgeBase kb = FOLKnowledgeBaseFactory
.createABCEqualityKnowledgeBase(ip, true);
String kbStr = kb.toString();
TermEquality query = new TermEquality(new Constant("A"), new Constant(
"C"));
InferenceResult answer = kb.ask(query);
System.out.println("ABC Equality Axiom Knowledge Base:");
System.out.println(kbStr);
System.out.println("Query: " + query);
for (Proof p : answer.getProofs()) {
System.out.print(ProofPrinter.printProof(p));
System.out.println("");
}
}
private static void abcEqualityNoAxiomDemo(InferenceProcedure ip) {
StandardizeApartIndexicalFactory.flush();
FOLKnowledgeBase kb = FOLKnowledgeBaseFactory
.createABCEqualityKnowledgeBase(ip, false);
String kbStr = kb.toString();
TermEquality query = new TermEquality(new Constant("A"), new Constant(
"C"));
InferenceResult answer = kb.ask(query);
System.out.println("ABC Equality No Axiom Knowledge Base:");
System.out.println(kbStr);
System.out.println("Query: " + query);
for (Proof p : answer.getProofs()) {
System.out.print(ProofPrinter.printProof(p));
System.out.println("");
}
}
}