public static bool evaluateQuantifiedExpression(ParseTreeFOL_Q quantifiedExpression, string[] subwords, List <Assignment> varVals) { if (quantifiedExpression.getExpression() != null) { return(evaluateLogicalExpression(quantifiedExpression.getExpression(), varVals)); } bool res = false; bool endState = false; //handles the difference between "There Exists" and "For All" quantifiers if (quantifiedExpression.getFOLQuantifier() == FOLQuantifier.E) { endState = true; } else { res = true; } //until we've tried all subwords, or the result proves the quantifier true or false for (int j = 0; j < subwords.Length && res != endState; j++) { List <Assignment> newVarVals = new List <Assignment>(); newVarVals.AddRange(varVals); Assignment varVal = new Assignment(quantifiedExpression.getQuantifiedVar(), subwords[j]); newVarVals.Add(varVal); res = evaluateQuantifiedExpression(quantifiedExpression.getChild(), subwords, newVarVals); } return(res); }
private static ParseTreeFOL_Q ParseQuantifiers(string quantifierString, ParseTreeFOL_O expression) { quantifierString = FillInQuantifiers(quantifierString); string[] quantifierStrings = quantifierString.Split(':'); quantifierStrings = quantifierStrings.Reverse().ToArray(); ParseTreeFOL_Q output = new ParseTreeFOL_Q(null, null, expression); if (quantifierStrings[0] != "") { foreach (string str in quantifierStrings) { if (str.First().Equals('E')) { output = new ParseTreeFOL_Q(FOLQuantifier.E, str.Substring(1), output); } else if (str.First().Equals('A')) { output = new ParseTreeFOL_Q(FOLQuantifier.A, str.Substring(1), output); } else { throw (new Exception("Failed to parse quantifiers.")); } } } return(output); }
public static List <List <Assignment> > EvaluateParsedExpression(ParseTreeFOL_Q quantifiedExpression, string[] subwords, string[] freeVars, string body) { List <List <Assignment> > res = EvaluateQuantifiedExpression(quantifiedExpression, subwords, body); List <string> varList = freeVars.ToList(); varList.RemoveAll(var => res.Any(sol => sol.Any(a => a.GetVariableName() == var))); res = FillInSolutions(res, varList.ToArray(), subwords); return(res); }
public static string[] GetFreeVars(ParseTreeFOL_Q query) { if (query.getExpression() != null) { return(GetFreeVars(query.getExpression())); } List <string> vars = GetFreeVars(query.getChild()).ToList(); vars.Remove(query.getQuantifiedVar()); return(vars.ToArray()); }
public static List <List <Assignment> > EvaluateQuantifiedExpression(ParseTreeFOL_Q quantifiedExpression, string[] subwords, string body) { List <List <Assignment> > solutions; if (quantifiedExpression.getExpression() == null) { solutions = EvaluateQuantifiedExpression(quantifiedExpression.getChild(), subwords, body); FOLQuantifier quantifier = (FOLQuantifier)quantifiedExpression.getFOLQuantifier(); string variableName = quantifiedExpression.getQuantifiedVar(); if (quantifier == FOLQuantifier.E) { if (!solutions.Any(sol => sol.Any(assignment => assignment.GetVariableName() == variableName))) { solutions.RemoveAll(a => true); } else { solutions = FOLSearcher.removeVariable(solutions, variableName); } } else { List <List <Assignment> > newSols = new List <List <Assignment> >(); List <List <Assignment> > solsWithoutVar = FOLSearcher.removeVariable( solutions.ConvertAll(sol => new List <Assignment>(sol)), variableName); foreach (List <Assignment> solWithoutVar in solsWithoutVar) { bool include = true; foreach (string word in subwords) { List <Assignment> sol = new List <Assignment>(solWithoutVar); sol.Add(new Assignment(variableName, word)); if (!solutions.Any(solution => CompareSolutions(sol, solution))) { include = false; } } if (include) { newSols.Add(solWithoutVar); } } solutions = newSols; } } else { solutions = EvaluateLogicalExpression(quantifiedExpression.getExpression(), subwords, body); } return(solutions); }
public static List <List <Assignment> > Search(string body, string query, bool topDownSearch) { List <string> subwords = getAllSubwords(body); string folExpression = query.Substring(query.IndexOf(":=") + 2); string freeVarsString = query.Substring(query.IndexOf('(') + 1).Substring(0, query.IndexOf(')') - 2); string[] freeVars = freeVarsString.Split(','); ParseTreeFOL_Q parsedExpression = FOLParser.Parse(folExpression, body); List <List <Assignment> > res; if (topDownSearch) { res = TopDownFOLEvaluator.evaluateParsedExpression(parsedExpression, subwords.ToArray(), freeVars, body); } else { res = BottomUpFOLEvaluator.EvaluateParsedExpression(parsedExpression, subwords.ToArray(), freeVars, body); } return(res); }
public static List <List <Assignment> > evaluateParsedExpression(ParseTreeFOL_Q parsedExpression, string[] subwords, string[] freeVars, string body) { int[] freeVarValIndices = new int[freeVars.Length]; for (int i = 0; i < freeVarValIndices.Length; i++) { freeVarValIndices[i] = 0; } List <List <Assignment> > successfulValueCombinations = new List <List <Assignment> >(); do { List <Assignment> varVals = new List <Assignment> { new Assignment("S", body) }; for (int i = 0; i < freeVarValIndices.Length; i++) { Assignment varVal = new Assignment(freeVars[i], subwords[freeVarValIndices[i]]); varVals.Add(varVal); } if (evaluateQuantifiedExpression(parsedExpression, subwords.ToArray(), varVals)) { successfulValueCombinations.Add(varVals); } freeVarValIndices[freeVarValIndices.Length - 1]++; for (int i = freeVarValIndices.Length - 1; i > 0; i--) { if (freeVarValIndices[i] >= subwords.Count()) { freeVarValIndices[i] = 0; freeVarValIndices[i - 1]++; } } } while (freeVarValIndices[0] != subwords.Count()); successfulValueCombinations = FOLSearcher.removeVariable(successfulValueCombinations, "S"); return(successfulValueCombinations); }
public FOLExpression(ParseTreeFOL_Q quantifiers, ParseTreeFOL_O expression) { this.FOQuantifiers = quantifiers; this.PLExpression = expression; }
public ParseTreeFOL_Q(FOLQuantifier?folquantifier, string quantifiedVar, ParseTreeFOL_Q child) { this.folQuantifier = folquantifier; this.quantifiedVar = quantifiedVar; this.child = child; }