public IProofStep GetProofStep()
{
if (null == proofStep)
{
// Assume was a premise
proofStep = new ProofStepPremise(this);
}
return(proofStep);
}
public ProofStepFoChAssertFact(Clause implication, Literal fact,
IDictionary <Variable, ITerm> bindings, IProofStep predecessor)
{
this.implication = implication;
this.fact = fact;
this.bindings = bindings;
if (null != predecessor)
{
predecessors.Add(predecessor);
}
}
private void AddToProofSteps(IProofStep step)
{
if (!proofSteps.Contains(step))
{
proofSteps[0] = step;
}
else
{
proofSteps.Remove(step);
proofSteps[0] = step;
}
IList <IProofStep> predecessors = step.GetPredecessorSteps();
for (int i = predecessors.Count - 1; i >= 0; i--)
{
this.AddToProofSteps(predecessors[i]);
}
}
private void CalcualteProofSteps()
{
proofSteps = new List <IProofStep>();
this.AddToProofSteps(finalStep);
// Move all premises to the front of the
// list of steps
int to = 0;
for (int i = 0; i < proofSteps.Count; i++)
{
if (proofSteps[i] is ProofStepPremise)
{
IProofStep m = proofSteps[i];
proofSteps.RemoveAt(i);
proofSteps[to] = m;
to++;
}
}
// Move the Goals after the premises
for (int i = 0; i < proofSteps.Count; i++)
{
if (proofSteps[i] is ProofStepGoal)
{
IProofStep m = proofSteps[i];
proofSteps.RemoveAt(i);
proofSteps[to] = m;
to++;
}
}
// Assign the step #s now that all the proof
// steps have been unwound
for (int i = 0; i < proofSteps.Count; i++)
{
proofSteps[i].SetStepNumber(i + 1);
}
}
public ProofStepRenaming(object proof, IProofStep predecessor)
{
this.proof = proof;
this.predecessors.Add(predecessor);
}
private bool MatchPremises(InferenceRule rule, FormulaMapping mapping, ref Proof proof, ref RuleStep step, int premiseIndex = 0)
{
if (premiseIndex >= rule.premises.Count)
{
return(true);
}
ISymbol premise = rule.premises[premiseIndex];
List <MappingResult> nonRootMappings = new List <MappingResult>();
for (int i = 0; i < truths.Count; i++)
{
IProofStep truth = truths[i];
foreach (MappingResult mappingResult in FindFormulaMappings(premise, truth.Conclusion, mapping))
{
if (mappingResult.isRoot)
{
step.AddReferredStep(truth);
if (MatchPremises(rule, mappingResult.mapping, ref proof, ref step, premiseIndex + 1))
{
break;
}
step.PopReferredStep();
}
else
{
// Do non-root options later for efficiency
nonRootMappings.Add(mappingResult);
}
}
if (step.referredSteps.Count >= rule.premises.Count)
{
return(true);
}
}
foreach (MappingResult mappingResult in nonRootMappings)
{
Proof newProof = TryProve(mappingResult.formula, rule, mappingResult.mapping, premiseIndex, ref step);
if (newProof != null)
{
proof.AddStepsFromProof(newProof);
return(true);
}
if (step.referredSteps.Count >= rule.premises.Count)
{
return(true);
}
}
if (mapping.Count >= rule.maxFormulaIndex)
{
RuleType lastUnreferredRuleBefore = lastUnreferredRule;
if (rule.type == RuleType.Double_Negation_Elimination && lastUnreferredRule == RuleType.Double_Negation_Elimination)
{
return(false);
}
lastUnreferredRule = rule.type;
ISymbol mappedPremise = premise.ApplyMapping(mapping);
Proof newProof = TryProve(mappedPremise, rule, mapping, premiseIndex, ref step);
if (newProof != null)
{
proof.AddStepsFromProof(newProof);
return(true);
}
lastUnreferredRule = lastUnreferredRuleBefore;
}
// Proof is impossible (invalid)
return(false);
}
public ProofFinal(IProofStep finalStep, IDictionary <Variable, ITerm> answerBindings)
{
this.finalStep = finalStep;
this.answerBindings = answerBindings;
}
public void SetPredecessor(IProofStep predecessor)
{
predecessors.Clear();
predecessors.Add(predecessor);
}
public void SetProofStep(IProofStep pStep)
{
this.proofStep = pStep;
}
public void AddProofStep(IProofStep step)
{
stepFinal = step;
}
public void AddProofStep(Clause implication, Literal fact,
IDictionary <Variable, ITerm> bindings)
{
stepFinal = new ProofStepFoChAssertFact(implication, fact,
bindings, stepFinal);
}
