public static VCExpr Block(Block b, VCExpr N, VCContext ctxt) //modifies ctxt.*; { Contract.Requires(b != null); Contract.Requires(N != null); Contract.Requires(ctxt != null); Contract.Ensures(Contract.Result<VCExpr>() != null); VCExpressionGenerator gen = ctxt.Ctxt.ExprGen; Contract.Assert(gen != null); VCExpr res = N; for (int i = b.Cmds.Count; --i >= 0; ) { res = Cmd(b, cce.NonNull( b.Cmds[i]), res, ctxt); } int id = b.UniqueId; if (ctxt.Label2absy != null) { ctxt.Label2absy[id] = b; } try { cce.BeginExpose(ctxt); if (ctxt.Label2absy == null) { return res; } else { return gen.Implies(gen.LabelPos(cce.NonNull(id.ToString()), VCExpressionGenerator.True), res); } } finally { cce.EndExpose(); } }
public VCContext(Dictionary<int, Absy> label2absy, ProverContext ctxt, VCExpr controlFlowVariableExpr, bool isPositiveContext = true) { Contract.Requires(ctxt != null); this.Label2absy = label2absy; this.Ctxt = ctxt; this.ControlFlowVariableExpr = controlFlowVariableExpr; this.isPositiveContext = isPositiveContext; }
public override void Assert(VCExpr vc, bool polarity) { LineariserOptions linOptions = new Z3LineariserOptions(false, (Z3InstanceOptions)this.options, new List<VCExprVar>()); if (polarity) context.AddAxiom(vc, linOptions); else context.AddConjecture(vc, linOptions); }
public override void BeginCheck(string descriptiveName, VCExpr vc, ErrorHandler handler) { LineariserOptions linOptions = new Z3LineariserOptions(false, (Z3InstanceOptions)this.options, new List<VCExprVar>()); Push(); context.AddAxiom(context.Axioms, linOptions); context.AddConjecture(vc, linOptions); outcome = context.Check(out z3LabelModels); Pop(); }
public abstract void AddAxiom(VCExpr vc);
public VCExpr TypeOf(VCExpr expr) { Contract.Requires(expr != null); Contract.Ensures(Contract.Result<VCExpr>() != null); return Gen.Function(TypeFunction, expr); }
public override void BeginCheck(string descriptiveName, VCExpr vc, ErrorHandler handler) { /*Contract.Requires(descriptiveName != null);*/ //Contract.Requires(vc != null); //Contract.Requires(handler != null); throw new NotImplementedException(); }
public virtual void DefineMacro(Macro fun, VCExpr vc) { throw new NotImplementedException(); }
// (assert vc) public virtual void Assert(VCExpr vc, bool polarity) { throw new NotImplementedException(); }
// (assert vc) public virtual void Assert(VCExpr vc, bool polarity, bool isSoft = false, int weight = 1) { throw new NotImplementedException(); }
/// <summary> /// Push a Verification Condition as an Axiom /// (Required for Doomed Program Point detection) /// </summary> public void PushVCExpr(VCExpr vc) { Contract.Requires(vc != null); //thmProver.Context.AddAxiom(vc); thmProver.PushVCExpression(vc); }
protected override bool StandardResult(VCExpr node, bool arg) { if (node is VCExprVar varNode && translator.TranslateVCVar(varNode, out var boogieVar)) { NamedDeclarations.Add(boogieVar); }
public void Print(VCExpr expr, TextWriter wr) { Contract.Requires(wr != null); Contract.Requires(expr != null); expr.Accept <bool, TextWriter /*!*/>(this, wr); }
/// <summary> /// Computes the wlp for an assert or assume command "cmd". /// </summary> public static VCExpr P_Cmd(Block b, HashSet <string> constantsAssumed, Cmd cmd, VCExpr N, VCContext ctxt) { Contract.Requires(cmd != null); Contract.Requires(N != null); Contract.Requires(ctxt != null); Contract.Ensures(Contract.Result <VCExpr>() != null); VCExpressionGenerator gen = ctxt.Ctxt.ExprGen; Contract.Assert(gen != null); if (cmd is AssertCmd) { AssertCmd ac = (AssertCmd)cmd; ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext; VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr); ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext; if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed) { return(gen.Implies(C, N)); } else { int id = ac.UniqueId; if (ctxt.Label2absy != null) { ctxt.Label2absy[id] = ac; } switch (Subsumption(ac)) { case CommandLineOptions.SubsumptionOption.Never: break; case CommandLineOptions.SubsumptionOption.Always: N = gen.Implies(C, N); break; case CommandLineOptions.SubsumptionOption.NotForQuantifiers: if (!(C is VCExprQuantifier)) { N = gen.Implies(C, N); } break; default: Contract.Assert(false); throw new cce.UnreachableException(); // unexpected case } // (MSchaef) Hack: This line might be useless, but at least it is not harmful // need to test it if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed) { return(gen.Implies(C, N)); } ctxt.AssertionCount++; if (ctxt.ControlFlowVariableExpr == null) { Contract.Assert(ctxt.Label2absy != null); return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N)); } else { VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId))); Contract.Assert(controlFlowFunctionAppl != null); VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId))); if (ctxt.Label2absy == null) { return(gen.AndSimp(gen.Implies(assertFailure, C), N)); } else { return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N)); } } } } else if (cmd is AssumeCmd) { AssumeCmd ac = (AssumeCmd)cmd; if (CommandLineOptions.Clo.StratifiedInlining > 0) { Contract.Assert(false); throw new System.Exception(string.Format("VC Generation in ICE-learning does not handle stratified inlining")); var pname = QKeyValue.FindStringAttribute(ac.Attributes, "candidate"); if (pname != null) { return(gen.ImpliesSimp(gen.LabelPos("candidate_" + pname.ToString(), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N)); } // Label the assume if it is a procedure call NAryExpr naryExpr = ac.Expr as NAryExpr; if (naryExpr != null) { if (naryExpr.Fun is FunctionCall) { int id = ac.UniqueId; ctxt.Label2absy[id] = ac; return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N)); } } } //return gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N); else { if (constantsAssumed == null) { return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N)); } // check if the assume command contains any of the constantsAssumed (corresponding to existential function calls)? var funcsUsed = FunctionCollector.Collect(ac.Expr); bool hasAnyConstantAssumed = false; foreach (var tup in funcsUsed) { var constantFunc = tup.Item1; if (constantsAssumed.Contains(constantFunc.Name)) { hasAnyConstantAssumed = true; break; } } if (hasAnyConstantAssumed) { int id = ac.UniqueId; if (ctxt.Label2absy != null) { ctxt.Label2absy[id] = ac; } //ctxt.AssertionCount++; if (ctxt.ControlFlowVariableExpr == null) { Contract.Assert(ctxt.Label2absy != null); return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N)); } else { return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N)); /*VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId))); * Contract.Assert(controlFlowFunctionAppl != null); * VCExpr assumeFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId))); * if (ctxt.Label2absy == null) * { * throw new System.Exception(string.Format("Dont know how to handle labels for the assume cmd")); * //return gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), gen.Implies(assumeFailure, ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr))), N); * } * else * { * return gen.ImpliesSimp(gen.LabelPos(cce.NonNull(id.ToString()), gen.Implies(assumeFailure, ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr))), N); * } */ } } else { return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N)); } } } else { Console.WriteLine(cmd.ToString()); Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command } }
/// <summary> /// Computes the wlp for an assert or assume command "cmd". /// </summary> public static VCExpr Cmd(Block b, Cmd cmd, VCExpr N, VCContext ctxt) { Contract.Requires(cmd != null); Contract.Requires(N != null); Contract.Requires(ctxt != null); Contract.Ensures(Contract.Result <VCExpr>() != null); VCExpressionGenerator gen = ctxt.Ctxt.ExprGen; Contract.Assert(gen != null); if (cmd is AssertCmd) { AssertCmd ac = (AssertCmd)cmd; ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext; VCExpr C = ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr); ctxt.Ctxt.BoogieExprTranslator.isPositiveContext = !ctxt.Ctxt.BoogieExprTranslator.isPositiveContext; if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed) { return(gen.Implies(C, N)); } else { int id = ac.UniqueId; if (ctxt.Label2absy != null) { ctxt.Label2absy[id] = ac; } switch (Subsumption(ac)) { case CommandLineOptions.SubsumptionOption.Never: break; case CommandLineOptions.SubsumptionOption.Always: N = gen.Implies(C, N); break; case CommandLineOptions.SubsumptionOption.NotForQuantifiers: if (!(C is VCExprQuantifier)) { N = gen.Implies(C, N); } break; default: Contract.Assert(false); throw new cce.UnreachableException(); // unexpected case } // (MSchaef) Hack: This line might be useless, but at least it is not harmful // need to test it if (CommandLineOptions.Clo.vcVariety == CommandLineOptions.VCVariety.Doomed) { return(gen.Implies(C, N)); } ctxt.AssertionCount++; if (ctxt.ControlFlowVariableExpr == null) { Contract.Assert(ctxt.Label2absy != null); return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), C), N)); } else { VCExpr controlFlowFunctionAppl = gen.ControlFlowFunctionApplication(ctxt.ControlFlowVariableExpr, gen.Integer(BigNum.FromInt(b.UniqueId))); Contract.Assert(controlFlowFunctionAppl != null); VCExpr assertFailure = gen.Eq(controlFlowFunctionAppl, gen.Integer(BigNum.FromInt(-ac.UniqueId))); if (ctxt.Label2absy == null) { return(gen.AndSimp(gen.Implies(assertFailure, C), N)); } else { return(gen.AndSimp(gen.LabelNeg(cce.NonNull(id.ToString()), gen.Implies(assertFailure, C)), N)); } } } } else if (cmd is AssumeCmd) { AssumeCmd ac = (AssumeCmd)cmd; if (CommandLineOptions.Clo.StratifiedInlining > 0) { var pname = QKeyValue.FindStringAttribute(ac.Attributes, "candidate"); if (pname != null) { return(gen.ImpliesSimp(gen.LabelPos("candidate_" + pname.ToString(), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N)); } // Label the assume if it is a procedure call NAryExpr naryExpr = ac.Expr as NAryExpr; if (naryExpr != null) { if (naryExpr.Fun is FunctionCall) { int id = ac.UniqueId; ctxt.Label2absy[id] = ac; return(gen.ImpliesSimp(gen.LabelPos(cce.NonNull("si_fcall_" + id.ToString()), ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr)), N)); } } } return(gen.ImpliesSimp(ctxt.Ctxt.BoogieExprTranslator.Translate(ac.Expr), N)); } else { Console.WriteLine(cmd.ToString()); Contract.Assert(false); throw new cce.UnreachableException(); // unexpected command } }
//////////////////////////////////////////////////////////////////////////// protected override bool StandardResult(VCExpr node, bool arg) { //Contract.Requires(node != null); return false; // by default, do not collect terms containing node }
public void Initialize(VCExpr evc) { Contract.Requires(evc != null); m_Checker.PushVCExpr(evc); }
public abstract void BeginCheck(string descriptiveName, VCExpr vc, ErrorHandler handler);
public void BeginCheck(string descriptiveName, VCExpr vc, ProverInterface.ErrorHandler handler) { Contract.Requires(descriptiveName != null); Contract.Requires(vc != null); Contract.Requires(handler != null); Contract.Requires(IsReady); status = CheckerStatus.Busy; hasOutput = false; outputExn = null; this.handler = handler; thmProver.Reset(gen); SetTimeout(); proverStart = DateTime.UtcNow; thmProver.BeginCheck(descriptiveName, vc, handler); // gen.ClearSharedFormulas(); PR: don't know yet what to do with this guy ProverTask = Task.Factory.StartNew(() => { WaitForOutput(null); }, TaskCreationOptions.LongRunning); }
/// <summary> /// MSchaef: Allows to Push a VCExpression as Axiom on the prover stack (beta) /// for now it is only implemented by ProcessTheoremProver and still requires some /// testing /// </summary> public virtual void PushVCExpression(VCExpr vc) { Contract.Requires(vc != null); throw new NotImplementedException(); }
public virtual string VCExpressionToString(VCExpr vc) { Contract.Requires(vc != null); Contract.Ensures(Contract.Result <string>() != null); throw new NotImplementedException(); }
// (assert vc) public virtual void Assert(VCExpr vc, bool polarity, bool isSoft = false, int weight = 1, string name = null) { throw new NotImplementedException(); }
private VCExpr Store(Function store, VCExpr map, List<VCExprVar/*!*/>/*!*/ indexes, VCExpr val) { Contract.Requires(val != null); Contract.Requires(map != null); Contract.Requires(store != null); Contract.Requires(cce.NonNullElements(indexes)); Contract.Ensures(Contract.Result<VCExpr>() != null); List<VCExpr/*!*/>/*!*/ storeArgs = new List<VCExpr/*!*/>(indexes.Count + 2); storeArgs.Add(map); storeArgs.AddRange(HelperFuns.ToVCExprList(indexes)); storeArgs.Add(val); return Gen.Function(store, storeArgs); }
// these optimisations should maybe be moved into a separate // visitor (peep-hole optimisations) private bool IsTriviallyTrue(VCExpr expr) { Contract.Requires(expr != null); if (expr.Equals(VCExpressionGenerator.True)) return true; if (expr is VCExprNAry) { VCExprNAry/*!*/ naryExpr = (VCExprNAry)expr; Contract.Assert(naryExpr != null); if (naryExpr.Op.Equals(VCExpressionGenerator.EqOp) && naryExpr[0].Equals(naryExpr[1])) return true; } return false; }
public virtual object Evaluate(VCExpr expr) { throw new NotImplementedException(); }
public abstract string translate(VCExpr expr, int polarity);
// Assert vc tagged with a name public virtual void AssertNamed(VCExpr vc, bool polarity, string name) { throw new NotImplementedException(); }
protected override bool StandardResult(VCExpr node, bool arg) { return(true); }
///////////////////////////////////////////////////////////////////////////////////// public bool Visit(VCExprNAry node, LineariserOptions options) { VCExprOp op = node.Op; Contract.Assert(op != null); var booleanOps = new HashSet <VCExprOp>(); booleanOps.Add(VCExpressionGenerator.NotOp); booleanOps.Add(VCExpressionGenerator.ImpliesOp); booleanOps.Add(VCExpressionGenerator.AndOp); booleanOps.Add(VCExpressionGenerator.OrOp); if (booleanOps.Contains(op)) { Stack <VCExpr> exprs = new Stack <VCExpr>(); exprs.Push(node); while (exprs.Count > 0) { VCExpr expr = exprs.Pop(); if (expr == null) { wr.Write(")"); continue; } wr.Write(" "); VCExprNAry naryExpr = expr as VCExprNAry; if (naryExpr == null || !booleanOps.Contains(naryExpr.Op)) { Linearise(expr, options); continue; } else if (naryExpr.Op.Equals(VCExpressionGenerator.NotOp)) { wr.Write("(not"); } else if (naryExpr.Op.Equals(VCExpressionGenerator.ImpliesOp)) { wr.Write("(=>"); } else if (naryExpr.Op.Equals(VCExpressionGenerator.AndOp)) { wr.Write("(and"); } else { System.Diagnostics.Debug.Assert(naryExpr.Op.Equals(VCExpressionGenerator.OrOp)); wr.Write("(or"); } exprs.Push(null); for (int i = naryExpr.Arity - 1; i >= 0; i--) { exprs.Push(naryExpr[i]); } } return(true); } if (OptimizationRequests != null && (node.Op.Equals(VCExpressionGenerator.MinimizeOp) || node.Op.Equals(VCExpressionGenerator.MaximizeOp))) { string optOp = node.Op.Equals(VCExpressionGenerator.MinimizeOp) ? "minimize" : "maximize"; OptimizationRequests.Add(string.Format("({0} {1})", optOp, ToString(node[0], Namer, ProverOptions, NamedAssumes))); Linearise(node[1], options); return(true); } if (node.Op is VCExprSoftOp) { Linearise(node[1], options); return(true); } if (node.Op.Equals(VCExpressionGenerator.NamedAssumeOp)) { var exprVar = node[0] as VCExprVar; NamedAssumes.Add(exprVar); Linearise(node[1], options); return(true); } return(node.Accept <bool, LineariserOptions /*!*/>(OpLineariser, options)); }
public void ComputeSize(VCExpr expr, IDictionary<VCExprVar /*!*/, VCExprVar /*!*/> /*!*/ globalVars) { Contract.Requires(expr != null); Contract.Requires(cce.NonNullDictionaryAndValues(globalVars)); Traverse(expr, globalVars); }
public void Linearise(VCExpr expr, LineariserOptions options) { Contract.Requires(expr != null); Contract.Requires(options != null); expr.Accept <bool, LineariserOptions>(this, options); }
//////////////////////////////////////////////////////////////////////////// private void AddAxiom(VCExpr axiom) { Contract.Requires(axiom != null); if (axiom.Equals(VCExpressionGenerator.True)) return; AllAxioms.Add(axiom); IncAxioms.Add(axiom); }
public override void AddAxiom(VCExpr vc) { //Contract.Requires(vc != null); axiomConjuncts.Add(vc); }
private Model.Element getValue(VCExpr arg, Model model) { if (arg is VCExprLiteral) { //return model.GetElement(arg.ToString()); return model.MkElement(arg.ToString()); } else if (arg is VCExprVar) { var el = model.TryGetFunc(prover.Context.Lookup(arg as VCExprVar)); if (el != null) { Debug.Assert(el.Arity == 0 && el.AppCount == 1); return el.Apps.First().Result; } else { // Variable not defined; assign arbitrary value if (arg.Type.IsBool) return model.MkElement("false"); else if (arg.Type.IsInt) return model.MkIntElement(0); else return null; } } else if (arg is VCExprNAry && (arg as VCExprNAry).Op is VCExprBvOp) { // support for BV constants var bvc = (arg as VCExprNAry)[0] as VCExprLiteral; if (bvc != null) { var ret = model.TryMkElement(bvc.ToString() + arg.Type.ToString()); if (ret != null && (ret is Model.BitVector)) return ret; } } var val = prover.Evaluate(arg); if (val is int || val is bool || val is Microsoft.Basetypes.BigNum) { return model.MkElement(val.ToString()); } else { Debug.Assert(false); } return null; }
////////////////////// // For interpolation queries ////////////////////// // Assert vc tagged with a name public virtual void AssertNamed(VCExpr vc, bool polarity, string name) { throw new NotImplementedException(); }
public override void AddAxiom(VCExpr vc) { }
// Returns Interpolant(A,B) public virtual VCExpr ComputeInterpolant(VCExpr A, VCExpr B) { throw new NotImplementedException(); }
private VCExpr Execute(Implementation impl, VCExpr vcExpr) { impl.Blocks.ForEach(block => block.Cmds.OfType <PredicateCmd>().Iter(predicateCmd => { AddDictionary(FindInstantiationSources(predicateCmd, "add_to_pool", exprTranslator), labelToInstances); })); vcExpr = Skolemizer.Skolemize(this, Polarity.Negative, vcExpr); lambdaToInstances = LambdaInstanceCollector.CollectInstances(this, vcExpr); while (labelToInstances.Count > 0) { var currLabelToInstances = labelToInstances; labelToInstances = new Dictionary <string, HashSet <VCExpr> >(); AddDictionary(currLabelToInstances, accLabelToInstances); var currLambdaToInstances = lambdaToInstances; lambdaToInstances = new Dictionary <Function, HashSet <List <VCExpr> > >(); AddDictionary(currLambdaToInstances, accLambdaToInstances); var visitedQuantifierBindings = new HashSet <VCExprVar>(); while (visitedQuantifierBindings.Count < quantifierBinding.Count) { foreach (var v in quantifierBinding.Keys) { if (visitedQuantifierBindings.Contains(v)) { continue; } visitedQuantifierBindings.Add(v); var quantifierExpr = quantifierBinding[v]; var quantifierInfo = quantifierInstantiationInfo[quantifierExpr]; if (quantifierInfo.relevantLabels.Overlaps(currLabelToInstances.Keys)) { InstantiateQuantifier(quantifierExpr); } } } var visitedLambdaFunctions = new HashSet <Function>(); while (visitedLambdaFunctions.Count < lambdaDefinition.Count) { foreach (var lambdaFunction in lambdaDefinition.Keys) { if (visitedLambdaFunctions.Contains(lambdaFunction)) { continue; } visitedLambdaFunctions.Add(lambdaFunction); var quantifierExpr = lambdaDefinition[lambdaFunction]; var quantifierInfo = quantifierInstantiationInfo[quantifierExpr]; if (quantifierInfo.relevantLabels.Overlaps(currLabelToInstances.Keys) || currLambdaToInstances[lambdaFunction].Count > 0) { InstantiateLambdaDefinition(lambdaFunction); } } } } var lambdaAxioms = vcExprGen.NAry(VCExpressionGenerator.AndOp, lambdaDefinition.Values .SelectMany(quantifierExpr => quantifierInstantiationInfo[quantifierExpr].instances.Values.ToList()).ToList()); return(vcExprGen.Implies(lambdaAxioms, LetConvert(vcExpr))); }
public static VCExpr Instantiate(Implementation impl, VCExpressionGenerator vcExprGen, Boogie2VCExprTranslator exprTranslator, VCExpr vcExpr) { if (!InstantiationSourceChecker.HasInstantiationSources(impl)) { return(vcExpr); } var qiEngine = new QuantifierInstantiationEngine(vcExprGen, exprTranslator); return(qiEngine.Execute(impl, vcExpr)); }
public virtual string VCExpressionToString(VCExpr vc) { Contract.Requires(vc != null); Contract.Ensures(Contract.Result<string>() != null); throw new NotImplementedException(); }
protected override Dictionary <VCExprVar, Polarity> StandardResult(VCExpr node, Polarity arg) { return(null); }
/////////////////////////////////////////////////////////////////////////// // The normal axioms of the theory of arrays (without extensionality) /*!*/ private VCExpr Select(Function/*!*/ select, // in general, the select function has to // receive explicit type parameters (which // are here already represented as VCExpr // of type T) List<VCExpr/*!*/>/*!*/ typeParams, VCExpr/*!*/ map, List<VCExprVar/*!*/>/*!*/ indexes) { Contract.Requires(select != null); Contract.Requires(cce.NonNullElements(typeParams)); Contract.Requires(map != null); Contract.Requires(cce.NonNullElements(indexes)); Contract.Ensures(Contract.Result<VCExpr>() != null); List<VCExpr/*!*/>/*!*/ selectArgs = new List<VCExpr/*!*/>(typeParams.Count + indexes.Count + 1); selectArgs.AddRange(typeParams); selectArgs.Add(map); selectArgs.AddRange(HelperFuns.ToVCExprList(indexes)); return Gen.Function(select, selectArgs); }
/* * The method Skolemize performs best-effort skolemization of the input expression expr. * If polarity == Polarity.Negative, a quantifier F embedded in expr is skolemized * provided it can be proved that F is a forall quantifier in the NNF version of expr. * If polarity == Polarity.Positive, a quantifier F embedded in expr is skolemized * provided it can be proved that F is an exists quantifier in the NNF version of expr. * * Factorization is performed on the resulting expression. */ public static VCExpr Skolemize(QuantifierInstantiationEngine qiEngine, Polarity polarity, VCExpr vcExpr) { var skolemizer = new Skolemizer(qiEngine, polarity, vcExpr); var skolemizedExpr = skolemizer.Mutate(vcExpr, true); return(Factorizer.Factorize(qiEngine, QuantifierCollector.Flip(polarity), skolemizedExpr)); }
/*!*/ public VCExpr AddTypePremisses(List<VCExprLetBinding/*!*/>/*!*/ typeVarBindings, VCExpr/*!*/ typePremisses, bool universal, VCExpr/*!*/ body) { Contract.Requires(cce.NonNullElements(typeVarBindings)); Contract.Requires(typePremisses != null); Contract.Requires(body != null); Contract.Ensures(Contract.Result<VCExpr>() != null); VCExpr/*!*/ bodyWithPremisses; if (universal) bodyWithPremisses = Gen.ImpliesSimp(typePremisses, body); else bodyWithPremisses = Gen.AndSimp(typePremisses, body); return Gen.Let(typeVarBindings, bodyWithPremisses); }
private Skolemizer(QuantifierInstantiationEngine qiEngine, Polarity polarity, VCExpr vcExpr) : base(qiEngine.vcExprGen) { this.qiEngine = qiEngine; this.quantifiers = QuantifierCollector.CollectQuantifiers(vcExpr, polarity); this.bound = new Dictionary <VCExprVar, VCExpr>(); }
private void TypeVarExtractors(TypeVariable var, Type completeType, VCExpr innerTerm, List<VCExpr/*!*/>/*!*/ extractors) { Contract.Requires(innerTerm != null); Contract.Requires(completeType != null); Contract.Requires(var != null); Contract.Requires(cce.NonNullElements(extractors)); if (completeType.IsVariable) { if (var.Equals(completeType)) { extractors.Add(innerTerm); } // else nothing } else if (completeType.IsBasic) { // nothing } else if (completeType.IsCtor) { CtorType/*!*/ ctorType = completeType.AsCtor; if (ctorType.Arguments.Count > 0) { // otherwise there are no chances of extracting any // instantiations from this type TypeCtorRepr repr = GetTypeCtorReprStruct(ctorType.Decl); for (int i = 0; i < ctorType.Arguments.Count; ++i) { VCExpr/*!*/ newInnerTerm = Gen.Function(repr.Dtors[i], innerTerm); Contract.Assert(newInnerTerm != null); TypeVarExtractors(var, ctorType.Arguments[i], newInnerTerm, extractors); } } } else if (completeType.IsMap) { TypeVarExtractors(var, MapTypeAbstracter.AbstractMapType(completeType.AsMap), innerTerm, extractors); } else { System.Diagnostics.Debug.Fail("Don't know how to handle this type: " + completeType); } }
public static VCExpr Factorize(QuantifierInstantiationEngine qiEngine, Polarity polarity, VCExpr vcExpr) { var factorizer = new Factorizer(qiEngine, polarity, vcExpr); return(factorizer.Mutate(vcExpr, true)); }
private Factorizer(QuantifierInstantiationEngine qiEngine, Polarity polarity, VCExpr vcExpr) : base(qiEngine.vcExprGen) { this.qiEngine = qiEngine; this.quantifiers = QuantifierCollector.CollectQuantifiers(vcExpr, polarity); }
public static HashSet <VCExprVar> CollectBindings(QuantifierInstantiationEngine qiEngine, VCExpr vcExpr) { var bindingCollector = new BindingCollector(qiEngine); bindingCollector.Traverse(vcExpr, true); return(bindingCollector.bindings); }
public override string translate(VCExpr expr, int polarity) { Contract.Requires(expr != null); Contract.Ensures(Contract.Result<string>() != null); throw new NotImplementedException(); }
public static Dictionary <Function, HashSet <List <VCExpr> > > CollectInstances(QuantifierInstantiationEngine qiEngine, VCExpr vcExpr) { var lambdaInstanceCollector = new LambdaInstanceCollector(qiEngine); lambdaInstanceCollector.Traverse(vcExpr, true); var lambdaFunctionToInstances = lambdaInstanceCollector.lambdaFunctions.ToDictionary( x => x, x => new HashSet <List <VCExpr> >(new ListComparer <VCExpr>())); foreach (var instance in lambdaInstanceCollector.instances) { var function = (instance.Op as VCExprBoogieFunctionOp).Func; lambdaFunctionToInstances[function].Add(instance.UniformArguments.ToList()); } return(lambdaFunctionToInstances); }