Ejemplo n.º 1
0
    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();
      }
    }
Ejemplo n.º 2
0
 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;
 }
Ejemplo n.º 3
0
 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);
 }
Ejemplo n.º 4
0
 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();
 }
Ejemplo n.º 5
0
 public abstract void AddAxiom(VCExpr vc);
Ejemplo n.º 6
0
 public VCExpr TypeOf(VCExpr expr)
 {
     Contract.Requires(expr != null);
       Contract.Ensures(Contract.Result<VCExpr>() != null);
       return Gen.Function(TypeFunction, expr);
 }
Ejemplo n.º 7
0
 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();
 }
Ejemplo n.º 8
0
 public virtual void DefineMacro(Macro fun, VCExpr vc)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 9
0
 // (assert vc)
 public virtual void Assert(VCExpr vc, bool polarity)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 10
0
 // (assert vc)
 public virtual void Assert(VCExpr vc, bool polarity, bool isSoft = false, int weight = 1)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 11
0
 /// <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);
     }
Ejemplo n.º 13
0
 public void Print(VCExpr expr, TextWriter wr)
 {
     Contract.Requires(wr != null);
     Contract.Requires(expr != null);
     expr.Accept <bool, TextWriter /*!*/>(this, wr);
 }
Ejemplo n.º 14
0
        /// <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
            }
        }
Ejemplo n.º 15
0
        /// <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
            }
        }
Ejemplo n.º 16
0
    ////////////////////////////////////////////////////////////////////////////

    protected override bool StandardResult(VCExpr node, bool arg)
    {
      //Contract.Requires(node != null);
      return false; // by default, do not collect terms containing node
    }
Ejemplo n.º 17
0
 public void Initialize(VCExpr evc) {
   Contract.Requires(evc != null);
     m_Checker.PushVCExpr(evc);
 }
Ejemplo n.º 18
0
 public abstract void BeginCheck(string descriptiveName, VCExpr vc, ErrorHandler handler);
Ejemplo n.º 19
0
        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);
        }
Ejemplo n.º 20
0
 /// <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();
 }
Ejemplo n.º 21
0
 public abstract void BeginCheck(string descriptiveName, VCExpr vc, ErrorHandler handler);
Ejemplo n.º 22
0
 public virtual string VCExpressionToString(VCExpr vc)
 {
     Contract.Requires(vc != null);
     Contract.Ensures(Contract.Result <string>() != null);
     throw new NotImplementedException();
 }
Ejemplo n.º 23
0
 /// <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();
 }
Ejemplo n.º 24
0
 // (assert vc)
 public virtual void Assert(VCExpr vc, bool polarity, bool isSoft = false, int weight = 1, string name = null)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 25
0
 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);
 }
Ejemplo n.º 26
0
 public virtual void DefineMacro(Macro fun, VCExpr vc)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 27
0
        // 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;
        }
Ejemplo n.º 28
0
 public virtual object Evaluate(VCExpr expr)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 29
0
 public abstract string translate(VCExpr expr, int polarity);
Ejemplo n.º 30
0
 // 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);
 }
Ejemplo n.º 32
0
        /////////////////////////////////////////////////////////////////////////////////////

        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));
        }
Ejemplo n.º 33
0
 public void ComputeSize(VCExpr expr, IDictionary<VCExprVar /*!*/, VCExprVar /*!*/> /*!*/ globalVars)
 {
   Contract.Requires(expr != null);
   Contract.Requires(cce.NonNullDictionaryAndValues(globalVars));
   Traverse(expr, globalVars);
 }
Ejemplo n.º 34
0
 public void Linearise(VCExpr expr, LineariserOptions options)
 {
     Contract.Requires(expr != null);
     Contract.Requires(options != null);
     expr.Accept <bool, LineariserOptions>(this, options);
 }
Ejemplo n.º 35
0
    ////////////////////////////////////////////////////////////////////////////


    private void AddAxiom(VCExpr axiom) {
      Contract.Requires(axiom != null);
      if (axiom.Equals(VCExpressionGenerator.True))
        return;
      AllAxioms.Add(axiom);
      IncAxioms.Add(axiom);
    }
Ejemplo n.º 36
0
 public override void AddAxiom(VCExpr vc)
 {
     //Contract.Requires(vc != null);
     axiomConjuncts.Add(vc);
 }
Ejemplo n.º 37
0
        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;
        }
Ejemplo n.º 38
0
 public abstract string translate(VCExpr expr, int polarity);
Ejemplo n.º 39
0
 /// <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);
 }
Ejemplo n.º 40
0
 public abstract void AddAxiom(VCExpr vc);
Ejemplo n.º 41
0
 //////////////////////
 // For interpolation queries
 //////////////////////
 // Assert vc tagged with a name
 public virtual void AssertNamed(VCExpr vc, bool polarity, string name)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 42
0
 public override void AddAxiom(VCExpr vc)
 {
 }
Ejemplo n.º 43
0
 // 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)));
        }
Ejemplo n.º 45
0
 public virtual object Evaluate(VCExpr expr)
 {
     throw new NotImplementedException();
 }
        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));
        }
Ejemplo n.º 47
0
 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);
 }
Ejemplo n.º 49
0
        ///////////////////////////////////////////////////////////////////////////
        // 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));
        }
Ejemplo n.º 51
0
        /*!*/
        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>();
 }
Ejemplo n.º 53
0
 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));
        }
Ejemplo n.º 55
0
 public override void AddAxiom(VCExpr vc)
 {
     //Contract.Requires(vc != null);
       axiomConjuncts.Add(vc);
 }
 private Factorizer(QuantifierInstantiationEngine qiEngine, Polarity polarity, VCExpr vcExpr) : base(qiEngine.vcExprGen)
 {
     this.qiEngine    = qiEngine;
     this.quantifiers = QuantifierCollector.CollectQuantifiers(vcExpr, polarity);
 }
Ejemplo n.º 57
0
 public override void AddAxiom(VCExpr vc)
 {
 }
        public static HashSet <VCExprVar> CollectBindings(QuantifierInstantiationEngine qiEngine, VCExpr vcExpr)
        {
            var bindingCollector = new BindingCollector(qiEngine);

            bindingCollector.Traverse(vcExpr, true);
            return(bindingCollector.bindings);
        }
Ejemplo n.º 59
0
        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);
        }