public Expr DisjointnessExpr(string domainName, HashSet <Variable> scope)
{
LinearDomain domain = linearDomains[domainName];
BoundVariable partition = new BoundVariable(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("partition_{0}", domainName), new MapType(Token.NoToken, new List <TypeVariable>(), new List <Type> {
domain.elementType
}, Microsoft.Boogie.Type.Int)));
Expr disjointExpr = Expr.True;
int count = 0;
foreach (Variable v in scope)
{
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, v);
Expr e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstInt), new List <Expr> {
new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(count++))
});
e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapEqInt), new List <Expr> {
new IdentifierExpr(Token.NoToken, partition), e
});
e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapImpBool), new List <Expr> {
v.TypedIdent.Type is MapType ? ie : Singleton(ie, domainName), e
});
e = Expr.Binary(BinaryOperator.Opcode.Eq, e, new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List <Expr> {
Expr.True
}));
disjointExpr = Expr.Binary(BinaryOperator.Opcode.And, e, disjointExpr);
}
var expr = new ExistsExpr(Token.NoToken, new List <Variable> {
partition
}, disjointExpr);
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
return(expr);
}
private static Expr OutPermsSubsetInPerms(LinearDomain domain, IEnumerable<Expr> ins, IEnumerable<Expr> outs)
{
Expr inMultiset = ExprHelper.Old(PermissionMultiset(domain, ins));
Expr outMultiset = PermissionMultiset(domain, outs);
Expr subsetExpr = ExprHelper.FunctionCall(domain.mapLe, outMultiset, inMultiset);
return Expr.Eq(subsetExpr, ExprHelper.FunctionCall(domain.mapConstBool, Expr.True));
}
private Expr SubsetExpr(LinearDomain domain, Expr ie, Variable partition, int partitionCount)
{
Expr e = ExprHelper.FunctionCall(domain.mapConstInt, Expr.Literal(partitionCount));
e = ExprHelper.FunctionCall(domain.mapEqInt, Expr.Ident(partition), e);
e = ExprHelper.FunctionCall(domain.mapImp, ie, e);
e = Expr.Eq(e, ExprHelper.FunctionCall(domain.mapConstBool, Expr.True));
return e;
}
private static Expr PermissionMultiset(LinearDomain domain, IEnumerable<Expr> exprs)
{
var terms = exprs.Select(x =>
ExprHelper.FunctionCall(domain.mapIteInt,
ExprHelper.FunctionCall(domain.collectors[x.Type], x),
domain.MapConstInt(1),
domain.MapConstInt(0))).ToList<Expr>();
if (terms.Count == 0)
return domain.MapConstInt(0);
return terms.Aggregate((x, y) => ExprHelper.FunctionCall(domain.mapAdd, x, y));
}
public Expr DisjointnessExprForPermissions(string domainName, IEnumerable<Expr> permissionsExprs)
{
Expr expr = Expr.True;
if (permissionsExprs.Count() > 1)
{
int count = 0;
List<Expr> subsetExprs = new List<Expr>();
LinearDomain domain = linearDomains[domainName];
BoundVariable partition = new BoundVariable(Token.NoToken,
new TypedIdent(Token.NoToken, $"partition_{domainName}", domain.mapTypeInt));
foreach (Expr e in permissionsExprs)
{
subsetExprs.Add(SubsetExpr(domain, e, partition, count));
count++;
}
expr = new ExistsExpr(Token.NoToken, new List<Variable> {partition}, Expr.And(subsetExprs));
}
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
return expr;
}
private Expr SubsetExprs(LinearDomain domain, HashSet<Variable> scope, Variable partition, int count, Expr expr)
{
foreach (Variable v in scope)
{
if (!domain.collectors.ContainsKey(v.TypedIdent.Type)) continue;
Expr ie = new NAryExpr(Token.NoToken, new FunctionCall(domain.collectors[v.TypedIdent.Type]), new List<Expr> { Expr.Ident(v) });
expr = Expr.And(SubsetExpr(domain, ie, partition, count), expr);
count++;
}
expr = new ExistsExpr(Token.NoToken, new List<Variable> { partition }, expr);
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
return expr;
}
private Expr SubsetExpr(LinearDomain domain, Expr ie, Variable partition, int partitionCount)
{
Expr e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstInt), new List<Expr> { new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(partitionCount)) });
e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapEqInt), new List<Expr> { Expr.Ident(partition), e });
e = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapImpBool), new List<Expr> { ie, e });
e = Expr.Eq(e, new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List<Expr> { Expr.True }));
return e;
}
private static List<Expr> PendingAsyncLinearParams(LinearTypeChecker linearTypeChecker, LinearDomain domain, AtomicAction pendingAsync, IdentifierExpr pa)
{
var pendingAsyncLinearParams = new List<Expr>();
for (int i = 0; i < pendingAsync.proc.InParams.Count; i++)
{
var inParam = pendingAsync.proc.InParams[i];
if (linearTypeChecker.FindDomainName(inParam) == domain.domainName && InKinds.Contains(linearTypeChecker.FindLinearKind(inParam)))
{
var pendingAsyncParam = ExprHelper.FunctionCall(pendingAsync.pendingAsyncCtor.selectors[i], pa);
pendingAsyncLinearParams.Add(pendingAsyncParam);
}
}
return pendingAsyncLinearParams;
}
