private List <Expression> Merge(Expression expr, List <Expression> first, List <Expression> second, Dictionary <Constant, bool> valuesFirst, Dictionary <Constant, bool> valuesSecond, int level) { var keys = valuesFirst.Keys.ToList(); keys.Sort((x, y) => - 1 * x.Value.CompareTo(y.Value)); List <Expression> assumptionA = new List <Expression>(); List <Expression> assumptionB = new List <Expression>(); for (int i = 0; i < keys.Count - level; i++) { if (valuesFirst[keys[i]]) { assumptionA.Add(keys[i]); } else { assumptionA.Add(new Negation(keys[i])); } if (valuesSecond[keys[i]]) { assumptionB.Add(keys[i]); } else { assumptionB.Add(new Negation(keys[i])); } } first = Deduction(first, assumptionA); second = Deduction(second, assumptionB); var aOrNotA = ProofCollection.GetAOrNotA(); for (int i = 0; i < aOrNotA.Count; i++) { aOrNotA[i] = SubstituteExprsToExpr(aOrNotA[i], assumptionB.Last(), null); } var parser = new Parser(); var axiom8 = SubstituteExprsToExpr(parser.Parse("((A->B)->(!A->B)->(A|!A)->B)"), assumptionB.Last(), expr); var mp1 = SubstituteExprsToExpr(parser.Parse("((!A->B)->(A|!A)->B)"), assumptionB.Last(), expr); var mp2 = SubstituteExprsToExpr(parser.Parse("((A|!A)->B)"), assumptionB.Last(), expr); var rv = new List <Expression>(); rv.AddRange(first); rv.AddRange(second); rv.AddRange(aOrNotA); rv.Add(axiom8); rv.Add(mp1); rv.Add(mp2); rv.Add(expr.Clone()); return(rv); }
private List <Expression> DeepProof(Expression expression, Dictionary <Constant, bool> values) { switch (expression) { case Constant c: var value = Evaluator.Evaluate(c, values); var proof = ProofCollection.GetProof(typeof(Negation), value); for (int i = 0; i < proof.Count; i++) { proof[i] = SubstituteExprsToExpr(proof[i], c, null); } return(proof); case UnaryOperation uo: proof = new List <Expression>(); value = Evaluator.Evaluate(uo.Expression, values); if (!(uo.Expression is Constant)) { proof.AddRange(DeepProof(uo.Expression, values)); } var tempProof = ProofCollection.GetProof(uo.GetType(), value); for (int i = 0; i < tempProof.Count; i++) { tempProof[i] = SubstituteExprsToExpr(tempProof[i], uo.Expression, null); } proof.AddRange(tempProof); return(proof); case BinaryOperation bo: proof = new List <Expression>(); var leftValue = Evaluator.Evaluate(bo.Left, values); var rightValue = Evaluator.Evaluate(bo.Right, values); proof.AddRange(DeepProof(bo.Left, values)); proof.AddRange(DeepProof(bo.Right, values)); tempProof = ProofCollection.GetProof(bo.GetType(), leftValue, rightValue); for (int i = 0; i < tempProof.Count; i++) { tempProof[i] = SubstituteExprsToExpr(tempProof[i], bo.Left, bo.Right); } proof.AddRange(tempProof); return(proof); } throw new Exception(); }