/// <summary> /// Initializes a new instance of the <see cref="MembershipLemmaManager"/> class. /// Generated instance only has information about global data. /// </summary> public MembershipLemmaManager( IsaGlobalProgramRepr globalProgRepr, int globalsMax, IVariableTranslationFactory factory, string theoryName) { containsLocalInformation = false; this.factory = factory; this.theoryName = theoryName; typeIsaVisitor = new TypeIsaVisitor(factory.CreateTranslation().TypeVarTranslation); basicCmdIsaVisitor = new BasicCmdIsaVisitor(factory); isaProgramRepr = new IsaProgramRepr(globalProgRepr, null, null, null, null, null, null); config = new IsaProgramGeneratorConfig(null, true, true, true, false, SpecsConfig.None, false); consts = QualifyAccessName(isaProgramRepr.GlobalProgramRepr.constantsDeclDef); globals = QualifyAccessName(isaProgramRepr.GlobalProgramRepr.globalsDeclDef); constsAndGlobalsDefs = new[] { consts + "_def", globals + "_def" }; constsAndGlobalsList = IsaCommonTerms.AppendList(IsaCommonTerms.TermIdentFromName(consts), IsaCommonTerms.TermIdentFromName(globals)); AddMinOrMaxLemma(true, globalsMax, VariableNames(constsAndGlobalsList)); AddWellFormednessLemmas(); }
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 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 BasicCmdIsaVisitor(IVariableTranslationFactory variableFactory) { this.variableFactory = variableFactory; boogieVarTranslation = variableFactory.CreateTranslation(); //by sharing TypeVarTranslation, changes in the bound variables will be visible in the type visitor typeIsaVisitor = new TypeIsaVisitor(boogieVarTranslation.TypeVarTranslation); }
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); }
/// <summary> /// Returns type visitor that contains the type variables of f in the context /// </summary> public static TypeIsaVisitor FunTypeIsaVisitor(Function f, IVariableTranslationFactory varTranslationFactory) { var typeVarTranslation = varTranslationFactory.CreateEmptyTranslation().TypeVarTranslation; /* * types variables are numbered as they appear in the list as opposed to type variables appearing later having a smaller number * that's the reason the loop iterates in reverse order */ foreach (var tv in ((IEnumerable <TypeVariable>)f.TypeParameters).Reverse()) { typeVarTranslation.AddBoundVariable(tv); } return(new TypeIsaVisitor(typeVarTranslation)); }
public AssumptionManager(IEnumerable <Function> functions, IEnumerable <Variable> variables, IVariableTranslationFactory factory) { _factory = factory; foreach (var f in functions) { RecordAssumptionLabel(f); } foreach (var v in variables) { RecordAssumptionLabel(v); } RecordAssumptionLabel(SpecialAssumptionsKind.TypeValClosed); }
public MembershipLemmaManager( IsaProgramGeneratorConfig config, IsaProgramRepr isaProgramRepr, IsaBlockInfo isaBlockInfo, Tuple <int, int> GlobalsMaxLocalsMin, IVariableTranslationFactory factory, string theoryName ) { parent = config.parentAccessor; this.isaProgramRepr = isaProgramRepr; this.factory = factory; this.theoryName = theoryName; this.config = config; this.isaBlockInfo = isaBlockInfo; typeIsaVisitor = new TypeIsaVisitor(factory.CreateTranslation().TypeVarTranslation); basicCmdIsaVisitor = new BasicCmdIsaVisitor(factory); paramsAndLocalsDefs = new[] { isaProgramRepr.paramsDeclDef + "_def", isaProgramRepr.localVarsDeclDef + "_def" }; parameters = config.generateParamsAndLocals ? QualifyAccessName(isaProgramRepr.paramsDeclDef) : parent.ParamsDecl(); locals = config.generateParamsAndLocals ? QualifyAccessName(isaProgramRepr.localVarsDeclDef) : parent.LocalsDecl(); paramsAndLocalsList = IsaCommonTerms.AppendList(IsaCommonTerms.TermIdentFromName(parameters), IsaCommonTerms.TermIdentFromName(locals)); consts = config.generateGlobalsAndConstants ? QualifyAccessName(isaProgramRepr.GlobalProgramRepr.constantsDeclDef) : parent.ConstsDecl(); globals = config.generateGlobalsAndConstants ? QualifyAccessName(isaProgramRepr.GlobalProgramRepr.globalsDeclDef) : parent.GlobalsDecl(); constsAndGlobalsDefs = new[] { consts + "_def", globals + "_def" }; constsAndGlobalsList = IsaCommonTerms.AppendList(IsaCommonTerms.TermIdentFromName(consts), IsaCommonTerms.TermIdentFromName(globals)); AddDisjointnessLemmas(GlobalsMaxLocalsMin.Item1, GlobalsMaxLocalsMin.Item2); AddWellFormednessLemmas(); }
public static Term FunDecl(Function f, IVariableTranslationFactory varTranslationFactory, bool includeName = true) { var typeIsaVisitor = LemmaHelper.FunTypeIsaVisitor(f, varTranslationFactory); Term fname = new StringConst(f.Name); Term numTypeParams = new NatConst(f.TypeParameters.Count); var argTypes = new TermList(f.InParams.Select(v => typeIsaVisitor.Translate(v.TypedIdent.Type)).ToList()); var retType = typeIsaVisitor.Translate(f.OutParams.First().TypedIdent.Type); if (includeName) { return(new TermTuple(new List <Term> { fname, numTypeParams, argTypes, retType })); } return(new TermTuple(new List <Term> { numTypeParams, argTypes, retType })); }
public EqualityHintGenerator(IVariableTranslationFactory variableFactory) { this.variableFactory = variableFactory; }
public static Term FunInterpSingleWf(Function f, Term absValTyMap, Term fTerm, IVariableTranslationFactory factory) { return(FunInterpSingleWf(absValTyMap, FunDecl(f, factory), fTerm)); }
public TypingTacticGenerator(IProgramAccessor programAccessor, IVariableTranslationFactory factory) { this.programAccessor = programAccessor; equalityHintGenerator = new EqualityHintGenerator(factory); }
public IProgramAccessor GetIsaProgram( string theoryName, string procName, BoogieMethodData methodData, IsaProgramGeneratorConfig config, IVariableTranslationFactory varTranslationFactory, CFGRepr cfg, out IList <OuterDecl> decls, bool generateMembershipLemmas = true, bool onlyGlobalData = false ) { this.varTranslationFactory = varTranslationFactory; varTranslation = varTranslationFactory.CreateTranslation(); cmdIsaVisitor = new MultiCmdIsaVisitor(varTranslationFactory); /* * Term program = IsaBoogieTerm.Program(IsaCommonTerms.TermIdentFromName(funcs.name), * new TermList(new List<Term>()), * new TermList(new List<Term>()), * IsaCommonTerms.TermIdentFromName(axiomsDecl.name), * new List<Term>() { method }); * * var list = new List<Tuple<IList<Term>, Term>> * { * new Tuple<IList<Term>, Term>(new List<Term>(), program) * }; */ //OuterDecl programDefinition = new DefDecl("ProgramM", new Tuple<IList<Term>, Term>(new List<Term>(), program)); decls = new List <OuterDecl>(); var isaGlobalProgramRepr = new IsaGlobalProgramRepr( FunctionDeclarationsName(), AxiomDeclarationsName(), VariableDeclarationsName("globals"), VariableDeclarationsName("constants") ); var globalsMax = methodData.Constants.Count() + methodData.GlobalVars.Count() - 1; // assume single versioning and order on constants, globals, params, locals var localsMin = globalsMax + 1; if (globalsMax < 0) { globalsMax = 0; } MembershipLemmaManager membershipLemmaManager; if (onlyGlobalData) { membershipLemmaManager = new MembershipLemmaManager( isaGlobalProgramRepr, globalsMax, varTranslationFactory, theoryName); } else { var outEdges = GetOutEdgesIsa(procName, cfg, out var edgeLemmas); var blockInfo = BlockToInfo(theoryName, procName, cfg, edgeLemmas); var isaProgramRepr = new IsaProgramRepr( isaGlobalProgramRepr, PreconditionDeclarationName(), PostconditionDeclarationName(), VariableDeclarationsName("params"), VariableDeclarationsName("locals"), cfgName, procDefName); membershipLemmaManager = new MembershipLemmaManager(config, isaProgramRepr, blockInfo, Tuple.Create(globalsMax, localsMin), varTranslationFactory, theoryName); var nodesToBlocks = GetNodeToBlocksIsa(cfg, blockInfo.BlockCmdsDefs); decls.AddRange(blockInfo.BlockCmdsDefs.Values); Term entry = new IntConst(BigNum.FromInt(cfg.GetUniqueIntLabel(cfg.entry))); var methodBodyCFG = IsaBoogieTerm.MethodCFGBody( entry, IsaCommonTerms.TermIdentFromName(outEdges.Name), IsaCommonTerms.TermIdentFromName(nodesToBlocks.Name) ); var methodBodyDecl = GetMethodBodyCFGDecl(procName, methodBodyCFG); decls.AddRange( new List <OuterDecl> { outEdges, nodesToBlocks, methodBodyDecl }); decls.AddRange(blockInfo.BlockCmdsLemmas.Values); decls.AddRange(blockInfo.BlockOutEdgesLemmas.Values); if (config.specsConfig != SpecsConfig.None) { OuterDecl preconditions; OuterDecl postconditions; if (config.specsConfig == SpecsConfig.AllPreCheckedPost) { preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions.Select(pre => pre.Item1)); postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions.Where(post => !post.Item2).Select(post => post.Item1)); } else { preconditions = GetExprListIsa(PreconditionDeclarationName(), methodData.Preconditions); postconditions = GetExprListIsa(PostconditionDeclarationName(), methodData.Postconditions); } decls.Add(preconditions); decls.Add(postconditions); } if (config.generateParamsAndLocals) { decls.Add(GetVariableDeclarationsIsa("params", methodData.InParams)); decls.Add(GetVariableDeclarationsIsa("locals", methodData.Locals)); } /* membership lemmas might still be added even if the parameter and local variable definitions are not generated * at this point (since the variable context may still be different, which requires other lookup lemmas) */ if (generateMembershipLemmas) { membershipLemmaManager.AddVariableMembershipLemmas(methodData.InParams, VarKind.ParamOrLocal); membershipLemmaManager.AddVariableMembershipLemmas(methodData.Locals, VarKind.ParamOrLocal); } } if (config.generateAxioms) { decls.Add(GetAxioms(methodData.Axioms)); if (generateMembershipLemmas) { membershipLemmaManager.AddAxiomMembershipLemmas(methodData.Axioms); } } if (config.generateFunctions) { decls.Add(GetFunctionDeclarationsIsa(methodData.Functions)); if (generateMembershipLemmas) { membershipLemmaManager.AddFunctionMembershipLemmas(methodData.Functions); } } if (config.generateGlobalsAndConstants) { decls.Add(GetVariableDeclarationsIsa("globals", methodData.GlobalVars)); decls.Add(GetVariableDeclarationsIsa("constants", methodData.Constants)); } if (generateMembershipLemmas) { membershipLemmaManager.AddVariableMembershipLemmas(methodData.GlobalVars, VarKind.Global); membershipLemmaManager.AddVariableMembershipLemmas(methodData.Constants, VarKind.Constant); decls.AddRange(membershipLemmaManager.OuterDecls()); } if (config.specsConfig != SpecsConfig.None) { DefDecl methodDef = MethodDefinition(membershipLemmaManager, methodData, config.specsConfig); decls.Add(methodDef); } return(membershipLemmaManager); }
public static Theory ProgramToVcProof( string theoryName, bool generateEndToEndProof, CFGRepr finalCfg, CFGRepr afterPassificationCfg, IDictionary <Block, Block> afterPassiveToFinalBlock, IDictionary <Block, Block> afterPassiveToOrigBlock, IProgramAccessor passiveProgAccess, IProgramAccessor beforePassiveProgAccess, BoogieMethodData methodData, ProgramVcProofData vcProofData, IVariableTranslationFactory varFactory, TypePremiseEraserFactory eraserFactory, VCExpressionGenerator gen, out Term vcAssm, out LemmaDecl endToEndLemma) { var lemmaNamer = new IsaUniqueNamer(); var passiveLemmaManager = new VcPhaseLemmaManager( vcProofData.VcBoogieInfo.VcInst, methodData, vcProofData.VcFunctions, passiveProgAccess.BlockInfo(), varFactory); var afterPassiveReachableBlocks = ReachableBlocks(afterPassificationCfg); var finalProgramLemmas = GenerateVCLemmas(afterPassificationCfg, finalCfg, afterPassiveToFinalBlock, afterPassiveToOrigBlock, afterPassiveReachableBlocks, passiveLemmaManager, vcProofData.VcHintManager, lemmaNamer); var cfgProgramLemmas = GenerateCfgLemmas(afterPassificationCfg, finalCfg, afterPassiveToFinalBlock, afterPassiveReachableBlocks, finalProgramLemmas, passiveLemmaManager, passiveProgAccess.CfgDecl(), lemmaNamer); var afterPassificationDecls = new List <OuterDecl>(); foreach (var v in finalProgramLemmas.Values) { afterPassificationDecls.AddRange(v); } afterPassificationDecls.AddRange(cfgProgramLemmas.Values); var afterPassificationLocale = GenerateLocale("passification", passiveLemmaManager, afterPassificationDecls); var passiveOuterDecls = new List <OuterDecl> { vcProofData.VcLocale }; passiveOuterDecls.Add(afterPassificationLocale); //generate axiom var axiomUniqueNamer = new IsaUniqueNamer(); var axId = 0; var axiomToLemma = new Dictionary <Axiom, OuterDecl>(); var vcRewriteLemmaGen = new VcRewriteLemmaGen(eraserFactory, VCExprToIsaTranslator.CreateNameBasedTranslator(new IsaUniqueNamer())); var vcAxiomLemmaManager = new VcAxiomLemmaManager( vcProofData.VcBoogieInfo.VcInstAxiom, methodData, vcProofData.VcFunctions, vcRewriteLemmaGen, varFactory); var axiomLocaleRequiredDecls = new List <OuterDecl>(); foreach (var axiom in vcProofData.VcBoogieInfo.VcAxiomsInfo) { if (axiom is VcBoogieAxiomInfo vcBoogieAxiom) { var axiomVcLemma = vcAxiomLemmaManager.AxiomVcLemma( axiomUniqueNamer.GetName(axiom, "axiom_vc_" + axId), vcBoogieAxiom.Axiom, vcBoogieAxiom.Expr, out var requiredDecls); axiomToLemma.Add(vcBoogieAxiom.Axiom, axiomVcLemma); axiomLocaleRequiredDecls.AddRange(requiredDecls); } } /* we add the required declarations for the axiom locale to the outer theory, since the axiom locale fixes variables that could clash * with the declarations */ passiveOuterDecls.AddRange(axiomLocaleRequiredDecls); var axiomLocale = GenerateLocale("axioms", vcAxiomLemmaManager, axiomToLemma.Values.ToList()); passiveOuterDecls.Add(axiomLocale); if (generateEndToEndProof) { var endToEnd = new EndToEndVCProof( methodData, passiveProgAccess, vcProofData.VcFunctions, vcProofData.VcBoogieInfo, afterPassificationCfg, finalCfg, afterPassificationLocale.Name + "." + cfgProgramLemmas[afterPassificationCfg.entry].Name, axiomLocale.Name, ax => axiomLocale.Name + "." + axiomToLemma[ax].Name, varFactory, vcProofData.VcTranslator, eraserFactory, gen); passiveOuterDecls.AddRange(endToEnd.GenerateProof(out vcAssm, out endToEndLemma)); } else { vcAssm = null; endToEndLemma = null; } return (new Theory(theoryName, new List <string> { "Boogie_Lang.Semantics", "Boogie_Lang.Util", "Boogie_Lang.VCHints", "Boogie_Lang.VCPhaseML", passiveProgAccess.TheoryName(), beforePassiveProgAccess.TheoryName() }, passiveOuterDecls)); }
/** * 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 )); }
/// <summary> /// Generate all proofs for the current procedure. /// </summary> /// <param name="vc">WP of the procedure body</param> /// <param name="vcAxioms">VC assumptions for the Boogie axioms</param> /// <param name="typeAxioms">VC assumptions for the Boogie type encoding</param> /// <param name="typeAxiomInfo">Hints about the type encoding</param> /// <param name="gen"></param> /// <param name="translator"></param> /// <param name="axiomBuilder"></param> /// <exception cref="ArgumentException"> /// axiom builder must be null iff types are not erased (since no polymorphism in vc), otherwise exception is /// thrown /// </exception> public static void VCGenerateAllProofs( VCExpr vc, VCExpr vcAxioms, VCExpr typeAxioms, List <VCAxiomInfo> typeAxiomInfo, VCExpressionGenerator gen, Boogie2VCExprTranslator translator, TypeAxiomBuilderPremisses axiomBuilder) { var uniqueNamer = new IsaUniqueNamer(); var theories = new List <Theory>(); if (axiomBuilder == null && typeAxioms != null) { throw new ArgumentException("type axioms can only be null if axiom builder is null"); } /* Since in the proofs calls are desugared, there can be more variables in "beforePassiveData". If only * the progam should be generaed, then these variables should be ignored. */ var mainData = CommandLineOptions.Clo.GenerateIsaProgNoProofs ? beforeDagData : beforePassiveData; var fixedVarTranslation2 = new DeBruijnFixedVarTranslation(mainData); var fixedTyVarTranslation2 = new DeBruijnFixedTVarTranslation(mainData); var varTranslationFactory2 = new DeBruijnVarFactory(fixedVarTranslation2, fixedTyVarTranslation2, boogieGlobalData); #region before cfg to dag program var beforeCfgToDagTheoryName = uniqueNamer.GetName(afterPassificationImpl.Name + "_before_cfg_to_dag_prog"); //Hack: specs config used to distinguish between all (free + checks) (--> expression tuples) or just checked (no tuples) var specsConfig = CommandLineOptions.Clo.GenerateIsaProgNoProofs ? SpecsConfig.All : SpecsConfig.AllPreCheckedPost; var beforeCfgToDagConfig = new IsaProgramGeneratorConfig(globalDataProgAccess, false, false, false, true, specsConfig, true); var beforeCfgToDagProgAccess = new IsaProgramGenerator().GetIsaProgram( beforeCfgToDagTheoryName, afterPassificationImpl.Name, mainData, beforeCfgToDagConfig, varTranslationFactory2, beforeDagCfg, out var programDeclsBeforeCfgToDag, !CommandLineOptions.Clo.GenerateIsaProgNoProofs); procNameToTopLevelPrograms.Add(afterPassificationImpl.Proc.Name, beforeCfgToDagProgAccess); var beforeCfgToDagProgTheory = new Theory(beforeCfgToDagTheoryName, new List <string> { "Boogie_Lang.Semantics", "Boogie_Lang.TypeSafety", "Boogie_Lang.Util", "\"../" + globalDataProgAccess.TheoryName() + "\"" }, programDeclsBeforeCfgToDag); theories.Add(beforeCfgToDagProgTheory); #endregion if (CommandLineOptions.Clo.GenerateIsaProgNoProofs) { StoreResult("program_" + afterPassificationImpl.Proc.Name, theories); return; } #region before passive program var beforePassiveProgTheoryName = uniqueNamer.GetName(afterPassificationImpl.Name + "_before_passive_prog"); var beforePassiveConfig = new IsaProgramGeneratorConfig(beforeCfgToDagProgAccess, false, false, false, false, SpecsConfig.None, false); var beforePassiveProgAccess = new IsaProgramGenerator().GetIsaProgram(beforePassiveProgTheoryName, afterPassificationImpl.Name, mainData, beforePassiveConfig, varTranslationFactory2, beforePassificationCfg, out var programDeclsBeforePassive, !CommandLineOptions.Clo.GenerateIsaProgNoProofs); #endregion var vcAllAxioms = AxiomHandler.AxiomInfo( axiomBuilder != null, boogieGlobalData.Axioms, vcAxioms, typeAxioms, typeAxiomInfo, out var allAxiomsInfo); var vcLocale = VCToIsaInterface.ConvertVC( "vc", vc, vcAllAxioms, new StandardActiveDecl(), translator, axiomBuilder, finalProgData, afterUnreachablePruningCfg, out var vcinst, out var vcinstAxiom, out var vcTranslator, out var vcFunctions); //use global version map for translation var fixedVarTranslation = new SimpleFixedVarTranslation(globalVersionMap); var fixedTyVarTranslation = new DeBruijnFixedTVarTranslation(finalProgData); varTranslationFactory = new DeBruijnVarFactory(fixedVarTranslation, fixedTyVarTranslation, boogieGlobalData); var finalProgTheoryName = uniqueNamer.GetName(afterPassificationImpl.Name + "_passive_prog"); var passiveProgConfig = new IsaProgramGeneratorConfig(beforePassiveProgAccess, false, false, false, true, SpecsConfig.None, false); var passiveProgAccess = new IsaProgramGenerator().GetIsaProgram(finalProgTheoryName, afterPassificationImpl.Name, finalProgData, passiveProgConfig, varTranslationFactory, //we use the CFG before the peep-hole transformations, so that we can directly use the VC to program proof in the passification phase afterPassificationCfg, out var programDecls, !CommandLineOptions.Clo.GenerateIsaProgNoProofs); var finalProgTheory = new Theory(finalProgTheoryName, new List <string> { "Boogie_Lang.Semantics", "Boogie_Lang.Util", beforePassiveProgAccess.TheoryName() }, programDecls); theories.Add(finalProgTheory); var vcBoogieInfo = new VcBoogieInfo(vcinst, vcinstAxiom, vcAllAxioms, allAxiomsInfo); var vcProofData = new ProgramVcProofData( vcFunctions, vcBoogieInfo, vcHintManager, vcLocale, vcTranslator ); var phasesTheories = new PhasesTheories(afterPassificationImpl.Name); var theoryPassive = VcPhaseManager.ProgramToVcProof( phasesTheories.TheoryName(PhasesTheories.Phase.Vc), _proofGenConfig.GenerateVcE2E, afterUnreachablePruningCfg, afterPassificationCfg, afterPassificationToAfterUnreachableBlock, afterPassificationToOrigBlock, passiveProgAccess, beforePassiveProgAccess, finalProgData, vcProofData, varTranslationFactory, typePremiseEraserFactory, gen, out var vcAssm, out var endToEndLemma ); theories.Add(theoryPassive); #region before passive var passificationProgTheory = new Theory(beforePassiveProgTheoryName, new List <string> { "Boogie_Lang.Semantics", "Boogie_Lang.Util", beforeCfgToDagTheoryName }, programDeclsBeforePassive); theories.Add(passificationProgTheory); /* * Console.WriteLine("Passive prog mapping: " + fixedVarTranslation.OutputMapping()); * Console.WriteLine("Before passive prog mapping: " + fixedVarTranslation2.OutputMapping()); */ var passificationProofTheory = PassificationManager.PassificationProof( phasesTheories.TheoryName(PhasesTheories.Phase.Passification), theoryPassive.TheoryName, _proofGenConfig.GeneratePassifE2E, endToEndLemma, vcAssm, beforePassificationCfg, beforePassiveToAfterPassiveBlock, passiveRelationGen, beforePassiveProgAccess, passiveProgAccess, mainData, varTranslationFactory2, varTranslationFactory ); theories.Add(passificationProofTheory); #endregion #region cfg to dag var uniqueExitBlock = uniqueExitBlockOrig != null ? beforePassiveOrigBlock.First(kv => kv.Value == uniqueExitBlockOrig).Key : null; var cfgToDagProofTheory = CfgToDagManager.CfgToDagProof( phasesTheories, _proofGenConfig.GenerateCfgDagE2E, vcAssm, beforeDagCfg, beforePassificationCfg, uniqueExitBlock, beforeDagData, cfgToDagHintManager, beforeDagAfterDagBlock, beforeCfgToDagProgAccess, beforePassiveProgAccess, varTranslationFactory2); theories.Add(cfgToDagProofTheory); #endregion StoreResult(afterPassificationImpl.Proc.Name, theories); }
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 MultiCmdIsaVisitor(IVariableTranslationFactory varTranslationFactory) : this( new BasicCmdIsaVisitor(varTranslationFactory)) { }