public static void AddChecks(CivlTypeChecker ctc)
{
foreach (var x in ctc.inductiveSequentializations)
{
var t = x.GenerateBaseCaseChecker();
ctc.program.AddTopLevelDeclaration(t.Item1);
ctc.program.AddTopLevelDeclaration(t.Item2);
t = x.GenerateConclusionChecker();
ctc.program.AddTopLevelDeclaration(t.Item1);
ctc.program.AddTopLevelDeclaration(t.Item2);
t = x.GenerateStepChecker(ctc.pendingAsyncAdd);
ctc.program.AddTopLevelDeclaration(t.Item1);
ctc.program.AddTopLevelDeclaration(t.Item2);
}
var absChecks = ctc.inductiveSequentializations.SelectMany(x => x.elim).Where(kv => kv.Key != kv.Value).Distinct();
foreach (var absCheck in absChecks)
{
var action = absCheck.Key;
var abs = absCheck.Value;
var requires = abs.gate.Select(g => new Requires(false, g.Expr)).ToList();
// TODO: check frame computation
var frame = new HashSet <Variable>(action.modifiedGlobalVars.Union(action.gateUsedGlobalVars).Union(abs.modifiedGlobalVars).Union(abs.gateUsedGlobalVars));
var tr = TransitionRelationComputation.Refinement(abs, frame);
var ensures = new List <Ensures> {
new Ensures(false, tr)
{
ErrorData = $"Abstraction {abs.proc.Name} does not summarize {action.proc.Name}"
}
};
var subst = InductiveSequentialization.GetSubstitution(action, abs);
List <Cmd> cmds = InductiveSequentialization.GetGateAsserts(action, subst,
$"Abstraction {abs.proc.Name} fails gate of {action.proc.Name}").ToList <Cmd>();
cmds.Add(
CmdHelper.CallCmd(
action.proc,
abs.impl.InParams.Select(Expr.Ident).ToList <Expr>(),
abs.impl.OutParams.Select(Expr.Ident).ToList()
));
var blocks = new List <Block> {
new Block(Token.NoToken, "init", cmds, CmdHelper.ReturnCmd)
};
var proc = new Procedure(Token.NoToken, $"AbstractionCheck_{action.proc.Name}_{abs.proc.Name}", new List <TypeVariable>(),
abs.impl.InParams, abs.impl.OutParams, requires, abs.modifiedGlobalVars.Select(Expr.Ident).ToList(), ensures);
var impl = new Implementation(Token.NoToken, proc.Name, new List <TypeVariable>(),
proc.InParams, proc.OutParams, new List <Variable>(), blocks)
{
Proc = proc
};
ctc.program.AddTopLevelDeclaration(proc);
ctc.program.AddTopLevelDeclaration(impl);
}
}
private Expr GetTransitionRelation(AtomicAction action)
{
var tr = TransitionRelationComputation.Refinement(civlTypeChecker, action, frame);
if (action == invariantAction && HasChoice)
{
return(new ChoiceEraser(invariantAction.impl.OutParams.Last()).VisitExpr(tr));
}
return(tr);
}
private Expr GetTransitionRelation(AtomicAction atomicAction)
{
if (!transitionRelationCache.ContainsKey(atomicAction))
{
transitionRelationCache[atomicAction] =
TransitionRelationComputation.Refinement(civlTypeChecker, atomicAction, new HashSet <Variable>(this.oldGlobalMap.Keys));
}
return(transitionRelationCache[atomicAction]);
}
private Expr GetTransitionRelation(AtomicActionCopy atomicActionCopy)
{
if (!transitionRelationCache.ContainsKey(atomicActionCopy))
{
transitionRelationCache[atomicActionCopy] =
TransitionRelationComputation.
Refinement(atomicActionCopy, new HashSet <Variable>(this.oldGlobalMap.Keys));
}
return(transitionRelationCache[atomicActionCopy]);
}
private static Tuple <Procedure, Implementation> GenerateAbstractionChecker(CivlTypeChecker civlTypeChecker, AtomicAction action, AtomicAction abs)
{
var requires = abs.gate.Select(g => new Requires(false, g.Expr)).ToList();
// TODO: check frame computation
var frame = new HashSet <Variable>(
action.modifiedGlobalVars
.Union(action.gateUsedGlobalVars)
.Union(abs.modifiedGlobalVars)
.Union(abs.gateUsedGlobalVars));
var tr = TransitionRelationComputation.Refinement(civlTypeChecker, abs, frame);
var ensures = new List <Ensures> {
new Ensures(false, tr)
{
ErrorData = $"Abstraction {abs.proc.Name} does not summarize {action.proc.Name}"
}
};
var subst = InductiveSequentialization.GetSubstitution(action, abs);
List <Cmd> cmds = InductiveSequentialization.GetGateAsserts(action, subst,
$"Abstraction {abs.proc.Name} fails gate of {action.proc.Name}").ToList <Cmd>();
cmds.Add(
CmdHelper.CallCmd(
action.proc,
abs.impl.InParams.Select(Expr.Ident).ToList <Expr>(),
abs.impl.OutParams.Select(Expr.Ident).ToList()
));
var blocks = new List <Block> {
new Block(Token.NoToken, "init", cmds, CmdHelper.ReturnCmd)
};
var proc = new Procedure(
Token.NoToken,
civlTypeChecker.AddNamePrefix($"AbstractionCheck_{action.proc.Name}_{abs.proc.Name}"),
new List <TypeVariable>(),
abs.impl.InParams,
abs.impl.OutParams,
requires,
action.proc.Modifies,
ensures);
var impl = new Implementation(
Token.NoToken,
proc.Name,
new List <TypeVariable>(),
proc.InParams,
proc.OutParams,
new List <Variable>(),
blocks)
{
Proc = proc
};
return(Tuple.Create(proc, impl));
}
private static Tuple <Procedure, Implementation> GenerateAbstractionChecker(CivlTypeChecker civlTypeChecker, AtomicAction action, AtomicAction abs)
{
var requires = abs.gate.Select(g => new Requires(false, g.Expr)).ToList();
// TODO: check frame computation
var frame = new HashSet <Variable>(
action.modifiedGlobalVars
.Union(action.gateUsedGlobalVars)
.Union(abs.modifiedGlobalVars)
.Union(abs.gateUsedGlobalVars));
var subst = InductiveSequentialization.GetSubstitution(action, abs);
List <Cmd> cmds = InductiveSequentialization.GetGateAsserts(action, subst,
$"Abstraction {abs.proc.Name} fails gate of {action.proc.Name}").ToList <Cmd>();
cmds.Add(
CmdHelper.CallCmd(
action.proc,
abs.impl.InParams,
abs.impl.OutParams
));
cmds.Add(
CmdHelper.AssertCmd(
abs.proc.tok,
TransitionRelationComputation.Refinement(civlTypeChecker, abs, frame),
$"Abstraction {abs.proc.Name} does not summarize {action.proc.Name}"
));
var blocks = new List <Block> {
BlockHelper.Block("init", cmds)
};
var proc = DeclHelper.Procedure(
civlTypeChecker.AddNamePrefix($"AbstractionCheck_{action.proc.Name}_{abs.proc.Name}"),
abs.impl.InParams,
abs.impl.OutParams,
requires,
action.proc.Modifies,
new List <Ensures>());
var impl = DeclHelper.Implementation(
proc,
proc.InParams,
proc.OutParams,
new List <Variable>(),
blocks);
return(Tuple.Create(proc, impl));
}