Esempio n. 1
0
            private void AddBoundVariablesForRemainingVars()
            {
                var remainingVars = NotEliminatedVars.Except(IntermediateFrameWithWitnesses);

                existsVarMap = new Dictionary <Variable, BoundVariable>();
                foreach (var v in remainingVars)
                {
                    existsVarMap[v] = new BoundVariable(Token.NoToken,
                                                        new TypedIdent(Token.NoToken, v.Name, v.TypedIdent.Type));
                }
                var varMap   = existsVarMap.ToDictionary(kvp => kvp.Key, kvp => Expr.Ident(kvp.Value) as Expr);
                var varSubst = Substituter.SubstitutionFromHashtable(varMap);

                pathExprs = pathExprs.Select(x => Substituter.Apply(varSubst, x)).ToList();
            }
Esempio n. 2
0
            private void ComputeWitnessedTransitionRelationExprs()
            {
                witnessedTransitionRelations = new List <Expr>();
                Dictionary <Variable, List <WitnessFunction> > varToWitnesses = FrameWithWitnesses.
                                                                                Where(x => NotEliminatedVars.Contains(frameIntermediateCopy[x])).
                                                                                ToDictionary(
                    x => frameIntermediateCopy[x],
                    x => transitionRelationComputer.globalVarToWitnesses[(GlobalVariable)x]);

                foreach (var witnessSet in varToWitnesses.Values.CartesianProduct())
                {
                    Dictionary <Variable, Expr> witnessSubst = new Dictionary <Variable, Expr>();
                    foreach (Tuple <Variable, WitnessFunction> pair in
                             Enumerable.Zip(varToWitnesses.Keys, witnessSet, Tuple.Create))
                    {
                        WitnessFunction witnessFunction = pair.Item2;
                        List <Expr>     args            = new List <Expr>();
                        foreach (var arg in witnessFunction.InputArgs)
                        {
                            Expr expr = null;
                            switch (arg.Kind)
                            {
                            case WitnessFunction.InputArgumentKind.FIRST_ARG:
                                // TODO: Add note on the reason of using second
                                expr = Expr.Ident(second.Params.
                                                  First(x => x.Name == second.Prefix + arg.Name));
                                break;

                            case WitnessFunction.InputArgumentKind.SECOND_ARG:
                                expr = Expr.Ident(first.Params.
                                                  First(x => x.Name == first.Prefix + arg.Name));
                                break;

                            case WitnessFunction.InputArgumentKind.PRE_STATE:
                                expr = ExprHelper.Old(Expr.Ident(
                                                          frame.First(x => x.Name == arg.Name)));
                                break;

                            case WitnessFunction.InputArgumentKind.POST_STATE:
                                expr = Expr.Ident(frame.First(x => x.Name == arg.Name));
                                break;

                            default:
                                Debug.Assert(false);
                                break;
                            }
                            args.Add(expr);
                        }
                        witnessSubst[pair.Item1] = ExprHelper.FunctionCall(
                            witnessFunction.function, args.ToArray()
                            );
                    }
                    var subst = Substituter.SubstitutionFromHashtable(witnessSubst);
                    witnessedTransitionRelations.Add(
                        Substituter.Apply(subst, TransitionRelationExpr));
                }
            }