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 static bool findLargestVersion(
Block b,
PassiveRelationGen relationGen,
IDictionary <Variable, int> versionMap,
int maxVersionPred,
out int maxVersion)
{
maxVersion = maxVersionPred;
var updates = relationGen.GenerateVariableRelUpdatesFromPassive(b, out _);
foreach (var update in updates)
{
if (!update.Item3)
{
//not constant propagation
var constrainedVariable = (update.Item2 as IdentifierExpr).Decl;
if (versionMap[constrainedVariable] <= maxVersionPred)
{
return(false);
}
maxVersion = Math.Max(versionMap[constrainedVariable], maxVersion);
}
}
return(true);
}
public static bool CheckVersionMap(
IDictionary <Variable, int> versionMap,
PassiveRelationGen relationGen,
CFGRepr beforePassiveBlocks,
IDictionary <Block, Block> beforeToPassiveBlocks
)
{
return(GlobalVersion.CheckIsGlobal(beforeToPassiveBlocks.Values.ToList(), relationGen, versionMap,
relationGen.LiveVarsBeforeBlock(beforePassiveBlocks.entry)));
}
public static bool CheckIsGlobal(
IList <Block> blocks,
PassiveRelationGen relationGen,
IDictionary <Variable, int> versionMap,
IEnumerable <Variable> entryVars)
{
var largestVersion = new Dictionary <Block, int>();
var graph = GraphUtil.GraphFromBlocks(blocks);
var sortedNodes = graph.TopologicalSort();
var maxVersionInitVars = entryVars.Any() ? entryVars.Select(v => versionMap[v]).Max() : -1;
foreach (var b in sortedNodes)
{
var predecessors = graph.Predecessors(b).ToList();
int maxVersionPred;
if (predecessors.Any())
{
maxVersionPred = graph.Predecessors(b).Select(b => largestVersion[b]).Max();
}
else
{
maxVersionPred = maxVersionInitVars;
}
var correct = findLargestVersion(b, relationGen, versionMap, maxVersionPred, out var maxVersionBlock);
if (!correct)
{
return(false);
}
largestVersion.Add(b, maxVersionBlock);
}
return(true);
}
public static Theory PassificationProof(
string theoryName,
string boogieToVcTheoryName,
bool generateEndToEndLemma,
LemmaDecl boogieToVcLemma,
Term vcAssm,
CFGRepr beforePassificationCfg,
IDictionary <Block, Block> nonPassiveToPassiveBlock,
PassiveRelationGen relationGen,
IProgramAccessor beforePassiveProgAccess,
IProgramAccessor passiveProgAccess,
BoogieMethodData beforePassiveData,
IVariableTranslationFactory beforePassiveFactory,
IVariableTranslationFactory passiveFactory)
{
var varContextName = "\\<Lambda>1";
var passiveVarContextName = "\\<Lambda>2";
var varContextNonPassivePassive = Tuple.Create(varContextName, passiveVarContextName);
var oldGlobalVars = GetOldGlobalVariables(beforePassificationCfg);
var oldRelationData =
OldRelation(
oldGlobalVars,
beforePassiveFactory.CreateTranslation().VarTranslation,
out var oldRelListDecl);
var passificationProofDecls = new List <OuterDecl>();
passificationProofDecls.AddRange(oldRelListDecl);
passificationProofDecls.AddRange(oldRelationData.VarToLookupLemma.Values);
if (oldRelationData.VarToLookupLemma.Any())
{
passificationProofDecls.Add(new LemmasDecl(allOldLookupLemmasName,
oldRelationData.VarToLookupLemma.Values.Select(lemma => lemma.Name).ToList()));
}
var beforePassiveLemmaManager = new PassificationLemmaManager(
beforePassificationCfg,
nonPassiveToPassiveBlock,
beforePassiveProgAccess,
passiveProgAccess,
varContextNonPassivePassive,
oldRelationData,
relationGen,
beforePassiveFactory,
passiveFactory
);
var lemmaNamer = new IsaUniqueNamer();
var varContextAbbrev = new AbbreviationDecl(
varContextName,
new Tuple <IList <Term>, Term>(new List <Term>(), beforePassiveProgAccess.VarContext())
);
var passiveVarContextAbbrev = new AbbreviationDecl(
passiveVarContextName,
new Tuple <IList <Term>, Term>(new List <Term>(), passiveProgAccess.VarContext())
);
passificationProofDecls.Add(varContextAbbrev);
passificationProofDecls.Add(passiveVarContextAbbrev);
passificationProofDecls.AddRange(beforePassiveLemmaManager.Prelude());
var cfgLemmas = new List <OuterDecl>();
foreach (var block in beforePassificationCfg.GetBlocksBackwards())
{
var localAndCfgLemma =
beforePassiveLemmaManager.GenerateBlockLemma(
block,
GetLemmaName(block, lemmaNamer),
b => GetCfgLemmaName(b, lemmaNamer));
passificationProofDecls.Add(localAndCfgLemma.Item1);
cfgLemmas.Add(localAndCfgLemma.Item2);
}
//add cfg lemmas at the end
passificationProofDecls.AddRange(cfgLemmas);
if (generateEndToEndLemma)
{
var endToEnd = new PassificationEndToEnd();
passificationProofDecls.AddRange(endToEnd.EndToEndProof(
GetCfgLemmaName(beforePassificationCfg.entry, lemmaNamer),
boogieToVcTheoryName + "." + boogieToVcLemma.Name,
vcAssm,
beforePassiveProgAccess,
passiveProgAccess,
varContextNonPassivePassive,
oldRelationData,
beforePassificationCfg,
relationGen.LiveVarsBeforeBlock(beforePassificationCfg.entry),
passiveFactory.CreateTranslation().VarTranslation
));
}
var imports = new List <string>
{
"Boogie_Lang.Semantics", "Boogie_Lang.Util", beforePassiveProgAccess.TheoryName(),
passiveProgAccess.TheoryName(), "Boogie_Lang.PassificationML",
boogieToVcTheoryName
};
if (generateEndToEndLemma)
{
imports.Add("Boogie_Lang.PassificationEndToEnd");
}
return(new Theory(theoryName, imports, passificationProofDecls));
}
public IDictionary <Variable, int> GlobalVersionMap(PassiveRelationGen relationGen,
IEnumerable <Variable> entryVariables, Block entry, IList <Block> blocks)
{
_relationGen = relationGen;
_versionedBlocks = new HashSet <Block>();
_versionMap = new Dictionary <Variable, int>();
_nextVersion = 0;
foreach (var entryVar in entryVariables)
{
VersionVariable(entryVar);
}
var queue = new List <Block>();
var graph = GraphUtil.GraphFromBlocks(blocks);
//TODO: make the currently inefficient computation more efficient
queue.Add(entry);
while (queue.Any())
{
/* find next block B where all predecessors have been marked and where one of the following two cases hold
* (Case 1) B is the only predecessor of all of B's successors
* (Case 2) B has a single successor with multiple predecessors ps and each block in ps only has marked
* predecessors
*/
Block blockToHandle = null;
var caseId = CaseType.Undefined;
foreach (var block in queue)
{
if (IsUniquePredecessor(block, graph))
{
blockToHandle = block;
caseId = CaseType.Case1;
break;
}
else if (ReadySynchronization(block, graph))
{
blockToHandle = block;
caseId = CaseType.Case2;
break;
}
}
if (blockToHandle == null || caseId == CaseType.Undefined)
{
throw new ProofGenUnexpectedStateException(GetType(), "Could not compute global version map.");
}
List <Block> nextNodes = null;
if (caseId == CaseType.Case1)
{
nextNodes = HandleCase1(blockToHandle, graph).ToList();
}
else
{
nextNodes = HandleCase2(blockToHandle, graph).ToList();
}
queue.RemoveAll(b => _versionedBlocks.Contains(b));
queue.AddRange(nextNodes);
if (nextNodes.Any(b => _versionedBlocks.Contains(b)))
{
throw new ProofGenUnexpectedStateException(GetType(), "Added already versioned block to queue");
}
}
return(_versionMap);
}
