public void Visit(Existential visitable) => throw new System.NotImplementedException();
private Decomposition DecomposeWFF(Negation f) { if (f.inner is AtomicWFF) { return(null); } else if (f.inner is Biconditional) { Biconditional inner = (Biconditional)f.inner; List <WFF> left = new List <WFF>(); List <WFF> right = new List <WFF>(); left.Add(inner.left.GetNegation()); left.Add(inner.right); right.Add(inner.left); right.Add(inner.right.GetNegation()); return(new Decomposition(f, left, right)); } else if (f.inner is Conditional) { Conditional inner = (Conditional)f.inner; List <WFF> left = new List <WFF>(); left.Add(inner.antecedent); left.Add(inner.consequent.GetNegation()); return(new Decomposition(f, left)); } else if (f.inner is Conjunction) { Conjunction inner = (Conjunction)f.inner; List <WFF>[] conjuncts = new List <WFF> [inner.arity]; for (int a = 0; a < inner.arity; a++) { conjuncts[a] = new List <WFF>(); conjuncts[a].Add(inner.conjuncts[a].GetNegation()); } return(new Decomposition(f, conjuncts.ToArray())); } else if (f.inner is Disjunction) { Disjunction inner = (Disjunction)f.inner; List <WFF> disjuncts = new List <WFF>(); foreach (WFF d in inner.disjuncts) { disjuncts.Add(d.GetNegation()); } return(new Decomposition(f, disjuncts)); } else if (f.inner is Existential) { Existential inner = (Existential)f.inner; List <WFF> dec = new List <WFF>(); dec.Add(new Universal(inner.variable, inner.scope.GetNegation())); return(new Decomposition(f, dec)); } else if (f.inner is Negation) { Negation inner = (Negation)f.inner; List <WFF> dec = new List <WFF>(); dec.Add(inner.inner); return(new Decomposition(f, dec)); } else if (f.inner is Universal) { Universal inner = (Universal)f.inner; List <WFF> dec = new List <WFF>(); dec.Add(new Existential(inner.variable, inner.scope.GetNegation())); return(new Decomposition(f, dec)); } throw new NotImplementedException(f.inner.GetType().ToString()); }
/// <summary> /// Build the Abstract Syntax Tree using prefix expression input /// </summary> public void Build() { // Remove white space and separator (assume that operand has only 1 character) Expression = Regex.Replace(Expression, @"\s+", ""); if (Expression.Contains(",,")) { throw new ArgumentException(); } Expression = Regex.Replace(Expression, ",", ""); // Mark the appeared variables int[] variableAppeared = new int[130]; bool[] currentlyBounded = new bool[130]; // The stack used for building AST List <Symbol> utilityStack = new List <Symbol>(); for (int i = 0; i < Expression.Length; i++) { /////// Close parenthesis, the signal to trigger an operation if (Expression[i] == ')') { HandleCloseBracket(utilityStack, currentlyBounded, variableAppeared); } /////// End Close parenthesis else if (availablePlaceholder.Contains(Expression[i])) { utilityStack.Add(new Placeholder(Expression[i])); } // Predicate P(x,y,z,t) else if (availablePredicate.Contains(Expression[i])) { //NumPredicateVariables[Expression[i]] = Predicate P = new Predicate(Expression[i]); utilityStack.Add(P); // P takes 0 object variables if (i == Expression.Length - 1 || Expression[i + 1] != '(') { if (NumPredicateVariables[P.Name] > 0) { throw new InvalidDataException("Wrong number of object variables for predicate " + P.Name); } NumPredicateVariables[P.Name] = 0; P.nChild = 0; } variableAppeared[P.Name]++; } // Variable else if (availableVariable.Contains(Expression[i])) { variableAppeared[Expression[i]]++; Variable v = new Variable(Expression[i]); if (currentlyBounded[Expression[i]]) { v.Bounded = true; } utilityStack.Add(v); } // Constant (True/False) else if (availableConstant.Contains(Expression[i])) { Constant cons = new Constant(Expression[i]); utilityStack.Add(cons); } // Operator else if (availableOperator.Contains(Expression[i])) { Symbol currentOperator; switch (Expression[i]) { case '&': currentOperator = new And(); break; case '|': currentOperator = new Or(); break; case '%': currentOperator = new Nand(); break; case '=': currentOperator = new BiImplication(); break; case '>': currentOperator = new Implication(); break; case '~': currentOperator = new Not(); break; default: currentOperator = new And(); break; } // add to stack utilityStack.Add(currentOperator); } else if (availableQuantifier.Contains(Expression[i])) { HasQuantifier = true; char quantName = Expression[i]; string tmpBoundVar = ""; for (int j = i + 1; j < Expression.Length; j++) { if (availableVariable.Contains(Expression[j])) { tmpBoundVar += Expression[j]; currentlyBounded[Expression[j]] = true; } else if (Expression[j] != '.' || j == i + 1) { throw new ArgumentException("Wrong input format at " + j); } else { i = j; break; } } Symbol currentQuantifier; switch (quantName) { case '@': currentQuantifier = new Universal(tmpBoundVar); break; default: currentQuantifier = new Existential(tmpBoundVar); break; } utilityStack.Add(currentQuantifier); } // Invalid symbol else { throw new ArgumentException("Invalid symbol."); } } if (utilityStack.Count != 1) { throw new ArgumentException("Wrong format."); } Root = utilityStack[0]; for (char c = 'A'; c <= 'Z'; c++) { if (variableAppeared[c] > 0) { ListVariable.Add(c); } } for (char c = 'a'; c <= 'z'; c++) { if (variableAppeared[c] > 0) { ListVariable.Add(c); } } }
public void Visit(Existential visitable) => visitable.InFixFormula = $"!{visitable.Variables()}[{visitable.LeftNode.InFixFormula}]";