public static Inference FindInference(Hypotheses hypotheses, Formula target)
{
var inference = new Inference(hypotheses);
if (inference.Push(target))
{
inference.Minimize();
return(inference);
}
var formulas = new HashSet <Formula>();
if (hypotheses is null == false)
{
foreach (var h in hypotheses)
{
inference.Push(h);
formulas.Add(h);
}
}
ParseFormula(target, formulas);
var addingFormulas = new Thread(() => AddingFormulas(inference, formulas, target));
var genFormulas = new Thread(() => GenFormulas(inference, formulas, target));
addingFormulas.Start();
genFormulas.Start();
while (true)
{
lock (inference)
{
if (inference.Push(target) || inference.Contains(target))
{
break;
}
}
Thread.Sleep(1000);
}
addingFormulas.Abort();
genFormulas.Abort();
inference.Minimize();
return(inference);
}
private static void AddingFormulas(Inference inference, HashSet <Formula> formulas, Formula target)
{
var form = new HashSet <Formula>();
while (true)
{
foreach (var f in form)
{
if (f.Equals(target) == false)
{
lock (inference)
{
if (inference.Contains(target))
{
return;
}
inference.Push(f);
}
}
}
lock (formulas)
{
form.UnionWith(formulas);
}
}
}
private static void GenAxiom(Inference inference, List <Formula> formulas, HashSet <Formula> allFormulas,
Formula target, Axiom a)
{
foreach (var f1 in formulas)
{
foreach (var f2 in formulas)
{
foreach (var f3 in formulas)
{
var f = SubstituteInFormula(a, f1, f2, f3);
if (f.Equals(target))
{
continue;
}
bool ok;
lock (inference)
{
if (inference.Contains(target))
{
return;
}
ok = inference.Push(f);
}
lock (allFormulas)
{
if (ok)
{
ParseFormula(f, allFormulas);
}
}
}
}
}
}
private static void GenAxioms(Formula target, HashSet <Formula> formulas, Axiom a, Inference inference, HashSet <Formula> newF)
{
foreach (var f1 in formulas)
{
foreach (var f2 in formulas)
{
foreach (var f3 in formulas)
{
var f = SubstituteInFormula(a, f1, f2, f3);
if (f.Equals(target) == false)
{
var ok = true;
lock (inference)
{
ok = inference.Push(f);
}
if (ok)
{
ParseFormula(f, newF);
}
}
}
}
}
}
public Inference BuildInference()
{
if (_inference != null)
{
return(_inference);
}
var inference = new Inference(Hypotheses);
if (inference.Push(Target))
{
return(_inference = inference);
}
var addedFormulas = new HashSet <Formula>();
var newAddedFormulas = new HashSet <Formula>();
var queue = new HashSet <Formula>();
var newQueue = new HashSet <Formula>();
ParseFormula(Target, queue);
if (Hypotheses != null)
{
foreach (var h in Hypotheses)
{
if (inference.Push(h))
{
addedFormulas.Add(h);
}
}
}
foreach (var q in queue)
{
addedFormulas.Add(q);
}
while (true)
{
foreach (var aF in addedFormulas)
{
foreach (var q in queue)
{
var f = SubstituteInFormula(new Formula(Impl), aF, q, null);
if (inference.Push(f))
{
newAddedFormulas.Add(f);
}
else
{
newQueue.Add(f);
}
}
}
foreach (var q in newQueue)
{
queue.Add(q);
}
newQueue.Clear();
foreach (var naF in newAddedFormulas)
{
addedFormulas.Add(naF);
}
newAddedFormulas.Clear();
var ok = true;
while (ok)
{
ok = false;
foreach (var f in queue)
{
if (inference.Push(f))
{
if (f.Equals(Target))
{
ok = false;
break;
}
ok = true;
newAddedFormulas.Add(f);
}
}
}
foreach (var naF in newAddedFormulas)
{
addedFormulas.Add(naF);
queue.Remove(naF);
}
newAddedFormulas.Clear();
if (inference.Length != 0 && inference.LastFormula.Equals(Target))
{
break;
}
if (inference.Push(Target))
{
break;
}
}
inference.Minimize();
return(_inference = inference);
}
public static Inference FindInference(Formula target, Hypotheses hypotheses)
{
var inference = new Inference(hypotheses);
if (inference.Push(target))
{
inference.Minimize();
return(inference);
}
var formulas = new HashSet <Formula>();
if (hypotheses is null == false)
{
foreach (var h in hypotheses)
{
inference.Push(h);
formulas.Add(h);
}
}
ParseFormula(target, formulas);
while (true)
{
var newF = new HashSet <Formula>();
//foreach (var a in Axioms.GetAxioms())
//{
// GenAxioms(target, formulas, a, inference, newF);
//}
Parallel.ForEach(Axioms.GetAxioms(), a => GenAxioms(target, formulas, a, inference, newF));
foreach (var f in newF)
{
formulas.Add(f);
}
newF.Clear();
var ok = true;
while (ok)
{
ok = false;
foreach (var f in formulas)
{
if (inference.Push(f))
{
ok = true;
if (target.Equals(f))
{
ok = false;
break;
}
}
}
}
if (inference.Contains(target))
{
break;
}
}
inference.Minimize();
return(inference);
}
