public static bool?Evaluate(ExpressionSyntacticElement exp, PredicateList state) { if (exp.GetType() == typeof(NotExpression)) { return(ExpressionExecutive.Evaluate((NotExpression)exp, state)); } if (exp.GetType() == typeof(AndExpression)) { return(ExpressionExecutive.Evaluate((AndExpression)exp, state)); } if (exp.GetType() == typeof(OrExpression)) { return(ExpressionExecutive.Evaluate((OrExpression)exp, state)); } if (exp.GetType() == typeof(XorExpression)) { return(ExpressionExecutive.Evaluate((XorExpression)exp, state)); } if (exp.GetType() == typeof(PredicateExpression)) { return(ExpressionExecutive.Evaluate((PredicateExpression)exp, state)); } if (exp.GetType() == typeof(ImplicationSyntacticExpression)) { return(ExpressionExecutive.Evaluate((ImplicationSyntacticExpression)exp, state)); } if (exp.GetType() == typeof(IfAndOnlyIfSyntacticExpression)) { return(ExpressionExecutive.Evaluate((IfAndOnlyIfSyntacticExpression)exp, state)); } throw new UnknownExpressionException(); }
/// <summary> /// Implies when run, evaluates left hand side and right hand side then sets itself /// this is the a result, True, the argument is valid and false it is not valid. /// Unknown will have to be taken as invalid. If all steps in the argument are valid /// then we should have a good argument /// implies testing /// p --> q /// 1 1 1 /// 1 0 0 /// 0 1 1 /// 0 1 0 /// X 1 1 /// X 0 X /// 1 X X /// 0 X 1 /// X X X /// </summary> /// <param name="element"></param> /// <param name="predicateState"></param> /// <returns></returns> public static PredicateList execute(ImplicationSyntacticExpression element, PredicateList predicateState) { bool?lhs = ExpressionExecutive.Evaluate(element.lhs, predicateState); bool?rhs = ExpressionExecutive.Evaluate(element.rhs, predicateState); element.Value = ImpliesTruthTable(lhs, rhs); return(predicateState); }
private static PropositionExpression RunProposition(PropositionExpression pse, LogicArgument program) { if (pse is ImplicationSyntacticExpression) { ExpressionExecutive.execute((ImplicationSyntacticExpression)pse, program.predicateList); } else if (pse is IfAndOnlyIfSyntacticExpression) { ExpressionExecutive.execute((IfAndOnlyIfSyntacticExpression)pse, program.predicateList); } else { throw new NotImplementedException("this bit cannot be reached and records a design error"); } return(pse); }
private static PredicateSetterSyntacticElement RunPredicateSetter(PredicateSetterSyntacticElement pse, LogicArgument program) { if (pse is PropositionSyntacticElement) { program.predicateList = ExpressionExecutive.execute((PropositionSyntacticElement)pse, program.predicateList); } else if (pse is PropositionNegationSyntacticElement) { program.predicateList = ExpressionExecutive.execute((PropositionNegationSyntacticElement)pse, program.predicateList); } else { // case cannot currently exist throw new NotImplementedException(); } return(pse); }
//what does this do? // if the conclusion is known, it works out what the conclusion should be and // returns the actual conclusion and the given one. // p->q conclusion is q predicate is p after execution p is known or not depending on value of p // if both are set then? is the truth table checked? do interested in state before and after // so how does an implies statement work? // p --> q ==== !p or q // 0 1 0 // 0 1 1 // 1 0 0 // 1 1 1 /// <summary> /// Execute with a full trace of what happened /// </summary> /// <param name="program"></param> public static List <string> Execute(LogicArgument program, out ProgramReturnCode errorCode) { // we want a value for the whole program and // we want a value for each line in the program // from the start to the end // executing must suggest a value for a predicate, // if this value cannot be set // 1 can be set to 1 // 0 can be set to 0 // ? can be set to anything 1, 0 or ? // The execution must be such that it runs through setting predicates // run predicates -- if fails produce result // run not expressions -- if fails produce result // run propositions in order // produce result List <string> programOutput = new List <string>(); // if no errors errorCode = Validate(program, ref programOutput); if (errorCode == ProgramReturnCode.No_errors) { errorCode = RunPredicateSetters(program, ref programOutput); if (errorCode == ProgramReturnCode.No_errors) { // run propositions errorCode = RunPropositions(program, ref programOutput); if (errorCode == ProgramReturnCode.No_errors) { // run therefore statement ExpressionExecutive.execute(program.thereforeSyntacticElement, program.predicateList); program.Conclusion = program.thereforeSyntacticElement.Value; if (program.Conclusion == true) { programOutput.Add("Your arguments conclusion was true."); } else { programOutput.Add("Your arguments conclusion was false."); } } } } return(programOutput); }
public static bool?Evaluate(NotExpression exp, PredicateList state) { bool?val = ExpressionExecutive.Evaluate(exp.expression, state); if (val == true) { return(false); } if (val == false) { return(true); } if (val == null) { return(null); } throw new NotImplementedException(); }
public static bool?Evaluate(IfAndOnlyIfSyntacticExpression exp, PredicateList state) { bool?lhs = ExpressionExecutive.Evaluate(exp.lhs, state); bool?rhs = ExpressionExecutive.Evaluate(exp.rhs, state); if (lhs == true && rhs == true) { return(true); } if (lhs == true && rhs == false) { return(false); } if (lhs == true && rhs == null) { return(null); } if (lhs == false && rhs == true) { return(false); } if (lhs == false && rhs == false) { return(true); } if (lhs == false && rhs == null) { return(null); } if (lhs == null && rhs == true) { return(null); } if (lhs == null && rhs == false) { return(null); } if (lhs == null && rhs == null) { return(null); } throw new NotImplementedException(); }
/// <summary> /// each of the following expressions all rely on expressions either unary or binary /// these are defined in the evaluate function, these can only really be worked out when all predicate suppositions /// are made. For propositions like p and not p must be run /// </summary> /// <param name="element"></param> /// <param name="predicateState"></param> /// <returns></returns> public static PredicateList execute(ThereforeSyntacticElement element, PredicateList predicateState) { // for of a therefore are element.Value = ExpressionExecutive.Evaluate(element.expression, predicateState); return(predicateState); }