lcs = clausesGroupedBySize[j];\n\t\t\t foreach (Clause sc in scs)\n\t\t\t {\n\t\t\t\t// Don't bother checking clauses\n\t\t\t\t// that are already subsumed.\n\t\t\t\tif (!subsumed.Contains(sc))\n\t\t\t\t{\n\t\t\t\t foreach (Clause lc in lcs)\n\t\t\t\t {\n\t\t\t\t\tif (!subsumed.Contains(lc))\n\t\t\t\t\t{\n\t\t\t\t\t if (sc.subsumes(lc))\n\t\t\t\t\t {\n\t\t\t\t\t\tsubsumed.Add(lc);\n\t\t\t\t\t }\n\t\t\t\t\t}\n\t\t\t\t }\n\t\t\t\t}\n\t\t\t }\n\t\t\t}\n\t\t }\n\t\t}\n\t }\n\t return subsumed;\n\t}\n }\n}"
},
{
"path": "aima-csharp/logic/fol/Unifier.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing aima.core.logic.fol.parsing.ast;\n\nnamespace aima.core.logic.fol\n{\n /**\n * Artificial Intelligence A Modern Approach (3rd Edition): Figure 9.1, page\n * 328.
\n *
\n * \n * \n * function UNIFY(x, y, theta) returns a substitution to make x and y identical\n * inputs: x, a variable, constant, list, or compound\n * y, a variable, constant, list, or compound\n * theta, the substitution built up so far (optional, defaults to empty)\n * \n * if theta = failure then return failure\n * else if x = y the return theta\n * else if VARIABLE?(x) then return UNIVY-VAR(x, y, theta)\n * else if VARIABLE?(y) then return UNIFY-VAR(y, x, theta)\n * else if COMPOUND?(x) and COMPOUND?(y) then\n * return UNIFY(x.ARGS, y.ARGS, UNIFY(x.OP, y.OP, theta))\n * else if LIST?(x) and LIST?(y) then\n * return UNIFY(x.REST, y.REST, UNIFY(x.FIRST, y.FIRST, theta))\n * else return failure\n * \n * ---------------------------------------------------------------------------------------------------\n * \n * function UNIFY-VAR(var, x, theta) returns a substitution\n * \n * if {var/val} E theta then return UNIFY(val, x, theta)\n * else if {x/val} E theta then return UNIFY(var, val, theta)\n * else if OCCUR-CHECK?(var, x) then return failure\n * else return add {var/x} to theta\n * \n * \n * Figure 9.1 The unification algorithm. The algorithm works by comparing the\n * structures of the inputs, elements by element. The substitution theta that is\n * the argument to UNIFY is built up along the way and is used to make sure that\n * later comparisons are consistent with bindings that were established earlier.\n * In a compound expression, such as F(A, B), the OP field picks out the\n * function symbol F and the ARGS field picks out the argument list (A, B).\n * \n * @author Ciaran O'Reilly\n * @author Ravi Mohan\n * @author Mike Stampone\n * \n */\n public class Unifier\n {\n\tprivate static SubstVisitor _substVisitor = new SubstVisitor();\n private VariableCollector _variableCollector;\n\n public Unifier()\n\t{\n\n\t}\n\n\t/**\n\t * Returns a Dictionary representing the substitution (i.e. a set\n\t * of variable/term pairs) or null which is used to indicate a failure to\n\t * unify.\n\t * \n\t * @param x\n\t * a variable, constant, list, or compound\n\t * @param y\n\t * a variable, constant, list, or compound\n\t * \n\t * @return a Dictionary representing the substitution (i.e. a set\n\t * of variable/term pairs) or null which is used to indicate a\n\t * failure to unify.\n\t */\n\tpublic Dictionary unify(FOLNode x, FOLNode y)\n\t{\n\t return unify(x, y, new Dictionary());\n\t}\n\n\t/**\n\t * Returns a Dictionary representing the substitution (i.e. a set\n\t * of variable/term pairs) or null which is used to indicate a failure to\n\t * unify.\n\t * \n\t * @param x\n\t * a variable, constant, list, or compound\n\t * @param y\n\t * a variable, constant, list, or compound\n\t * @param theta\n\t * the substitution built up so far\n\t * \n\t * @return a Dictionary representing the substitution (i.e. a set\n\t * of variable/term pairs) or null which is used to indicate a\n\t * failure to unify.\n\t */\n\tpublic Dictionary unify(FOLNode x, FOLNode y,\n\t\tDictionary theta)\n\t{\n\t // if theta = failure then return failure\n\t if (theta == null)\n\t {\n\t\treturn null;\n\t }\n\t else if (x.Equals(y))\n\t {\n\t\t// else if x = y then return theta\n\t\treturn theta;\n\t }\n\t else if (x is Variable)\n\t {\n\t\t// else if VARIABLE?(x) then return UNIVY-VAR(x, y, theta)\n\t\treturn unifyVar((Variable)x, y, theta);\n\t }\n\t else if (y is Variable)\n\t {\n\t\t// else if VARIABLE?(y) then return UNIFY-VAR(y, x, theta)\n\t\treturn unifyVar((Variable)y, x, theta);\n\t }\n\t else if (isCompound(x) && isCompound(y))\n\t {\n\t\t// else if COMPOUND?(x) and COMPOUND?(y) then\n\t\t// return UNIFY(x.ARGS, y.ARGS, UNIFY(x.OP, y.OP, theta))\n\t\treturn unify(args(x), args(y), unifyOps(op(x), op(y), theta));\n\t }\n\t else\n\t {\n\t\t// else return failure\n\t\treturn null;\n\t }\n\t}\n\n\t/**\n\t * Returns a Dictionary representing the substitution (i.e. a set\n\t * of variable/term pairs) or null which is used to indicate a failure to\n\t * unify.\n\t * \n\t * @param x\n\t * a variable, constant, list, or compound\n\t * @param y\n\t * a variable, constant, list, or compound\n\t * @param theta\n\t * the substitution built up so far\n\t * \n\t * @return a Dictionary representing the substitution (i.e. a set\n\t * of variable/term pairs) or null which is used to indicate a\n\t * failure to unify.\n\t */\n\t// else if LIST?(x) and LIST?(y) then\n\t// return UNIFY(x.REST, y.REST, UNIFY(x.FIRST, y.FIRST, theta))\n\tpublic Dictionary unify(List x,\n\t List y, Dictionary theta)\n\t{\n\t if (theta == null)\n\t {\n\t\treturn null;\n\t }\n\t else if (x.Count != y.Count)\n\t {\n\t\treturn null;\n\t }\n\t else if (x.Count == 0 && y.Count == 0)\n\t {\n\t\treturn theta;\n\t }\n\t else if (x.Count == 1 && y.Count == 1)\n\t {\n\t\treturn unify(x[0], y[0], theta);\n\t }\n\t else\n\t {\n\t\treturn unify(x.Skip(1).ToList(), y.Skip(1).ToList(), unify(\n\t\t\tx[0], y[0], theta));\n\t }\n\t}\n\n\t// PROTECTED METHODS\n\n\t// Note: You can subclass and override this method in order\n\t// to re-implement the OCCUR-CHECK?() to always\n\t// return false if you want that to be the default\n\t// behavior, as is the case with Prolog.\n\tprotected bool occurCheck(Dictionary theta, Variable var,\n\t FOLNode x)\n\t{\n\t if (x is Function)\n\t {\n\t\tList varsToCheck = _variableCollector\n\t\t\t.collectAllVariables((Function)x);\n\t\tif (varsToCheck.Contains(var))\n\t\t{\n\t\t return true;\n\t\t}\n\n\t\t// Now need to check if cascading will cause occurs to happen\n\t\t// e.g.\n\t\t// Loves(SF1(v2),v2)\n\t\t// Loves(v3,SF0(v3))\n\t\t// or\n\t\t// P(v1,SF0(v1),SF0(v1))\n\t\t// P(v2,SF0(v2),v2 )\n\t\t// or\n\t\t// P(v1, F(v2),F(v2),F(v2),v1, F(F(v1)),F(F(F(v1))),v2)\n\t\t// P(F(v3),v4, v5, v6, F(F(v5)),v4, F(v3), F(F(v5)))\n\t\treturn cascadeOccurCheck(theta, var, varsToCheck,\n\t\t\tnew List(varsToCheck));\n\t }\n\t return false;\n\t}\n\n\t// PRIVATE METHODS\n\n\t/**\n * \n * function UNIFY-VAR(var, x, theta) returns a substitution\n * inputs: var, a variable\n * x, any expression\n * theta, the substitution built up so far\n * \n */\n\tprivate Dictionary unifyVar(Variable var, FOLNode x,\n\t\tDictionary theta)\n\t{\n\n\t if (!(x is Term))\n\t {\n\t\treturn null;\n\t }\n\t else if (theta.ContainsKey(var))\n\t {\n\t\t// if {var/val} E theta then return UNIFY(val, x, theta)\n\t\treturn unify(theta[var], x, theta);\n\t }\n\t else if (theta.Keys.Contains(x))\n\t {\n\t\t// else if {x/val} E theta then return UNIFY(var, val, theta)\n\t\treturn unify(var, (FOLNode)theta[(Variable)x], theta);\n\t }\n\t else if (occurCheck(theta, var, x))\n\t {\n\t\t// else if OCCUR-CHECK?(var, x) then return failure\n\t\treturn null;\n\t }\n\t else\n\t {\n\t\t// else return add {var/x} to theta\n\t\tcascadeSubstitution(theta, var, (Term)x);\n\t\treturn theta;\n\t }\n\t}\n\n\tprivate Dictionary unifyOps(String x, String y,\n\t\tDictionary theta)\n\t{\n\t if (theta == null)\n\t {\n\t\treturn null;\n\t }\n\t else if (x.Equals(y))\n\t {\n\t\treturn theta;\n\t }\n\t else\n\t {\n\t\treturn null;\n\t }\n\t}\n\n\tprivate List args(FOLNode x)\n\t{\n\t return x.getArgs();\n\t}\n\n\tprivate String op(FOLNode x)\n\t{\n\t return x.getSymbolicName();\n\t}\n\n\tprivate bool isCompound(FOLNode x)\n\t{\n\t return x.isCompound();\n\t}\n\n\tprivate bool cascadeOccurCheck(Dictionary theta, Variable var,\n\t List varsToCheck, List varsCheckedAlready)\n\t{\n\t // Want to check if any of the variable to check end up\n\t // looping back around on the new variable.\n\t List nextLevelToCheck = new List();\n\t foreach (Variable v in varsToCheck)\n\t {\n\t\tTerm t = null;\n\t\tif (theta.ContainsKey(v))\n\t\t{\n\t\t t = theta[v];\n\t\t}\n\t\tif (null == t)\n\t\t{\n\t\t // Variable may not be a key so skip\n\t\t continue;\n\t\t}\n\t\tif (t.Equals(var))\n\t\t{\n\t\t // e.g.\n\t\t // v1=v2\n\t\t // v2=SFO(v1)\n\t\t return true;\n\t\t}\n\t\telse if (t is Function)\n\t\t{\n\t\t // Need to ensure the function this variable\n\t\t // is to be replaced by does not contain var.\n\t\t List indirectvars = _variableCollector\n\t\t\t .collectAllVariables(t);\n\t\t if (indirectvars.Contains(var))\n\t\t {\n\t\t\treturn true;\n\t\t }\n\t\t else\n\t\t {\n\t\t\t// Determine the next cascade/level\n\t\t\t// of variables to check for looping\n\t\t\tforeach (Variable iv in indirectvars)\n\t\t\t{\n\t\t\t if (!varsCheckedAlready.Contains(iv))\n\t\t\t {\n\t\t\t\tnextLevelToCheck.Add(iv);\n\t\t\t }\n\t\t\t}\n\t\t }\n\t\t}\n\t }\n\t if (nextLevelToCheck.Count > 0)\n\t {\n\t\tvarsCheckedAlready.AddRange(nextLevelToCheck);\n\t\treturn cascadeOccurCheck(theta, var, nextLevelToCheck,\n\t\t\tvarsCheckedAlready);\n\t }\n\t return false;\n\t}\n\n\t// See:\n\t// http://logic.stanford.edu/classes/cs157/2008/miscellaneous/faq.html#jump165\n\t// for need for this.\n\tprivate void cascadeSubstitution(Dictionary theta, Variable var,\n\t\tTerm x)\n\t{\n\t theta.Add(var, x);\n\t List thetaKeys = theta.Keys.ToList();\n\t foreach (Variable v in thetaKeys)\n\t {\n\t\tTerm t = theta[v];\n\t\tif (theta.ContainsKey(v))\n\t\t{\n\t\t theta[v] = _substVisitor.subst(theta, t);\n\t\t}\n\t\telse\n\t\t{\n\t\t theta.Add(v, _substVisitor.subst(theta, t));\n\t\t}\n\t }\n\t}\n }\n}\n"
},
{
"path": "aima-csharp/logic/fol/VariableCollector.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing aima.core.logic.fol.parsing;\nusing aima.core.logic.fol.parsing.ast;\nusing aima.core.logic.fol.kb.data;\n\nnamespace aima.core.logic.fol\n{\n /**\n * @author Ravi Mohan\n * @author Ciaran O'Reilly\n */\n public class VariableCollector : FOLVisitor\n {\n\tpublic VariableCollector()\n\t{\n\n\t}\n\n\n\t// Note: The set guarantees the order in which they were\n\t// found.\n\tpublic List collectAllVariables(Sentence sentence)\n\t{\n\t List variables = new List();\n\n\t sentence.accept(this, variables);\n\n\t return variables;\n\t}\n\n\tpublic List collectAllVariables(Term aTerm)\n\t{\n\t List variables = new List();\n\n\t aTerm.accept(this, variables);\n\n\t return variables;\n\t}\n\n\tpublic List collectAllVariables(Clause aClause)\n\t{\n\t List variables = new List();\n\n\t foreach (Literal l in aClause.getLiterals())\n\t {\n\t\tl.getAtomicSentence().accept(this, variables);\n\t }\n\n\t return variables;\n\t}\n\n\tpublic List collectAllVariables(Chain aChain)\n\t{\n\t List variables = new List();\n\n\t foreach (Literal l in aChain.getLiterals())\n\t {\n\t\tl.getAtomicSentence().accept(this, variables);\n\t }\n\n\t return variables;\n\t}\n\n\tpublic Object visitVariable(Variable var, Object arg)\n\t{\n\t List variables = (List)arg;\n\t variables.Add(var);\n\t return var;\n\t}\n\n\tpublic Object visitQuantifiedSentence(QuantifiedSentence sentence,\n\t\tObject arg)\n\t{\n\t // Ensure I collect quantified variables too\n\t List variables = (List)arg;\n\t variables.AddRange(sentence.getVariables());\n\n\t sentence.getQuantified().accept(this, arg);\n\n\t return sentence;\n\t}\n\n\tpublic Object visitPredicate(Predicate predicate, Object arg)\n\t{\n\t foreach (Term t in predicate.getTerms())\n\t {\n\t\tt.accept(this, arg);\n\t }\n\t return predicate;\n\t}\n\n\tpublic Object visitTermEquality(TermEquality equality, Object arg)\n\t{\n\t equality.getTerm1().accept(this, arg);\n\t equality.getTerm2().accept(this, arg);\n\t return equality;\n\t}\n\n\tpublic Object visitConstant(Constant constant, Object arg)\n\t{\n\t return constant;\n\t}\n\n\tpublic Object visitFunction(Function function, Object arg)\n\t{\n\t foreach (Term t in function.getTerms())\n\t {\n\t\tt.accept(this, arg);\n\t }\n\t return function;\n\t}\n\n\tpublic Object visitNotSentence(NotSentence sentence, Object arg)\n\t{\n\t sentence.getNegated().accept(this, arg);\n\t return sentence;\n\t}\n\n\tpublic Object visitConnectedSentence(ConnectedSentence sentence, Object arg)\n\t{\n\t sentence.getFirst().accept(this, arg);\n\t sentence.getSecond().accept(this, arg);\n\t return sentence;\n\t}\n }\n}"
},
{
"path": "aima-csharp/logic/fol/domain/DomainFactory.cs",
"content": "using System;\n\nnamespace aima.core.logic.fol.domain\n{\n /**\n * @author Ravi Mohan\n * \n */\n public class DomainFactory\n {\n\tpublic static FOLDomain crusadesDomain()\n\t{\n\t FOLDomain domain = new FOLDomain();\n\t domain.addConstant(\"John\");\n\t domain.addConstant(\"Richard\");\n\t domain.addConstant(\"England\");\n\t domain.addConstant(\"Saladin\");\n\t domain.addConstant(\"Crown\");\n\n\t domain.addFunction(\"LeftLegOf\");\n\t domain.addFunction(\"BrotherOf\");\n\t domain.addFunction(\"EnemyOf\");\n\t domain.addFunction(\"LegsOf\");\n\n\t domain.addPredicate(\"King\");\n\t return domain;\n\t}\n\n\tpublic static FOLDomain knowsDomain()\n\t{\n\t FOLDomain domain = new FOLDomain();\n\t domain.addConstant(\"John\");\n\t domain.addConstant(\"Jane\");\n\t domain.addConstant(\"Bill\");\n\t domain.addConstant(\"Elizabeth\");\n\t domain.addFunction(\"Mother\");\n\t domain.addPredicate(\"Knows\");\n\n\t return domain;\n\t}\n\n\tpublic static FOLDomain weaponsDomain()\n\t{\n\n\t FOLDomain domain = new FOLDomain();\n\t domain.addConstant(\"West\");\n\t domain.addConstant(\"America\");\n\t domain.addConstant(\"M1\");\n\t domain.addConstant(\"Nono\");\n\t domain.addPredicate(\"American\");\n\t domain.addPredicate(\"Weapon\");\n\t domain.addPredicate(\"Sells\");\n\t domain.addPredicate(\"Hostile\");\n\t domain.addPredicate(\"Criminal\");\n\t domain.addPredicate(\"Missile\");\n\t domain.addPredicate(\"Owns\");\n\t domain.addPredicate(\"Enemy\");\n\n\t return domain;\n\t}\n\n\tpublic static FOLDomain kingsDomain()\n\t{\n\t FOLDomain domain = new FOLDomain();\n\t domain.addConstant(\"John\");\n\t domain.addConstant(\"Richard\");\n\t domain.addPredicate(\"King\");\n\t domain.addPredicate(\"Greedy\");\n\t domain.addPredicate(\"Evil\");\n\n\t return domain;\n\t}\n\n\tpublic static FOLDomain lovesAnimalDomain()\n\t{\n\t FOLDomain domain = new FOLDomain();\n\t domain.addPredicate(\"Animal\");\n\t domain.addPredicate(\"Loves\");\n\t domain.addPredicate(\"Kills\");\n\t domain.addPredicate(\"Cat\");\n\t domain.addConstant(\"Jack\");\n\t domain.addConstant(\"Tuna\");\n\t domain.addConstant(\"Curiosity\");\n\n\t return domain;\n\t}\n\n\tpublic static FOLDomain ringOfThievesDomain()\n\t{\n\t FOLDomain domain = new FOLDomain();\n\t domain.addPredicate(\"Parent\");\n\t domain.addPredicate(\"Caught\");\n\t domain.addPredicate(\"Friend\");\n\t domain.addPredicate(\"Skis\");\n\t domain.addConstant(\"Mike\");\n\t domain.addConstant(\"Joe\");\n\t domain.addConstant(\"Janet\");\n\t domain.addConstant(\"Nancy\");\n\t domain.addConstant(\"Ernie\");\n\t domain.addConstant(\"Bert\");\n\t domain.addConstant(\"Red\");\n\t domain.addConstant(\"Drew\");\n\n\t return domain;\n\t}\n }\n}"
},
{
"path": "aima-csharp/logic/fol/domain/FOLDomain.cs",
"content": "using System;\nusing System.Collections.Generic;\nusing aima.core.util;\n\nnamespace aima.core.logic.fol.domain\n{\n /**\n * @author Ravi Mohan\n * @author Ciaran O'Reilly\n */\n public class FOLDomain\n {\n\tprivate HashSet constants, functions, predicates;\n\tprivate int skolemConstantIndexical = 0;\n\tprivate int skolemFunctionIndexical = 0;\n\tprivate int answerLiteralIndexical = 0;\n\tprivate List listeners = new List();\n\n\tpublic FOLDomain()\n\t{\n\t this.constants = new HashSet();\n\t this.functions = new HashSet();\n\t this.predicates = new HashSet