private void ReplacePreOrPostStateVars()
{
var sub = new Dictionary <Variable, Expr>();
foreach (var v in trc.allInParams)
{
sub[varCopies[v][0]] = Expr.Ident(v);
}
foreach (var v in trc.frame)
{
sub[varCopies[v][0]] = ExprHelper.Old(Expr.Ident(v));
}
if (!trc.ignorePostState)
{
foreach (var v in trc.PostStateVars)
{
var lastCopy = varCopies[v].Last();
if (sub.ContainsKey(lastCopy))
{
Debug.Assert(trc.frame.Contains(v) && lastCopy == varCopies[v][0]);
pathExprs.Add(Expr.Eq(Expr.Ident(v), sub[lastCopy]));
}
// In case of conflict we prefer "v" instead of "old(v)"
sub[lastCopy] = Expr.Ident(v);
}
}
pathExprs = SubstitutionHelper.Apply(sub, pathExprs).ToList();
}
private void AddBoundVariablesForRemainingVars()
{
var remainingVars = NotEliminatedVars.Except(IntermediateFrameWithWitnesses);
existsVarMap = remainingVars.ToDictionary(v => (Variable)VarHelper.BoundVariable(v.Name, v.TypedIdent.Type));
pathExprs = SubstitutionHelper.Apply(existsVarMap, pathExprs).ToList();
}
private void TryElimination(IEnumerable <Variable> extraDefinedVariables)
{
bool Defined(Variable v) => varToExpr.ContainsKey(v) || extraDefinedVariables.Contains(v);
bool changed;
do
{
changed = false;
var remainingAssignments = new List <Assignment>();
foreach (var assignment in assignments)
{
if (!Defined(assignment.Var) &&
VariableCollector.Collect(assignment.Expr).
Intersect(AllIntroducedVariables).All(Defined))
{
varToExpr[assignment.Var] = SubstitutionHelper.Apply(varToExpr, assignment.Expr);
changed = true;
}
else
{
remainingAssignments.Add(assignment);
}
}
Substitution sub = Substituter.SubstitutionFromHashtable(varToExpr);
foreach (var assignment in remainingAssignments)
{
assignment.Expr = Substituter.Apply(sub, assignment.Expr);
}
assignments = remainingAssignments;
assumes = SubstitutionHelper.Apply(sub, assumes).ToList();
} while (changed);
}
private static QKeyValue CloneAttributes(QKeyValue kv, Dictionary <Variable, Variable> substMap)
{
if (kv == null)
{
return(null);
}
return(new QKeyValue(kv.tok, kv.Key,
kv.Params.Select(p => p is Expr ? SubstitutionHelper.Apply(substMap, (Expr)p) : p).ToList(),
CloneAttributes(kv.Next, substMap)));
}
private void AddBoundVariablesForRemainingVars()
{
var remainingVars = NotEliminatedVars.Except(IntermediateFrameWithWitnesses);
existsVarMap = remainingVars.ToDictionary(v => v, v => (Variable)VarHelper.BoundVariable(v.Name, v.TypedIdent.Type));
var substMap = remainingVars.ToDictionary(v => copyToOriginalVar[v], v => existsVarMap[v]);
existsVarMap.Iter(kv => kv.Value.Attributes = CloneAttributes(copyToOriginalVar[kv.Key].Attributes, substMap));
pathExprs = SubstitutionHelper.Apply(existsVarMap, pathExprs).ToList();
}
private void ComputeWitnessedTransitionRelationExprs()
{
witnessedTransitionRelations = new List <Expr>();
Dictionary <Variable, List <CommutativityWitness> > varToWitnesses = trc.FrameWithWitnesses.
Where(x => NotEliminatedVars.Contains(frameIntermediateCopy[x])).
ToDictionary(
x => frameIntermediateCopy[x],
x => trc.globalVarToWitnesses[(GlobalVariable)x]);
foreach (var witnessSet in varToWitnesses.Values.CartesianProduct())
{
Dictionary <Variable, Expr> witnessSubst = new Dictionary <Variable, Expr>();
foreach (Tuple <Variable, CommutativityWitness> pair in
Enumerable.Zip(varToWitnesses.Keys, witnessSet, Tuple.Create))
{
CommutativityWitness witness = pair.Item2;
witnessSubst[pair.Item1] = ExprHelper.FunctionCall(
witness.function, witness.args.ToArray()
);
}
witnessedTransitionRelations.Add(
SubstitutionHelper.Apply(witnessSubst, TransitionRelationExpr));
}
}
