public VcAxiomLemmaManager(
VCInstantiation <VCExpr> vcAxiomInst,
BoogieMethodData methodData,
IEnumerable <Function> vcFunctions,
VcRewriteLemmaGen vcRewriteLemmaGen,
IVariableTranslationFactory variableFactory)
{
this.vcAxiomInst = vcAxiomInst;
this.methodData = methodData;
this.vcRewriteLemmaGen = vcRewriteLemmaGen;
this.variableFactory = variableFactory;
basicCmdIsaVisitor = new BasicCmdIsaVisitor(variableFactory);
boogieContext = new BoogieContextIsa(IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"), IsaCommonTerms.TermIdentFromName("\\<Lambda>"),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"), IsaCommonTerms.TermIdentFromName("\\<Omega>"));
var typeDeclTranslation = new ConcreteTypeDeclTranslation(boogieContext);
declToVCMapping =
LemmaHelper.DeclToTerm(
((IEnumerable <NamedDeclaration>)methodData.Functions).Union(methodData.Constants), vcFunctions,
typeDeclTranslation, uniqueNamer);
//separate unique namer for function interpretations (since they already have a name in uniqueNamer): possible clashes
funToInterpMapping = LemmaHelper.FunToTerm(methodData.Functions, new IsaUniqueNamer());
assmManager = new AssumptionManager(methodData.Functions, methodData.Constants, variableFactory);
}
public VcPhaseLemmaManager(VCInstantiation <Block> vcinst,
BoogieMethodData methodData,
IEnumerable <Function> vcFunctions,
IsaBlockInfo isaBlockInfo,
IVariableTranslationFactory variableFactory)
{
this.vcinst = vcinst;
this.methodData = methodData;
programVariables = methodData.AllVariables();
initState = IsaBoogieTerm.Normal(normalInitState);
this.isaBlockInfo = isaBlockInfo;
this.variableFactory = variableFactory;
boogieContext = new BoogieContextIsa(
IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"),
IsaCommonTerms.TermIdentFromName("\\<Lambda>"),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"),
IsaCommonTerms.TermIdentFromName("\\<Omega>")
);
var typeDeclTranslation = new ConcreteTypeDeclTranslation(boogieContext);
declToVCMapping = LemmaHelper.DeclToTerm(
((IEnumerable <NamedDeclaration>)methodData.Functions).Union(programVariables),
vcFunctions,
typeDeclTranslation,
uniqueNamer);
//separate unique namer for function interpretations (since they already have a name in uniqueNamer): possible clashes
funToInterpMapping = LemmaHelper.FunToTerm(methodData.Functions, new IsaUniqueNamer());
assmManager = new AssumptionManager(methodData.Functions, programVariables, variableFactory);
}
public VcBoogieInfo(
VCInstantiation <Block> vcinst,
VCInstantiation <VCExpr> vcInstAxiom,
IEnumerable <VCExpr> vcAxioms,
IEnumerable <VCAxiomInfo> vcAxiomsInfo)
{
VcInst = vcinst;
VcInstAxiom = vcInstAxiom;
VcAxioms = vcAxioms;
VcAxiomsInfo = vcAxiomsInfo;
}
private static Term ConclusionBlock(
IEnumerable <Block> b_successors,
Term normalInitState,
Term finalState,
IDictionary <NamedDeclaration, Term> declToVCMapping,
VCInstantiation <Block> vcinst,
bool useMagicFinalState = false)
{
if (useMagicFinalState)
{
return(new TermBinary(finalState, IsaBoogieTerm.Magic(), TermBinary.BinaryOpCode.Eq));
}
Term nonFailureConclusion =
new TermBinary(finalState, IsaBoogieTerm.Failure(), TermBinary.BinaryOpCode.Neq);
var normalFinalState = IsaCommonTerms.TermIdentFromName("n_s'");
Term ifNormalConclusionLhs = new TermBinary(finalState, IsaBoogieTerm.Normal(normalFinalState),
TermBinary.BinaryOpCode.Eq);
Term ifNormalConclusionRhs1 = new TermBinary(normalFinalState, normalInitState, TermBinary.BinaryOpCode.Eq);
var ifNormalConclusionRhs =
!b_successors.Any()
? ifNormalConclusionRhs1
: new TermBinary(
ifNormalConclusionRhs1,
LemmaHelper.ConjunctionOfSuccessorBlocks(b_successors, declToVCMapping, vcinst),
TermBinary.BinaryOpCode.And);
Term ifNormalConclusion =
new TermQuantifier(
TermQuantifier.QuantifierKind.ALL,
new List <Identifier> {
normalFinalState.Id
},
new TermBinary(
ifNormalConclusionLhs,
ifNormalConclusionRhs,
TermBinary.BinaryOpCode.Implies)
);
return(new TermBinary(nonFailureConclusion, ifNormalConclusion, TermBinary.BinaryOpCode.And));
}
public static Term ConjunctionOfSuccessorBlocks(IEnumerable <Block> successorBlocks,
IDictionary <NamedDeclaration, Term> declToVCMapping, VCInstantiation <Block> vcinst)
{
return
(successorBlocks.Select(b_suc => vcinst.GetVCObjInstantiation(b_suc, declToVCMapping))
.Aggregate((vc1, vc2) => new TermBinary(vc1, vc2, TermBinary.BinaryOpCode.And)));
}
