public static IList <Tuple <TermIdent, TypeIsa> > GlobalFixedVariables(
BoogieContextIsa boogieContext,
IEnumerable <Function> functions,
IEnumerable <Variable> variables,
TermIdent normalInitState,
IDictionary <Function, TermIdent> funToInterpMapping,
IsaUniqueNamer uniqueNamer)
{
var absValType = new VarType("a");
var pureTyIsaTransformer = LemmaHelper.ConretePureTyIsaTransformer(absValType);
var result = new List <Tuple <TermIdent, TypeIsa> >
{
Tuple.Create((TermIdent)boogieContext.absValTyMap, IsaBoogieType.AbstractValueTyFunType(absValType)),
Tuple.Create((TermIdent)boogieContext.varContext, IsaBoogieType.VarContextType()),
Tuple.Create((TermIdent)boogieContext.funContext, IsaBoogieType.FunInterpType(absValType)),
Tuple.Create(normalInitState, IsaBoogieType.NormalStateType(absValType))
};
foreach (var kv in funToInterpMapping)
{
result.Add(Tuple.Create(kv.Value, IsaBoogieType.BoogieFuncInterpType(absValType)));
var boogieFun = kv.Key;
//get untyped version, maybe should precompute this somewhere and re-use or get the data from the VC
TypeUtil.SplitTypeParams(boogieFun.TypeParameters, boogieFun.InParams.Select(v => v.TypedIdent.Type),
out var explicitTypeVars, out _);
var typeIsa = pureTyIsaTransformer.Translate(new Function(null, boogieFun.Name,
explicitTypeVars, boogieFun.InParams, boogieFun.OutParams[0]));
result.Add(Tuple.Create(
IsaCommonTerms.TermIdentFromName(uniqueNamer.GetName(boogieFun, boogieFun.Name)), typeIsa));
}
foreach (var v in variables)
{
var typeIsa = pureTyIsaTransformer.Translate(v);
result.Add(Tuple.Create(IsaCommonTerms.TermIdentFromName(uniqueNamer.GetName(v, v.Name)), typeIsa));
}
return(result);
}
public static Term ProcedureIsCorrect(Term funDecls, Term constantDecls, Term globalDecls, Term axioms,
Term procedure)
{
var typeInterpId = new SimpleIdentifier("A");
return
(TermQuantifier.MetaAll(
new List <Identifier> {
typeInterpId
},
null,
new TermApp(
IsaCommonTerms.TermIdentFromName("proc_is_correct"),
//TODO: here assuming that we use "'a" for the abstract value type carrier t --> make t a parameter somewhere
new TermWithExplicitType(new TermIdent(typeInterpId), IsaBoogieType.AbstractValueTyFunType(new VarType("a"))),
funDecls,
constantDecls,
globalDecls,
axioms,
procedure)));
}
//returns PureTyIsaTransformer that instantiates U and T with the concrete instantiations
public static PureTyIsaTransformer ConretePureTyIsaTransformer(TypeIsa abstractValueType)
{
//instantiate type in VC representing Boogie values with Boogie value type
//instantiate type in VC representing Boogie types with Boogie closed type
return(new PureTyIsaTransformer(IsaBoogieType.ValType(abstractValueType), IsaBoogieVC.BoogieClosedType()));
}
private ContextElem LemmaContext(
CFGRepr cfg,
Term vcAssm
)
{
var multiRed = IsaBoogieTerm.RedCFGMulti(
BoogieContextIsa.CreateWithNewVarContext(
boogieContext,
new TermTuple(programAccessor.ConstsAndGlobalsDecl(), programAccessor.ParamsAndLocalsDecl())
),
programAccessor.CfgDecl(),
IsaBoogieTerm.CFGConfigNode(new NatConst(cfg.GetUniqueIntLabel(cfg.entry)),
IsaBoogieTerm.Normal(normalInitState)),
IsaBoogieTerm.CFGConfig(finalNodeOrReturn, finalState)
);
var closedAssm = EndToEndAssumptions.ClosednessAssumption(boogieContext.absValTyMap);
var nonEmptyTypesAssm = EndToEndAssumptions.NonEmptyTypesAssumption(boogieContext.absValTyMap);
var finterpAssm = IsaBoogieTerm.FunInterpWf(boogieContext.absValTyMap, programAccessor.FunctionsDecl(),
boogieContext.funContext);
var absValType = new VarType("a");
//need to explicitly give type for normal state, otherwise Isabelle won't know that the abstract value type is the same as used in the VC
var axiomAssm = EndToEndAssumptions.AxiomAssumption(boogieContext, programAccessor,
new TermWithExplicitType(normalInitState, IsaBoogieType.NormalStateType(absValType)));
var presAssm =
IsaBoogieTerm.ExprAllSat(boogieContext, normalInitState, programAccessor.PreconditionsDecl());
var localsAssm = EndToEndAssumptions.LocalStateAssumption(boogieContext,
IsaCommonTerms.Snd(boogieContext.varContext), normalInitState);
var globalsAssm = EndToEndAssumptions.GlobalStateAssumption(boogieContext,
IsaCommonTerms.Fst(boogieContext.varContext), normalInitState);
var oldGlobalStateAssm = EndToEndAssumptions.OldGlobalStateAssumption(normalInitState);
var binderEmptyAssm = EndToEndAssumptions.BinderStateEmpty(normalInitState);
return
(ContextElem.CreateWithAssumptions(
new List <Term>
{
multiRed, vcAssm, closedAssm, nonEmptyTypesAssm, finterpAssm, axiomAssm,
presAssm, localsAssm, globalsAssm, oldGlobalStateAssm, binderEmptyAssm
},
new List <string>
{
redAssmName, vcAssmName, closedAssmName, nonEmptyTypesAssmName, finterpAssmName, axiomAssmName,
preconditionsAssmName, paramsLocalsAssmName, constsGlobalsAssmName, oldGlobalAssmName,
binderEmptyAssmName
}
));
}
/**
* cases:
* 1) is loop head block
* 2) is back edge block
* 3) successor is loop head block
*
* any combination is possible
*/
public static Theory CfgToDagProof(
PhasesTheories phasesTheories,
bool generateEndToEndLemma,
Term vcAssm,
CFGRepr beforeDagCfg,
CFGRepr afterDagCfg,
Block afterUniqueExit,
BoogieMethodData beforeDagData,
CfgToDagHintManager hintManager,
IDictionary <Block, Block> beforeToAfter,
IProgramAccessor beforeDagProgAccess,
IProgramAccessor afterDagProgAccess,
IVariableTranslationFactory varFactory)
{
var afterToBefore = beforeToAfter.InverseDict();
//track mapping from blocks to loops that the block is contained in and for which it is not the loop head
IDictionary <Block, IList <Block> > blocksToLoops = new Dictionary <Block, IList <Block> >();
foreach (var afterBlock in afterDagCfg.GetBlocksBackwards())
{
if (afterToBefore.TryGetValue(afterBlock, out var beforeBlock))
{
var loops = new HashSet <Block>();
foreach (var bSuc in beforeDagCfg.GetSuccessorBlocks(beforeBlock))
{
if (blocksToLoops.TryGetValue(bSuc, out var loopsSuc))
{
//if successor inside of a loop L and the block is not the loop head of L, then the block is also inside L
foreach (var loopSuc in loopsSuc)
{
if (!loopSuc.Equals(beforeBlock))
{
loops.Add(loopSuc);
}
}
}
}
/* a node is inside all loops for which it has an out-going backedge
* if a node has a backedge to itself (i.e., it is also a loop head), then we do not add this loop
*/
if (hintManager.TryIsBackedgeNode(beforeBlock, out var backedgeLoops))
{
foreach (var backedgeLoop in backedgeLoops)
{
if (beforeBlock != backedgeLoop)
{
loops.Add(backedgeLoop);
}
}
}
var loopsList = loops.ToList();
blocksToLoops.Add(beforeBlock, loopsList);
}
}
var varContextName = "\\<Lambda>1";
var varContextAbbrev = new AbbreviationDecl(
varContextName,
new Tuple <IList <Term>, Term>(new List <Term>(), beforeDagProgAccess.VarContext())
);
var funContextWfName = "Wf_Fun";
var boogieContext = new BoogieContextIsa(
IsaCommonTerms.TermIdentFromName("A"),
IsaCommonTerms.TermIdentFromName("M"),
IsaCommonTerms.TermIdentFromName(varContextName),
IsaCommonTerms.TermIdentFromName("\\<Gamma>"),
IsaCommonTerms.EmptyList);
var lemmaManager = new CfgToDagLemmaManager(
beforeDagProgAccess,
afterDagProgAccess,
boogieContext,
afterDagCfg,
funContextWfName,
hintManager,
blocksToLoops,
beforeToAfter,
beforeDagData,
afterUniqueExit,
varFactory);
var lemmaNamer = new IsaUniqueNamer();
var outerDecls = new List <OuterDecl>();
outerDecls.Add(varContextAbbrev);
outerDecls.Add(new DeclareDecl("Nat.One_nat_def[simp del]"));
if (afterUniqueExit != null)
{
outerDecls.AddRange(lemmaManager.UnifiedExitLemma(GetCfgLemmaName(afterUniqueExit, lemmaNamer)));
}
foreach (var afterBlock in afterDagCfg.GetBlocksBackwards())
{
if (afterToBefore.TryGetValue(afterBlock, out var beforeBlock))
{
//if the node's only edge is a backedge, then an "assume false" will be added
var singleCutEdge = hintManager.TryIsBackedgeNode(beforeBlock, out var _) &&
beforeDagCfg.NumOfSuccessors(beforeBlock) == 1;
var(localLemmas, cfgLemma) =
lemmaManager.BlockLemma(
beforeBlock,
afterBlock,
beforeDagCfg.GetSuccessorBlocks(beforeBlock),
block => GetLemmaName(block, lemmaNamer),
block => GetCfgLemmaName(block, lemmaNamer),
singleCutEdge
);
outerDecls.AddRange(localLemmas);
outerDecls.Add(cfgLemma);
}
else
{
//block was added as part of transformation
if (afterBlock == afterDagCfg.entry)
{
//entry lemma handled elsewhere
continue;
}
var afterBlockSuccessors = afterDagCfg.GetSuccessorBlocks(afterBlock);
var afterBlockSuccessorsList = afterBlockSuccessors.ToList();
if (!afterBlockSuccessorsList.Any())
{
//this must be the unique node
if (afterUniqueExit == null)
{
throw new ProofGenUnexpectedStateException(
"unique exit block added, but only exit block existed before cfg-to-dag");
}
continue;
}
if (afterBlockSuccessorsList.Count != 1)
{
throw new ProofGenUnexpectedStateException(
"Block added in CFG-to-DAG phase does not have a unique successor");
}
var afterUniqueSuc = afterBlockSuccessorsList.First();
if (afterToBefore.TryGetValue(afterUniqueSuc, out var beforeUniqueSuc))
{
hintManager.IsLoopHead(beforeUniqueSuc, out var hint);
var lemma = lemmaManager.NewBlockLemma(
GetCfgLemmaName(afterBlock, lemmaNamer),
afterBlock,
afterUniqueSuc,
hint
);
outerDecls.Add(lemma);
}
else if (hintManager.IsNewBackedgeBlock(afterBlock, out var loopHeadHint))
{
if (afterDagCfg.GetSuccessorBlocks(afterUniqueSuc).Any())
{
throw new ProofGenUnexpectedStateException(
"New backedge node has successor that is not the exit node.");
}
//afterUniqueSuc is a successor to a backedge node for which all edges were eliminated
var lemma = lemmaManager.NewBlockLemma(
GetCfgLemmaName(afterBlock, lemmaNamer),
afterBlock,
null,
loopHeadHint
);
outerDecls.Add(lemma);
}
else
{
throw new ProofGenUnexpectedStateException(
"CFG-to-DAG: Unique successor of added block cannot be mapped to original block");
}
}
}
var entryLemma = lemmaManager.EntryLemma("entry_lemma", beforeDagCfg.entry, afterDagCfg.entry,
b => GetCfgLemmaName(b, lemmaNamer));
outerDecls.Add(entryLemma);
var absValType = new VarType("a");
var cfgToDagLemmasLocale = new LocaleDecl(
"cfg_to_dag_lemmas",
new ContextElem(
new List <Tuple <TermIdent, TypeIsa> >
{
Tuple.Create((TermIdent)boogieContext.absValTyMap,
IsaBoogieType.AbstractValueTyFunType(absValType)),
Tuple.Create((TermIdent)boogieContext.funContext, IsaBoogieType.FunInterpType(absValType))
},
new List <Term>
{
IsaBoogieTerm.FunInterpWf(boogieContext.absValTyMap, beforeDagProgAccess.FunctionsDecl(),
boogieContext.funContext)
},
new List <string> {
funContextWfName
}
),
outerDecls
);
var theoryOuterDecls = new List <OuterDecl>();
theoryOuterDecls.Add(cfgToDagLemmasLocale);
if (generateEndToEndLemma)
{
var endToEndManager = new CfgToDagEndToEnd();
var endToEndDecls = endToEndManager.EndToEndProof(
cfgToDagLemmasLocale.Name + "." + entryLemma.Name,
phasesTheories.EndToEndLemmaName(PhasesTheories.Phase.Passification, true),
vcAssm,
beforeDagProgAccess,
beforeDagCfg
);
theoryOuterDecls.AddRange(endToEndDecls);
}
return(new Theory(
phasesTheories.TheoryName(PhasesTheories.Phase.CfgToDag),
new List <string>
{
"Boogie_Lang.Semantics", "Boogie_Lang.Util", "Boogie_Lang.BackedgeElim", "Boogie_Lang.TypingML",
beforeDagProgAccess.TheoryName(),
afterDagProgAccess.TheoryName(), phasesTheories.TheoryName(PhasesTheories.Phase.Passification),
phasesTheories.TheoryName(PhasesTheories.Phase.Vc)
},
theoryOuterDecls
));
}
public override Term IntType(Function func)
{
return(IsaBoogieVC.PrimTypeClosed(IsaBoogieType.IntType()));
}
