private bool IsBetaRule(Proposition proposition) { if (proposition.GetType() == typeof(Negation)) { Negation n = (Negation)proposition; return(n.LeftSuccessor.GetType() == typeof(Conjunction) || n.LeftSuccessor.GetType() == typeof(BiImplication)); } if (proposition.GetType() == typeof(Nand)) { return(true); } if (proposition.GetType() == typeof(Disjunction)) { return(true); } if (proposition.GetType() == typeof(Implication)) { return(true); } if (proposition.GetType() == typeof(BiImplication)) { return(true); } return(false); }
// Both, but equals still needs to be overriden for predicates protected bool IsContradiction(Proposition proposition1, Proposition proposition2) { Negation negatedProposition = null; Proposition targetLiteral = null; if (proposition1 is Negation) { negatedProposition = (Negation)proposition1; targetLiteral = proposition2; } if (proposition2 is Negation) { negatedProposition = (Negation)proposition2; targetLiteral = proposition1; } if (negatedProposition != null) { Proposition negatedSuccessor = negatedProposition.LeftSuccessor; return(negatedSuccessor.Equals(targetLiteral)); } return(false); }
private void ApplyDoubleNegationRule(Proposition proposition) { HashSet <Proposition> propositions = new HashSet <Proposition>(); foreach (Proposition p in Propositions) { if (!p.Equals(proposition)) { propositions.Add(p); } } Proposition doubleNegationRemoved = null; if (proposition.GetType() == typeof(Negation)) { Negation negation = (Negation)proposition; Proposition negatedProposition = negation.LeftSuccessor; if (negatedProposition.GetType() == typeof(Negation)) { Negation negatedNegation = (Negation)negatedProposition; doubleNegationRemoved = negatedNegation.LeftSuccessor; propositions.Add(doubleNegationRemoved); } } LeftChild = new SemanticTableauxElement(propositions, new HashSet <char>(ReplacementVariables)); }
private static void NumberOperands(Proposition expressionRoot) { List <Proposition> queue = new List <Proposition>(); Proposition currentSymbol = expressionRoot; queue.Add(currentSymbol); int nodeCounter = 1; while (currentSymbol != null) { currentSymbol.NodeNumber = nodeCounter; if (currentSymbol is BinaryConnective) { queue.Add(((BinaryConnective)currentSymbol).LeftSuccessor); queue.Add(((BinaryConnective)currentSymbol).RightSuccessor); } else if (currentSymbol is UnaryConnective) { queue.Add(((UnaryConnective)currentSymbol).LeftSuccessor); } queue.RemoveAt(0); if (queue.Count > 0) { currentSymbol = queue[0]; } else { currentSymbol = null; } nodeCounter++; } }
private Proposition GenerateExpressionRecursively(Proposition result, int level) { if (!(result is UnaryConnective)) { return(result); } int newLevel = level + 1; if (level >= 5) { newLevel = level + 4; } if (result is UnaryConnective) { // Generate a random left UnaryConnective connective = (UnaryConnective)result; connective.LeftSuccessor = GenerateProposition(level); GenerateExpressionRecursively(connective.LeftSuccessor, newLevel); } if (result is BinaryConnective) { // Generate a random right BinaryConnective connective = (BinaryConnective)result; connective.RightSuccessor = GenerateProposition(level); GenerateExpressionRecursively(connective.RightSuccessor, newLevel); } return(result); }
public TruthTableRow(Proposition propositionRoot, List <Proposition> uniqueVariables, int numberOfVariables) { this.propositionRoot = propositionRoot; this.uniqueVariables = uniqueVariables; Cells = new char[numberOfVariables]; IsSimplified = false; }
public SemanticTableaux(Proposition proposition) { Proposition = proposition; if (proposition == null) { throw new NullReferenceException("A proposition is required to make use of the semantic tableaux"); } Negation negation = new Negation(); negation.LeftSuccessor = proposition; HashSet <Proposition> propositions = new HashSet <Proposition>() { negation }; // Then the type of semantic tableaux element could be // set by the semantic tableaux by perhaps setting // an enum on the semantic tableaux element // which calls a create method SemanticTableauxElement.ResetReplacementVariables(); Head = new SemanticTableauxElement(propositions); }
private void CreateConnective(char connective) { Proposition result = null; // 'GetCorrespondingConnective' switch (connective) { case Negation.SYMBOL: result = new Negation(); break; case Implication.SYMBOL: result = new Implication(); break; case BiImplication.SYMBOL: result = new BiImplication(); break; case Conjunction.SYMBOL: result = new Conjunction(); break; case Disjunction.SYMBOL: result = new Disjunction(); break; case Nand.SYMBOL: result = new Nand(); break; case UniversalQuantifier.SYMBOL: result = new UniversalQuantifier(PopBoundVariable()); break; case ExistentialQuantifier.SYMBOL: result = new ExistentialQuantifier(PopBoundVariable()); break; } // 'CreateExpression' // The symbols[symbols.Count - 1] can always be done. Placement is dependent on Unary or Binary connective. if (result is BinaryConnective) { ((BinaryConnective)result).LeftSuccessor = symbols[symbols.Count - 2]; ((BinaryConnective)result).RightSuccessor = symbols[symbols.Count - 1]; symbols.RemoveAt(symbols.Count - 1); symbols.RemoveAt(symbols.Count - 1); } else { ((UnaryConnective)result).LeftSuccessor = symbols[symbols.Count - 1]; symbols.RemoveAt(symbols.Count - 1); } // Now the expression is a symbol in case a nested connective needs to use it // as right or left successor. symbols.Add(result); }
private void ApplyAlphaRule(Proposition proposition) { HashSet <Proposition> childPropositions = new HashSet <Proposition>(); foreach (Proposition p in Propositions) { if (!p.Equals(proposition)) { childPropositions.Add(p); } } if (proposition.GetType() == typeof(Conjunction)) { BinaryConnective connective = (BinaryConnective)proposition; childPropositions.Add(connective.LeftSuccessor); childPropositions.Add(connective.RightSuccessor); } if (proposition.GetType() == typeof(Negation)) { Negation negation = (Negation)proposition; BinaryConnective nestedConnective = (BinaryConnective)negation.LeftSuccessor; if (nestedConnective.GetType() != typeof(Nand)) { // Both cases have a negation of the right successor. Negation negatedRight = new Negation(); negatedRight.LeftSuccessor = nestedConnective.RightSuccessor; // Only disjunction results in a left side negated as well. if (nestedConnective.GetType() == typeof(Disjunction)) { Negation negatedLeft = new Negation(); negatedLeft.LeftSuccessor = nestedConnective.LeftSuccessor; childPropositions.Add(negatedLeft); } // Should not forget to add the implication's left successor if (nestedConnective.GetType() == typeof(Implication)) { childPropositions.Add(nestedConnective.LeftSuccessor); } childPropositions.Add(negatedRight); } else { // It's a negated Nand and we can add left and right to the set childPropositions.Add(nestedConnective.LeftSuccessor); childPropositions.Add(nestedConnective.RightSuccessor); } } LeftChild = new SemanticTableauxElement(childPropositions, new HashSet <char>(ReplacementVariables)); }
private void randomPropositionBtn_Click(object sender, EventArgs e) { ResetAllControls(); propositionTbx.Text = ""; generatedProposition = propositionGenerator.GenerateExpression(); infixTbx.Text = generatedProposition.ToString(); }
public static void CreateGraphOfProposition(Proposition propositionRoot, string fileName) { if (propositionRoot == null) { throw new ArgumentNullException("Proposition root cannot be null!"); } NumberOperands(propositionRoot); CreateGraph(fileName, propositionRoot.NodeLabel()); }
protected override void ExecuteParsingActivities() { if (Root.IsAbstractProposition()) { hashCodes = new List <string>(); // 1 TruthTable = new TruthTable(Root); hashCodeCalculator.GenerateHashCode(TruthTable.GetConvertedResultColumn()); hashCodes.Add(hashCodeCalculator.HashCode); // 2 SimplifiedTruthTable = TruthTable.Simplify(); if (NonConstantExpressionWasParsed()) { // Convert the table to DNF such that we have a proposition to work with. Proposition simplified = SimplifiedTruthTable.CreateDisjunctiveNormalForm(); TruthTable simplifiedTt = new TruthTable(simplified); // Check the hash code for the proposition. hashCodeCalculator.GenerateHashCode(simplifiedTt.GetConvertedResultColumn()); hashCodes.Add(hashCodeCalculator.HashCode); // 3 Nandified = Root.Nandify(); TruthTable nandifiedTruthTable = new TruthTable(Nandified); TruthTable nandifiedSimplified = nandifiedTruthTable.Simplify(); // Same as for simplified truth table. Proposition nandSimpleDnf = nandifiedSimplified.CreateDisjunctiveNormalForm(); TruthTable nandSimpleDnfTt = new TruthTable(nandSimpleDnf); hashCodeCalculator.GenerateHashCode(nandSimpleDnfTt.GetConvertedResultColumn()); hashCodes.Add(hashCodeCalculator.HashCode); // 4 DisjunctiveNormalForm = TruthTable.CreateDisjunctiveNormalForm(); TruthTable disjunctiveTruthTable = new TruthTable(DisjunctiveNormalForm); hashCodeCalculator.GenerateHashCode(disjunctiveTruthTable.GetConvertedResultColumn()); hashCodes.Add(hashCodeCalculator.HashCode); // 5 Proposition simplifiedDisjunctiveNormal = SimplifiedTruthTable.CreateDisjunctiveNormalForm(); TruthTable simplifiedDisjunctiveNormalTruthTable = new TruthTable(simplifiedDisjunctiveNormal); hashCodeCalculator.GenerateHashCode(simplifiedDisjunctiveNormalTruthTable.GetConvertedResultColumn()); hashCodes.Add(hashCodeCalculator.HashCode); // 6 Proposition nandifiedSimplifiedDisjunctiveNormal = simplifiedDisjunctiveNormal.Nandify(); TruthTable nandifiedSimplifiedDisjunctiveNormalTruthTable = new TruthTable(nandifiedSimplifiedDisjunctiveNormal); hashCodeCalculator.GenerateHashCode(nandifiedSimplifiedDisjunctiveNormalTruthTable.GetConvertedResultColumn()); hashCodes.Add(hashCodeCalculator.HashCode); } } }
public void Parse(Proposition expression) { if (expression == null) { throw new ArgumentException("Proposition may not be null"); } Root = expression; ExecuteParsingActivities(); }
private bool TryToCreateDoubleNegation(Proposition proposition) { if (IsDoubleNegationRule(proposition)) { ApplyDoubleNegationRule(proposition); return(true); } return(false); }
private bool TryToCreateBetaRule(Proposition proposition) { if (IsBetaRule(proposition)) { ApplyBetaRule(proposition); return(true); } return(false); }
public Proposition CreateDisjunctiveNormalForm() { List <Proposition> propositionList = GenerateDisjunctiveNormalFormEquivalentPropositions(); // Check for missing variables. HashSet <Proposition> missingVariables = GetMissingVariables(propositionList); if (missingVariables.Count == propositionVariablesSet.Count) { if (propositionList.Count > 0) { Proposition p = propositionList[0]; propositionList.Remove(p); if (p.GetType() == typeof(True)) { // Create tautologies. foreach (Proposition variable in missingVariables) { propositionList.Add(PropositionGenerator.CreateTautologyFromProposition(variable)); } } } else { // Create contradictions. foreach (Proposition variable in missingVariables) { propositionList.Add(PropositionGenerator.CreateContradictionFromProposition(variable)); } } } // If we miss one or more variables but not all, this indicates that those variables // had no meaning in the original expression. Thus by logical equivalence we can say that // the expression would be equivalent to for ex: A & (B | ~(B)), the truth value of B // does not matter thus we can restate this as A | 0 which means we are totally reliant // on the truth value of A which can be obtained by creating a contradiction of // the variable that does not matter (B) in this case to keep the result column of equal // length, this would result in A | (B & ~(B)) which IS in DNF if (missingVariables.Count > 0 && missingVariables.Count < propositionVariablesSet.Count) { foreach (Proposition missingVariable in missingVariables) { propositionList.Add(PropositionGenerator.CreateContradictionFromProposition(missingVariable)); } } propositionList = CreateCorrespondingDisjuncts(propositionList); return(propositionList[0]); }
private void ApplyDeltaRule(Proposition proposition) { // COULD BE: GetAllDifferingChildPropositions(proposition) // REFACTOR WORTHY: otherwise needs to be tested for every rule which is all the same HashSet <Proposition> childPropositions = new HashSet <Proposition>(); foreach (Proposition p in Propositions) { if (!p.Equals(proposition)) { childPropositions.Add(p); } } // REFACTOR WORTHY // Current proposition we want to break up again into new pieces. Quantifier quantifier = null; Proposition predicate = null; if (proposition.GetType() == typeof(Negation)) { Negation negatedUniversalQuantifier = (Negation)proposition; quantifier = (Quantifier)negatedUniversalQuantifier.LeftSuccessor; predicate = quantifier.LeftSuccessor; Negation negatedPredicate = new Negation(); negatedPredicate.LeftSuccessor = predicate; predicate = negatedPredicate; } else { quantifier = (Quantifier)proposition; predicate = quantifier.LeftSuccessor; } char boundVariable = quantifier.GetBoundVariable(); char replacementCharacter = GenerateReplacementVariable(); Proposition predicateCopy = predicate.Copy(); predicateCopy.Replace(boundVariable, replacementCharacter); // Get current set locally, add new variable and pass them down. HashSet <char> childReplacementVariables = new HashSet <char>(ReplacementVariables); childReplacementVariables.Add(replacementCharacter); childPropositions.Add(predicateCopy); LeftChild = new SemanticTableauxElement(childPropositions, childReplacementVariables); }
public void Parse(string propositionExpression) { if (propositionExpression == null || propositionExpression == string.Empty) { throw new ArgumentException("Proposition expression may not be null or empty string"); } Root = parser.Parse(propositionExpression); ExecuteParsingActivities(); parsedExpression = propositionExpression; }
public static Proposition CreateContradictionFromProposition(Proposition variable) { if (variable == null) { throw new NullReferenceException("A proposition is required to create a contradiction from it!"); } Negation negation = new Negation(); negation.LeftSuccessor = CreateTautologyFromProposition(variable); return(negation); }
private bool IsDoubleNegationRule(Proposition proposition) { if (proposition.GetType() == typeof(Negation)) { Negation negation = (Negation)proposition; Proposition negatedProposition = negation.LeftSuccessor; if (negatedProposition.GetType() == typeof(Negation)) { return(true); } } return(false); }
// Specific to abstract propositions private bool ConstantContradiction(Proposition proposition) { if (proposition.GetType() == typeof(False)) { return(true); } if (proposition.GetType() == typeof(Negation)) { Negation negation = (Negation)proposition; return(negation.LeftSuccessor.GetType() == typeof(True)); } return(false); }
public override Proposition Nandify() { // ~(A) == ~(A & A) == A % A Nand nand = new Nand(); Proposition nandifiedLeft = LeftSuccessor; if (LeftSuccessor.GetType() != typeof(Proposition)) { nandifiedLeft = LeftSuccessor.Nandify(); } nand.LeftSuccessor = nandifiedLeft; nand.RightSuccessor = nandifiedLeft; return(nand); }
private void Parse() { string proposition = propositionTbx.Text; if (proposition != string.Empty) { generatedProposition = null; selectedApp.Parse(proposition); } if (generatedProposition != null) { propositionTbx.Text = ""; selectedApp.Parse(generatedProposition); } }
private bool IsGammaRule(Proposition proposition) { if (proposition.GetType() == typeof(UniversalQuantifier)) { return(true); } if (proposition.GetType() == typeof(Negation)) { Proposition quantifier = ((Negation)proposition).LeftSuccessor; return(quantifier.GetType() == typeof(ExistentialQuantifier)); } return(false); }
public static Proposition CreateTautologyFromProposition(Proposition variable) { if (variable == null) { throw new NullReferenceException("A proposition is required to create a tautology from it!"); } Disjunction tautology = new Disjunction(); tautology.LeftSuccessor = variable; // A Negation negatedVariable = new Negation(); negatedVariable.LeftSuccessor = variable; tautology.RightSuccessor = negatedVariable; // A | ~(A) == 1 return(tautology); }
public TruthTable(Proposition propositionRoot) { this.propositionRoot = propositionRoot; // Transparent caching if (propositionRoot.UniqueVariableSet == null) { propositionVariablesSet = propositionRoot.GetVariables(); } else { propositionVariablesSet = propositionRoot.UniqueVariableSet; } // Place them in alphabetic order propositionVariablesSet.Sort(); Rows = new List <ITruthTableRow>(); CreateTruthTableRows(); }
private bool IsDeltaRule(Proposition proposition) { if (proposition.GetType() == typeof(ExistentialQuantifier)) { return(true); } // Negated Universal Quantifier if (proposition.GetType() == typeof(Negation)) { Proposition left = ((Negation)proposition).LeftSuccessor; return(left.GetType() == typeof(UniversalQuantifier)); } return(false); }
public Proposition GetDisjunctiveNormalFormEquivalent() { List <Proposition> propositionList = new List <Proposition>(); for (int i = 0; i < Cells.Length; i++) { // return value is null if cell held * // Add the obtained variable to the list such that we can process it. Proposition resultVariable = GetDisjunctiveNormalFormVariable(Cells[i], uniqueVariables[i]); if (resultVariable != null) { propositionList.Add(resultVariable); } } // Create conjuncts and insert them at the first position // until there is 1 proposition object left. (the root) while (propositionList.Count > 1) { // take vriable at pos 0 and 1 and create a conjunct between them. // Insert them back in the first position of the list. Conjunction conjunct = new Conjunction(); // We do not need to create copies of variables since we did that beforehand. conjunct.LeftSuccessor = propositionList[0]; conjunct.RightSuccessor = propositionList[1]; // Remove the individual variables from the list. propositionList.RemoveAt(1); propositionList.RemoveAt(0); // Insert the conjunct into the list. propositionList.Add(conjunct); } if (propositionList.Count > 0) { return(propositionList[0]); } if (Result == true) { return(new True()); } return(new False()); }
public Proposition GenerateExpression() { if (rng == null) { rng = new Random(); } generatedPropositionVariables = new HashSet <Proposition>(); int numberOfVariables = rng.Next(1, MAX_UNIQUE_VARIABLES + 1); while (generatedPropositionVariables.Count < numberOfVariables) { generatedPropositionVariables.Add(GetRandomProposition()); } int startLevel = 0; Proposition root = GenerateProposition(startLevel); return(GenerateExpressionRecursively(root, startLevel + 1)); }
private Proposition GetDisjunctiveNormalFormVariable(char truthValue, Proposition variable) { Proposition disjunctiveNormalFormVariable = null; // Can omit any actions if the cell holds a don't care variable // only the case for simplified truth tables. if (truthValue != '*') { if (truthValue == '0') { // Negate the original variable as this will result into true in the conjunction. Negation negation = new Negation(); negation.LeftSuccessor = variable; disjunctiveNormalFormVariable = negation; } else if (truthValue == '1') { // Return the original variable. disjunctiveNormalFormVariable = variable; } } return(disjunctiveNormalFormVariable); }