private Term SubstPredsRec(TermDict <Term> memo, Dictionary <FuncDecl, FuncDecl> subst, Term t)
{
Term res;
if (memo.TryGetValue(t, out res))
{
return(res);
}
if (t.GetKind() == TermKind.App)
{
var args = t.GetAppArgs();
args = args.Select(x => SubstPredsRec(memo, subst, x)).ToArray();
FuncDecl nf = null;
var f = t.GetAppDecl();
if (subst.TryGetValue(f, out nf))
{
res = ctx.MkApp(nf, args);
}
else
{
res = ctx.CloneApp(t, args);
}
} // TODO: handle quantifiers
else
{
res = t;
}
memo.Add(t, res);
return(res);
}
private Term Doit(Term t)
{
VCExprVar v;
if (bindingMap.TryGetValue(t, out v))
{
return(v);
}
Term res = null;
var kind = t.GetKind();
bool letok = false;
if (kind == TermKind.App)
{
var f = t.GetAppDecl();
var args = t.GetAppArgs();
args = args.Select(x => Doit(x)).ToArray();
res = ctx.MkApp(f, args);
letok = true;
}
else if (t is VCExprQuantifier)
{
var q = t as VCExprQuantifier;
var newbody = ctx.Letify(q.Body);
if (q.Quan == Quantifier.ALL)
{
res = ctx.Forall(q.BoundVars, q.Triggers, newbody);
}
else
{
res = ctx.Exists(q.BoundVars, q.Triggers, newbody);
}
letok = true;
}
else
{
res = t;
}
if (letok && refcnt[t].cnt > 1)
{
VCExprVar lv = ctx.MkConst("fpvc$" + Convert.ToString(letcnt), t.GetSort()) as VCExprVar;
VCExprLetBinding b = ctx.LetBinding(lv, res);
bindings.Add(b);
bindingMap.Add(t, lv);
res = lv;
letcnt++;
}
return(res);
}
public Term CloneApp(Term t, Term[] args)
{
var f = t.GetAppDecl();
var typeArgs = (t as VCExprNAry).TypeArguments;
if (typeArgs != null && typeArgs.Count > 0)
{
return(MkApp(f, args, typeArgs.ToArray()));
}
else
{
return(MkApp(f, args));
}
}
/** Create a node in the graph. The input is a term R(v_1...v_n)
* where R is an arbitrary relational symbol and v_1...v_n are
* arbitary distinct variables. The names are only of mnemonic value,
* however, the number and type of arguments determine the type
* of the relation at this node. */
public Node CreateNode(Term t)
{
Node n = new Node();
// Microsoft.Boogie.VCExprAST.VCExprNAry tn = t as Microsoft.Boogie.VCExprAST.VCExprNAry;
// Term[] _IndParams = tn.ToArray();
Term[] _IndParams = t.GetAppArgs();
FuncDecl Name = t.GetAppDecl();
n.Annotation = CreateRelation(_IndParams, ctx.MkTrue());
n.Bound = CreateRelation(_IndParams, ctx.MkTrue());
n.owner = this;
n.number = ++nodeCount;
n.Name = Name; // just to have a unique name
n.Incoming = new List <Edge>();
return(n);
}
private Node GetNodeFromClause(Term t, FuncDecl failName)
{
Term[] args = t.GetAppArgs();
Term body = args[0];
Term head = args[1];
FuncDecl Name;
Term[] _IndParams;
bool is_query = false;
if (head.Equals(ctx.MkFalse()))
{
Name = failName;
is_query = true;
_IndParams = new Term[0];
}
else
{
Name = head.GetAppDecl();
_IndParams = head.GetAppArgs();
}
if (relationToNode.ContainsKey(Name))
{
return(null);
}
for (int i = 0; i < _IndParams.Length; i++)
{
if (!IsVariable(_IndParams[i]))
{
Term v = ctx.MkConst("@a" + i.ToString(), _IndParams[i].GetSort());
_IndParams[i] = v;
}
}
Term foo = ctx.MkApp(Name, _IndParams);
Node node = CreateNode(foo);
relationToNode[Name] = node;
if (is_query)
{
node.Bound = CreateRelation(new Term[0], ctx.MkFalse());
}
return(node);
}
private Edge GetEdgeFromClause(Term t, FuncDecl failName)
{
Term[] args = t.GetAppArgs();
Term body = args[0];
Term head = args[1];
Term[] _IndParams;
FuncDecl Name;
if (head.IsFalse())
{
Name = failName;
_IndParams = new Term[0];
}
else
{
_IndParams = head.GetAppArgs();
Name = head.GetAppDecl();
}
for (int i = 0; i < _IndParams.Length; i++)
{
if (!IsVariable(_IndParams[i]))
{
Term v = ctx.MkConst("@a" + i.ToString(), _IndParams[i].GetSort());
body = ctx.MkAnd(body, ctx.MkEq(v, _IndParams[i]));
_IndParams[i] = v;
}
}
var relParams = new List <FuncDecl>();
var nodeParams = new List <RPFP.Node>();
var memo = new TermDict <Term>();
var done = new Dictionary <Term, Term>(); // note this hashes on equality, not reference!
body = CollectParamsRec(memo, body, relParams, nodeParams, done);
Transformer F = CreateTransformer(relParams.ToArray(), _IndParams, body);
Node parent = relationToNode[Name];
return(CreateEdge(parent, F, nodeParams.ToArray()));
}
private Term CollectParamsRec(TermDict <Term> memo, Term t, List <FuncDecl> parms, List <RPFP.Node> nodes,
Dictionary <Term, Term> done)
{
Term res;
if (memo.TryGetValue(t, out res))
{
return(res);
}
if (t.GetKind() == TermKind.App)
{
var f = t.GetAppDecl();
Node node;
if (relationToNode.TryGetValue(f, out node))
{
if (done.ContainsKey(t))
{
res = done[t];
}
else
{
f = SuffixFuncDecl(t, parms.Count);
parms.Add(f);
nodes.Add(node);
done.Add(t, res); // don't count same expression twice!
}
}
var args = t.GetAppArgs();
args = args.Select(x => CollectParamsRec(memo, x, parms, nodes, done)).ToArray();
res = ctx.CloneApp(t, args);
} // TODO: handle quantifiers
else
{
res = t;
}
memo.Add(t, res);
return(res);
}
// This returns a new FuncDel with same sort as top-level function
// of term t, but with numeric suffix appended to name.
private FuncDecl SuffixFuncDecl(Term t, int n)
{
var name = t.GetAppDecl().GetDeclName() + "_" + n.ToString();
return(ctx.MkFuncDecl(name, t.GetAppDecl()));
}
// This returns a new FuncDel with same sort as top-level function
// of term t, but with numeric suffix appended to name.
private FuncDecl SuffixFuncDecl(Term t, int n)
{
var name = t.GetAppDecl().GetDeclName() + "_" + n.ToString();
return ctx.MkFuncDecl(name, t.GetAppDecl());
}
private Term SubstPredsRec(TermDict< Term> memo, Dictionary<FuncDecl,FuncDecl> subst, Term t)
{
Term res;
if (memo.TryGetValue(t, out res))
return res;
if (t.GetKind() == TermKind.App)
{
var args = t.GetAppArgs();
args = args.Select(x => SubstPredsRec(memo,subst,x)).ToArray();
FuncDecl nf = null;
var f = t.GetAppDecl();
if (subst.TryGetValue(f, out nf))
{
res = ctx.MkApp(nf, args);
}
else
{
res = ctx.CloneApp(t, args);
}
} // TODO: handle quantifiers
else
res = t;
memo.Add(t, res);
return res;
}
private Term MergeGoalsRec(TermDict< Term> memo, Term t)
{
Term res;
if (memo.TryGetValue(t, out res))
return res;
var kind = t.GetKind();
if (kind == TermKind.App)
{
var f = t.GetAppDecl();
var args = t.GetAppArgs();
if (f.GetKind() == DeclKind.Implies)
{
res = ctx.MkImplies(args[0], MergeGoalsRec(memo, args[1]));
goto done;
}
else if (f.GetKind() == DeclKind.And)
{
args = args.Select(x => MergeGoalsRec(memo, x)).ToArray();
res = ctx.MkApp(f, args);
goto done;
}
else if (f.GetKind() == DeclKind.Label)
{
var arg = t.GetAppArgs()[0];
var r = arg.GetAppDecl();
if (r.GetKind() == DeclKind.Uninterpreted)
{
res = NormalizeGoal(arg, f);
goto done;
}
}
}
res = t;
done:
memo.Add(t, res);
return res;
}
public static bool IsFunctionApp(this Term t)
{
return(t.GetKind() == TermKind.App && t.GetAppDecl().GetKind() == DeclKind.Uninterpreted);
}
private Term ExtractSmallerVCsRec(TermDict< Term> memo, Term t, List<Term> small, Term lbl = null)
{
Term res;
if (memo.TryGetValue(t, out res))
return res;
var kind = t.GetKind();
if (kind == TermKind.App)
{
var f = t.GetAppDecl();
if (f.GetKind() == DeclKind.Implies){
var lhs = t.GetAppArgs()[0];
if(lhs.GetKind() == TermKind.App){
var r = lhs.GetAppDecl();
if (r.GetKind() == DeclKind.And)
{
Term q = t.GetAppArgs()[1];
var lhsargs = lhs.GetAppArgs();
for (int i = lhsargs.Length-1; i >= 0; --i)
{
q = ctx.MkImplies(lhsargs[i], q);
}
res = ExtractSmallerVCsRec(memo, q, small,lbl);
goto done;
}
if (r.GetKind() == DeclKind.Label)
{
var arg = lhs;
arg = lhs.GetAppArgs()[0];
if (!(arg.GetKind() == TermKind.App && arg.GetAppDecl().GetKind() == DeclKind.Uninterpreted))
goto normal;
if (!(annotationInfo.ContainsKey(arg.GetAppDecl().GetDeclName()) && annotationInfo[arg.GetAppDecl().GetDeclName()].type == AnnotationInfo.AnnotationType.LoopInvariant))
goto normal;
var sm = ctx.MkImplies(lhs, ExtractSmallerVCsRec(memo, t.GetAppArgs()[1], small));
if (lbl != null)
sm = ctx.MkImplies(lbl, sm);
small.Add(sm);
res = ctx.MkTrue();
goto done;
}
if (r.GetKind() == DeclKind.Uninterpreted)
{
var arg = lhs;
if (!(annotationInfo.ContainsKey(arg.GetAppDecl().GetDeclName()) && annotationInfo[arg.GetAppDecl().GetDeclName()].type == AnnotationInfo.AnnotationType.LoopInvariant))
goto normal;
var sm = ctx.MkImplies(lhs,ExtractSmallerVCsRec(memo,t.GetAppArgs()[1],small));
if (lbl != null)
sm = ctx.MkImplies(lbl, sm);
small.Add(sm);
res = ctx.MkTrue();
goto done;
}
}
normal:
Term newlbl = null;
if (lhs.IsLabel() && lhs.GetAppArgs()[0] == ctx.MkTrue())
newlbl = lhs;
res = ctx.MkImplies(lhs,ExtractSmallerVCsRec(memo,t.GetAppArgs()[1],small,newlbl));
}
else if (f.GetKind() == DeclKind.And)
{
res = ctx.MkApp(f,t.GetAppArgs().Select(x => ExtractSmallerVCsRec(memo, x, small)).ToArray());
}
else
res = t;
}
else
res = t;
done:
memo.Add(t, res);
return res;
}
private Term CollectGoalsRec(TermDict< Term> memo, Term t, List<Term> goals, List<Term> cruft)
{
Term res;
if (memo.TryGetValue(t, out res))
return res;
var kind = t.GetKind();
if (kind == TermKind.App)
{
var f = t.GetAppDecl();
if (f.GetKind() == DeclKind.Implies)
{
CollectGoalsRec(memo, t.GetAppArgs()[1], goals, cruft);
goto done;
}
else if (f.GetKind() == DeclKind.And)
{
foreach (var arg in t.GetAppArgs())
{
CollectGoalsRec(memo, arg, goals, cruft);
}
goto done;
}
else if (f.GetKind() == DeclKind.Label)
{
var arg = t.GetAppArgs()[0];
var r = arg.GetAppDecl();
if (r.GetKind() == DeclKind.Uninterpreted)
{
if (memo.TryGetValue(arg, out res))
goto done;
if (!annotationInfo.ContainsKey(r.GetDeclName()) && !arg.GetAppDecl().GetDeclName().StartsWith("_solve_"))
goto done;
goals.Add(arg);
memo.Add(arg, arg);
goto done;
}
else
return CollectGoalsRec(memo, arg, goals, cruft);
}
else if (f.GetKind() == DeclKind.Uninterpreted)
{
string name = f.GetDeclName();
if (name.StartsWith("_solve_"))
{
if (memo.TryGetValue(t, out res))
goto done;
goals.Add(t);
memo.Add(t, t);
return t;
}
}
}
// else the goal must be cruft
cruft.Add(t);
done:
res = t; // just to return something
memo.Add(t, res);
return res;
}
// TODO: this is a bit cheesy. Rather than finding the argument position
// of a relational term in a transformer by linear search, better to index this
// somewhere, but where?
private int TransformerArgPosition(RPFP rpfp, RPFP.Node root, Term expr)
{
FuncDecl rel = expr.GetAppDecl();
string relname = rel.GetDeclName();
var rps = root.Outgoing.F.RelParams;
for (int i = 0; i < rps.Length; i++)
{
string thisname = rps[i].GetDeclName();
if (thisname == relname)
return i;
}
return -1;
}
private Term SubstRecGoals(TermDict< Term> memo, Term t)
{
Term res;
if (memo.TryGetValue(t, out res))
return res;
var kind = t.GetKind();
if (kind == TermKind.App)
{
var f = t.GetAppDecl();
var args = t.GetAppArgs();
if (f.GetKind() == DeclKind.Implies){
res = SubstRecGoals(memo, args[1]);
if (res != ctx.MkTrue())
res = ctx.MkImplies(args[0],res);
goto done;
}
else if (f.GetKind() == DeclKind.And)
{
args = args.Select(x => SubstRecGoals(memo, x)).ToArray();
args = args.Where(x => x != ctx.MkTrue()).ToArray();
res = ctx.MkAnd(args);
goto done;
}
else if (f.GetKind() == DeclKind.Label)
{
var arg = t.GetAppArgs()[0];
var r = arg.GetAppDecl();
if (r.GetKind() == DeclKind.Uninterpreted)
{
if (memo.TryGetValue(arg, out res))
{
if(res != ctx.MkTrue())
res = ctx.MkApp(f, res);
goto done;
}
}
else
{
res = ctx.MkApp(f, SubstRecGoals(memo, arg));
goto done;
}
}
// what's left could be cruft!
if (memo.TryGetValue(t, out res))
{
goto done;
}
}
res = t;
done:
memo.Add(t, res);
return res;
}
private Term NormalizeGoal(Term goal, FuncDecl label)
{
var f = goal.GetAppDecl();
var args = goal.GetAppArgs();
int number;
if (!goalNumbering.TryGetValue(f, out number))
{
number = goalNumbering.Count;
goalNumbering.Add(f, number);
}
Term[] tvars = new Term[args.Length];
Term[] eqns = new Term[args.Length];
AnnotationInfo info = null;
annotationInfo.TryGetValue(f.GetDeclName(), out info);
for (int i = 0; i < args.Length; i++)
{
string pname = (info == null) ? i.ToString() : info.argnames[i];
tvars[i] = ctx.MkConst("@a" + number.ToString() + "_" + pname, args[i].GetSort());
eqns[i] = ctx.MkEq(tvars[i], args[i]);
}
return ctx.MkImplies(ctx.MkAnd(eqns), ctx.MkApp(label, ctx.MkApp(f, tvars)));
}
/** Create a node in the graph. The input is a term R(v_1...v_n)
* where R is an arbitrary relational symbol and v_1...v_n are
* arbitary distinct variables. The names are only of mnemonic value,
* however, the number and type of arguments determine the type
* of the relation at this node. */
public Node CreateNode(Term t)
{
Node n = new Node();
// Microsoft.Boogie.VCExprAST.VCExprNAry tn = t as Microsoft.Boogie.VCExprAST.VCExprNAry;
// Term[] _IndParams = tn.ToArray();
Term[] _IndParams = t.GetAppArgs();
FuncDecl Name = t.GetAppDecl();
n.Annotation = CreateRelation(_IndParams,ctx.MkTrue());
n.Bound = CreateRelation(_IndParams, ctx.MkTrue());
n.owner = this;
n.number = ++nodeCount;
n.Name = Name; // just to have a unique name
n.Incoming = new List<Edge>();
return n;
}
private Term CollectParamsRec(TermDict<Term> memo, Term t, List<FuncDecl> parms, List<RPFP.Node> nodes, Dictionary<Term, Term> done)
{
Term res;
if (memo.TryGetValue(t, out res))
return res;
if (t.GetKind() == TermKind.App)
{
var f = t.GetAppDecl();
Node node;
if (relationToNode.TryGetValue(f, out node))
{
if (done.ContainsKey(t))
res = done[t];
else
{
f = SuffixFuncDecl(t, parms.Count);
parms.Add(f);
nodes.Add(node);
done.Add(t,res); // don't count same expression twice!
}
}
var args = t.GetAppArgs();
args = args.Select(x => CollectParamsRec(memo, x, parms, nodes, done)).ToArray();
res = ctx.CloneApp(t, args);
} // TODO: handle quantifiers
else
res = t;
memo.Add(t, res);
return res;
}
