public PassificationLemmaManager(
CFGRepr cfg,
IDictionary <Block, Block> origToPassiveBlock,
IProgramAccessor programAccessor,
IProgramAccessor passiveProgramAccessor,
Tuple <string, string> varContextNonPassivePassive,
StateRelationData oldStateRelationData,
PassiveRelationGen relationGen,
IVariableTranslationFactory varTranslationFactory,
IVariableTranslationFactory passiveTranslationFactory)
{
this.cfg = cfg;
this.origToPassiveBlock = origToPassiveBlock;
this.programAccessor = programAccessor;
this.passiveProgramAccessor = passiveProgramAccessor;
_oldStateRelationData = oldStateRelationData;
_relationGen = relationGen;
initState = IsaBoogieTerm.Normal(normalInitState);
varTranslation = varTranslationFactory.CreateTranslation().VarTranslation;
passiveVarTranslation = passiveTranslationFactory.CreateTranslation().VarTranslation;
//separate unique namer for function interpretations (since they already have a name in uniqueNamer): possible clashes
boogieContext = new BoogieContextIsa(
IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"),
IsaCommonTerms.TermIdentFromName(varContextNonPassivePassive.Item1),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"),
IsaCommonTerms.TermIdentFromName("\\<Omega>")
);
passiveVarContext = IsaCommonTerms.TermIdentFromName(varContextNonPassivePassive.Item2);
}
public IEnumerable <LemmaDecl> GetHints(Expr e)
{
_hintLemmas = new List <LemmaDecl>();
tyVarTranslation = variableFactory.CreateTranslation().TypeVarTranslation;
Visit(e);
return(_hintLemmas);
}
/// <summary>
/// Return lookup lemmas for each element in the old relation as well as the definition of the old relation, which
/// is defined via an association list
/// </summary>
private static StateRelationData OldRelation(
ISet <Variable> oldGlobalVars,
IVariableTranslation <Variable> variableTranslation,
out IList <OuterDecl> oldRelDecls)
{
//assume that passive version representing old variable of "g" is "g" itself
var oldRelTuples = new List <Term>();
var varList = new List <Variable>();
var varToLookupLemma = new Dictionary <Variable, LemmaDecl>();
var uniqueNamer = new IsaUniqueNamer();
foreach (var v in oldGlobalVars)
{
if (variableTranslation.TryTranslateVariableId(v, out var varTermId, out _))
{
oldRelTuples.Add(new TermTuple(varTermId, IsaCommonTerms.Inl(varTermId)));
var lemma = new LemmaDecl(
"lookup_old_rel" + uniqueNamer.GetName(v, v.Name),
TermBinary.Eq(new TermApp(oldRel, varTermId),
IsaCommonTerms.SomeOption(IsaCommonTerms.Inl(varTermId))),
new Proof(new List <string>
{
"unfolding " + oldRelListName + "_def " + oldRelName + "_def",
"by simp"
})
);
varToLookupLemma.Add(v, lemma);
varList.Add(v);
}
public BoogieVariableTranslation(
IVariableTranslation <Variable> variableTranslation,
IVariableTranslation <TypeVariable> typeVarTranslation)
{
VarTranslation = variableTranslation;
TypeVarTranslation = typeVarTranslation;
}
public static Term LocalStateVariableAssumption(Variable v,
Term varContext,
Term state,
IDictionary <NamedDeclaration, Term> declToVCMapping,
IVariableTranslation <Variable> varTranslation)
{
return(LocalStateVariableAssumption(v, varContext, state, declToVCMapping[v], varTranslation));
}
public ApplicableIsaVisitor(TypeParamInstantiation typeInst,
IList <Term> args,
IVariableTranslation <TypeVariable> typeVarTranslation)
{
_typeInst = typeInst;
_args = args;
typeIsaVisitor = new TypeIsaVisitor(typeVarTranslation);
}
public static Term LocalStateVariableAssumption(Variable v, Term varContext, Term normalState, Term vcVar,
IVariableTranslation <Variable> varTranslation)
{
if (varTranslation.TryTranslateVariableId(v, out var varId, out var isBoundVar) && !isBoundVar)
{
var left = IsaBoogieTerm.LookupVar(varContext, normalState, varId);
var right =
IsaCommonTerms.SomeOption(pureToBoogieValConverter.ConvertToBoogieVal(v.TypedIdent.Type, vcVar));
return(new TermBinary(left, right, TermBinary.BinaryOpCode.Eq));
}
throw new ProofGenUnexpectedStateException(typeof(LemmaHelper), "Can't retrieve variable id");
}
/// <summary>The returned list in-sync with <see cref="AllAssumptionLabels" />.</summary>
public IList <Term> AllAssumptions(
IDictionary <Function, TermIdent> funInterpMapping,
IDictionary <NamedDeclaration, Term> declToVCMapping,
Term state,
BoogieContextIsa boogieContext,
IVariableTranslation <Variable> varTranslation
)
{
var assumptions = new List <Term>();
foreach (var obj in _assumptionLabelMap.Keys)
{
if (obj is Function f)
{
assumptions.Add(LemmaHelper.FunctionCtxtWfAssm(f, funInterpMapping, boogieContext));
assumptions.Add(LemmaHelper.FunctionVcCorresAssm(f, funInterpMapping, declToVCMapping,
boogieContext));
}
else if (obj is Variable v)
{
assumptions.Add(LemmaHelper.LocalStateVariableAssumption(v, boogieContext.varContext, state,
declToVCMapping, varTranslation));
if (!TypeUtil.IsPrimitive(v.TypedIdent.Type))
{
assumptions.Add(LemmaHelper.VariableTypeAssumption(
v,
declToVCMapping[v],
new TypeIsaVisitor(_factory.CreateEmptyTranslation().TypeVarTranslation),
boogieContext.absValTyMap));
}
}
else if (obj is SpecialAssumptionsKind kind)
{
switch (kind)
{
case SpecialAssumptionsKind.TypeValClosed:
assumptions.Add(EndToEndAssumptions.ClosednessAssumption(boogieContext.absValTyMap));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
return(assumptions);
}
public IEnumerable <OuterDecl> EndToEndProof(
string entryCfgLemma,
string boogieToVcLemma,
Term vcAssm,
IProgramAccessor programAccessor,
IProgramAccessor passiveProgramAccessor,
Tuple <string, string> varContextNonPassivePassive,
StateRelationData oldRelationData,
CFGRepr cfg,
IEnumerable <Variable> liveEntryVars,
IVariableTranslation <Variable> varTranslation)
{
this.entryCfgLemma = entryCfgLemma;
this.boogieToVcLemma = boogieToVcLemma;
this.vcAssm = vcAssm;
this.programAccessor = programAccessor;
this.passiveProgramAccessor = passiveProgramAccessor;
boogieContext = new BoogieContextIsa(
IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"),
IsaCommonTerms.TermIdentFromName(varContextNonPassivePassive.Item1),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"),
IsaCommonTerms.EmptyList
);
passiveVarContext = IsaCommonTerms.TermIdentFromName(varContextNonPassivePassive.Item2);
this.oldRelationData = oldRelationData;
this.cfg = cfg;
this.liveEntryVars = liveEntryVars;
this.varTranslation = varTranslation;
var locale = new LocaleDecl("glue_proof",
Context(),
GenerateLemma()
);
return(new List <OuterDecl>
{
locale
});
}
public TypeIsaVisitor(IVariableTranslation <TypeVariable> typeVarTranslation,
bool usedClosedConstructors = false)
{
this.typeVarTranslation = typeVarTranslation;
this.usedClosedConstructors = usedClosedConstructors;
}
