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);
}