public override void OnModel(IList<string>/*!>!*/ labels, Model model) { // TODO: it would be better to check which reachability variables are actually set to one! List<Block> traceNodes = new List<Block>(); List<AssertCmd> assertNodes = new List<AssertCmd>(); foreach (string s in labels) { Contract.Assert(s != null); Absy node = Label2Absy(s); if (node is Block) { Block b = (Block)node; traceNodes.Add(b); //Console.Write("{0}, ", b.Label); } } m_CurrentTrace.AddRange(traceNodes); }
private Model.Element GetModelValue(Model m, Variable v, Dictionary<string,string> subst) { // first, get the unique name string uniqueName; VCExprVar vvar = boogieContext.BoogieExprTranslator.TryLookupVariable(v); uniqueName = v.Name; if(subst.ContainsKey(uniqueName)) return m.MkElement(subst[uniqueName]); return m.MkFunc("@undefined", 0).GetConstant(); }
public override void OnModel(IList<string> labels, Model model) { Debug.Assert(model != null); if(CommandLineOptions.Clo.PrintErrorModel >= 1) model.Write(Console.Out); this.model = model; }
public MLHoudiniErrorReporter() { model = null; }
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; }
private List<Tuple<string, List<Model.Element>>> ExtractState(string impl, Expr expr, Model model) { var funcsUsed = FunctionCollector.Collect(expr); var ret = new List<Tuple<string, List<Model.Element>>>(); foreach (var tup in funcsUsed.Where(t => t.Item2 == null)) { var constant = tup.Item1; if (!constant2FuncCall.ContainsKey(constant.Name)) continue; var func = constant2FuncCall[constant.Name]; var funcName = (func.Fun as FunctionCall).FunctionName; var vals = new List<Model.Element>(); prover.Context.BoogieExprTranslator.Translate(func.Args).Iter(ve => vals.Add(getValue(ve, model))); ret.Add(Tuple.Create(funcName, vals)); } foreach (var tup in funcsUsed.Where(t => t.Item2 != null)) { var constant = tup.Item1; var boundExpr = tup.Item2; if (!constant2FuncCall.ContainsKey(constant.Name)) continue; // There are some bound variables (because the existential function was inside an \exists). // We must find an assignment for bound varibles // First, peice apart the existential functions var cd = new Duplicator(); var tup2 = ExistentialExprModelMassage.Massage(cd.VisitExpr(boundExpr.Body)); var be = tup2.Item1; Expr env = Expr.True; foreach (var ahFunc in tup2.Item2) { var tup3 = impl2FuncCalls[impl].First(t => t.Item2.Name == ahFunc.Name); var varList = new List<Expr>(); tup3.Item3.Args.OfType<Expr>().Iter(v => varList.Add(v)); env = Expr.And(env, function2Value[tup3.Item1].Gamma(varList)); } be = Expr.And(be, Expr.Not(env)); // map formals to constants var formalToConstant = new Dictionary<string, Constant>(); foreach (var f in boundExpr.Dummies.OfType<Variable>()) formalToConstant.Add(f.Name, new Constant(Token.NoToken, new TypedIdent(Token.NoToken, f.Name + "@subst@" + (existentialConstCounter++), f.TypedIdent.Type), false)); be = Substituter.Apply(new Substitution(v => formalToConstant.ContainsKey(v.Name) ? Expr.Ident(formalToConstant[v.Name]) : Expr.Ident(v)), be); formalToConstant.Values.Iter(v => prover.Context.DeclareConstant(v, false, null)); var reporter = new MLHoudiniErrorReporter(); var ve = prover.Context.BoogieExprTranslator.Translate(be); prover.Assert(ve, true); prover.Check(); var proverOutcome = prover.CheckOutcomeCore(reporter); if (proverOutcome != ProverInterface.Outcome.Invalid) continue; model = reporter.model; var func = constant2FuncCall[constant.Name]; var funcName = (func.Fun as FunctionCall).FunctionName; var vals = new List<Model.Element>(); foreach (var funcArg in func.Args.OfType<Expr>()) { var arg = Substituter.Apply(new Substitution(v => formalToConstant.ContainsKey(v.Name) ? Expr.Ident(formalToConstant[v.Name]) : Expr.Ident(v)), funcArg); vals.Add(getValue(prover.Context.BoogieExprTranslator.Translate(arg), model)); } ret.Add(Tuple.Create(funcName, vals)); } return ret; }
internal BitVector(Model p, string n, int sz) : base(p, n) { Size = sz; }
public virtual void OnModel(IList<string> labels, Model model, Outcome proverOutcome) { Contract.Requires(cce.NonNullElements(labels)); }
internal Uninterpreted(Model p, string n) : base(p) { Name = n; }
protected Element(Model p) { Model = p; Id = Model.elements.Count; }
internal Func(Model p, string n, int a) { Model = p; Name = n; Arity = a; }
internal DatatypeValue(Model p, string name, List<Element> args) : base(p) { ConstructorName = name; Arguments = args.ToArray(); }
internal Array(Model p, Func v) : base(p) { Value = v; }
internal Boolean(Model p, bool v) : base(p) { Value = v; }
private void GetModelWithStates(Model m, RPFP.Node cex, StratifiedInliningInfo mainInfo, List<StateId> orderedStateIds, Dictionary<int,Dictionary<string,string>> varSubst) { if (m == null) return; var mvInfo = mainInfo.mvInfo; foreach (Variable v in mvInfo.AllVariables) { m.InitialState.AddBinding(v.Name, GetModelValue(m, v, varSubst[cex.Outgoing.number])); } Dictionary<int, RPFP.Edge> edgeNumbering = new Dictionary<int,RPFP.Edge>(); NumberCexEdges(cex, edgeNumbering); int lastCandidate = 0; int lastCapturePoint = CALL; for (int i = 0; i < orderedStateIds.Count; ++i) { var s = orderedStateIds[i]; RPFP.Edge edge = s.edge; int candidate = edge.number; int capturePoint = s.capturePoint; Dictionary<string, string> subst = varSubst[candidate]; string implName = edge.Parent.Name.GetDeclName(); var info = s.info.mvInfo; if (capturePoint == CALL || capturePoint == RETURN) { lastCandidate = candidate; lastCapturePoint = capturePoint; continue; } Contract.Assume(0 <= capturePoint && capturePoint < info.CapturePoints.Count); VC.ModelViewInfo.Mapping map = info.CapturePoints[capturePoint]; var prevInc = (lastCapturePoint != CALL && lastCapturePoint != RETURN && candidate == lastCandidate) ? info.CapturePoints[lastCapturePoint].IncarnationMap : new Dictionary<Variable, Expr>(); var cs = m.MkState(map.Description); foreach (Variable v in info.AllVariables) { var e = (Expr)map.IncarnationMap[v]; if (e == null) { if (lastCapturePoint == CALL || lastCapturePoint == RETURN) { cs.AddBinding(v.Name, GetModelValue(m, v, subst)); } continue; } if (lastCapturePoint != CALL && lastCapturePoint != RETURN && prevInc[v] == e) continue; // skip unchanged variables Model.Element elt; if (e is IdentifierExpr) { IdentifierExpr ide = (IdentifierExpr)e; elt = GetModelValue(m, ide.Decl, subst); } else if (e is LiteralExpr) { LiteralExpr lit = (LiteralExpr)e; elt = m.MkElement(lit.Val.ToString()); } else { Contract.Assume(false); elt = m.MkFunc(e.ToString(), 0).GetConstant(); } cs.AddBinding(v.Name, elt); } lastCandidate = candidate; lastCapturePoint = capturePoint; } return; }
/** Set the model of the background theory used in a counterexample. */ public void SetBackgroundModel(Model m) { dualModel = m; }
protected Number(Model p, string n) : base(p) { Numeral = n; }
protected void NewModel() { lastLine = ""; currModel = new Model (); resModels.Add (currModel); }
internal Integer(Model p, string n) : base(p, n) { }