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