Bounded and Approximate Strong Satisfiability in Workflows

TL;DR

This paper introduces a new problem combining workflow satisfiability with costs and budgets, and provides a fixed-parameter tractable algorithm to determine if all workflow instances can meet the budget constraints.

Contribution

It formulates a novel problem of bounded and approximate satisfiability in workflows and offers an efficient algorithm for its solution.

Findings

The problem of bounded satisfiability is solvable with fixed-parameter tractability.

The algorithm efficiently handles workflows with varying instances and soft constraints.

Practical relevance for workflow management with cost and budget considerations.

Abstract

There has been a considerable amount of interest in recent years in the problem of workflow satisfiability, which asks whether the existence of constraints in a workflow specification makes it impossible to allocate authorized users to each step in the workflow. Recent developments have seen the workflow satisfiability problem (WSP) studied in the context of workflow specifications in which the set of steps may vary from one instance of the workflow to another. This, in turn, means that some constraints may only apply to certain workflow instances. Inevitably, WSP becomes more complex for such workflow specifications. Other approaches have considered the possibility of associating costs with the violation of `soft' constraints and authorizations. Workflow satisfiability in this context becomes a question of minimizing the cost of allocating users to steps in the workflow. In this paper, we introduce new problems, which we believe to be of practical relevance, that combine these approaches. In particular, we consider the question of whether, given a workflow specification with costs and a `budget', all possible workflow instances have an allocation of users to steps that does not exceed the budget. We design a fixed-parameter tractable algorithm to solve this problem parameterized by the total number of steps, release points and xor branchings.

Tables

Table 1. Table 1: Illustration of Execution Arrangements

Arrangement	Sequence
$\{s_1,s_2,s_3,s_5\},r,\{s_4,s_6\}$	$(s_1,s_2,s_3,s_5,r,s_4,s_6)$
$\{s_1,s_2,s_3,s_4,s_5\},r,\{s_4,s_6\}$	$(s_1,s_2,s_3,s_4,s_5,r,s_6)$
	$(s_1,s_2,s_3,s_5,s_4,r,s_6)$
	$(s_1,s_2,s_4,s_3,s_5,r,s_6)$
$\{s_1,s_2,s_3^{\prime },s_4\},r,\left\{s_6\right\}$	$(s_1,s_2,s_3^{\prime },s_4,r,s_6)$
	$(s_1,s_2,s_4,s_3^{\prime },r,s_6)$
$\{s_1,s_2,s_3^{\prime }\},r,\{s_4,s_6\}$	$(s_1,s_2,s_3^{\prime },r,s_4,s_6)$

Equations

$$w_c(\pi )\{\begin{array}{ll}=0& \text{if π satisfies c},\\ >0& \text{otherwise}.\end{array}$$

$$w_C(\pi )=\sum _{c\in C}{w}_c(\pi ).$$

$$w_A(\pi )\{\begin{array}{ll}=0& \text{if (t,π(t))∈A for all t∈S},\\ >0& \text{otherwise}.\end{array}$$

$$\sigma +{\sigma }^{\prime }=$$

$$\sigma \ast {\sigma }^{\prime }=$$

$$\{(b_1)+{\sigma }^{\prime \prime }:{\sigma }^{\prime \prime }\in (a_1,\dots ,a_k)\ast (b_2,\dots ,b_{\ell })\}$$

$$\sigma \ast ()=$$

$$T_0$$

$$T_i$$

$$T_q$$

$$\sum _{\sigma \in \Sigma }f(\sigma )=1,$$

$$f(\sigma )=\frac{1}{\left|\Sigma \right|},\text{for all σ∈Σ}.$$

$$\overline{w}(\sigma ,\pi )⩽\frac{B}{\left|\Sigma \right|};$$

$$\sum _{{\sigma }_i\in \Sigma }\overline{w}({\sigma }_i,{\pi }_i)⩽B.$$

$${\Sigma }_B=\left\{\sigma \in \Sigma :\exists \pi :S(\sigma )\to U,w(\sigma ,\pi )⩽B\right\}$$

$$\sum _{\sigma \in {\Sigma }_B}f(\sigma )⩾p.$$

$$\frac{\left|{\Sigma }_B\right|}{\left|\Sigma \right|}⩾p.$$

$$W^{\ast }=\frac{\sum _{i=1}^{|P|}{a}_i{w}_i^{\star }}{{\sum }_{i=1}^{|P|}{a}_i}$$

Full text

1 Introduction

Many businesses use computerized systems to manage their business processes. A common example of such a system is a workflow management system, which is responsible for the co-ordination and execution of steps in a business process. The overall structure of the business process is fixed and may be defined as a workflow specification comprising a set of steps that must be performed in a particular sequence. However, the specific steps that are performed may vary from one instance of the workflow to another. For example, certain steps may only be relevant in a purchase order workflow if the value of a specific order exceeds a particular value.

The steps in a workflow instance are executed by users and these users will vary from instance to instance. For most workflows, we may wish to impose some form of access control on the execution of those steps, limiting which users may perform which steps. This control may take the form of an authorization policy and a set of authorization constraints: the former defines which users are authorized to perform which steps; and the latter limits the combinations of users that may perform certain sets of steps in the business process. A simple form of constraint prohibits the same user from performing two (or more) particular security-sensitive steps.

As we noted above, the steps executed in a workflow may vary from one instance to another. Similarly, there may be constraints that only apply when certain sub-workflows are executed in a particular workflow instance. Basin, Burri and Karjoth introduced a mechanism for modeling such constraints using release points [3]. Informally, release points allow a constraint to be “switched off” when some specified points in a workflow instance are reached. In particular, when different release points are located in different mutually exclusive sub-processes, it is possible to encode conditional constraints.

An assignment of users to workflow steps is a plan. A plan is valid if all users are authorized and no constraint is violated. We say a workflow specification is satisfiable if there exists a valid plan for the specification [22]. An efficient algorithm for deciding the so-called workflow satisfiability question (WSP) is important from the point of view of static analysis of workflow specifications and as an on-line access control decision problem [9, Section 2.2].

Crampton, Gutin and Karapetyan [10] introduced the valued workflow satisfiability problem (VWSP). Informally, constraint and authorization violations are associated with costs, which may be regarded as an estimate of the risk associated with allowing those violations. A solution to VWSP is an assignment of users to steps having minimal cost, this cost being zero when the workflow is satisfiable.

In this paper, we introduce a new class of workflow satisfiability problems, based on extended workflow specifications and costs associated with policy and constraint violation. The notion of strong satisfiability is associated with workflow specifications in which the set of steps executed in a workflow instance may vary from instance to another. Typically, this variation arises because of conditional branching in the specification. Strong satisfiability requires that there exists a valid plan for every possible set of steps that could form a workflow instance. A weaker form of strong satisfiability asks whether there exists a “reasonable” plan for every possible set of steps, where “reasonable” means its cost does not exceed some threshold value that is part of the input to the problem. An alternative question would be that of “approximate satisfiability”, which asks whether there exists a valid plan for at least some fraction (stated as part of the input to the problem) of all possible sets of steps. An organization might be prepared to make a workflow specification operational if, for example, it is known that there exists a valid plan for at least 99% of the possible workflow instances.

We define three decision problems based on the informal notions described above and show that these problems are fixed-parameter tractable, subject to reasonable assumptions about the workflow specification. Informally, this means that relatively efficient algorithms exist to solve these problems.

In Section 2, we introduce relevant notation and terminology. Then, in Section 3, we describe relevant workflow models and satisfiability problems. We formally define bounded and approximate WSP problems in Section 4, then prove these problems are fixed-parameter tractable in Sections 5 and 6. The paper concludes with sections describing related work, a summary of our contributions and our ideas for future research in this area. In Appendix, we provide a running example illustrating some key concepts of this paper.

2 Notation and terminology

2.1 Directed graphs

A directed graph (digraph for short) is a pair $G=(V,E)$, where $V$ is the set of vertices, and $E\subseteq V\times V$ is the set of edges. A directed acyclic graph (DAG) is a digraph which does not contain any directed cycle, i.e. no sequence $(u_{0},u_{1}\dots,u_{k-1},u_{0})$ such that each pair of consecutive vertices belongs to $E$.

For $u\in V$, we define the in-neighborhood of $u$ to be the set $N^{-}(u)=\{t\in V:(t,u)\in E\}$; the in-degree of $u$ is the size of its in-neighborhood $\left|N^{-}(u)\right|$. Similarly, the out-neighborhood of $u$ is the set $N^{+}(u)=\{w\in V:(u,w)\in E\}$ and the out-degree of $u$ is $\left|N^{+}(u)\right|$. A vertex of in-degree [math] is called a source, while a vertex of out-degree [math] is called a sink. For $S\subseteq V$, we denote by $G[S]$ the induced subgraph $(S,E\cap(S\times S))$. By abuse of notation, we will sometimes write $G\setminus S$ as a shortcut for $G[V\setminus S]$. For additional information about directed and undirected graphs and DAGs, we refer the reader to [2, 15, 17].

Sometimes, it is convenient to represent a DAG with a partial order on its vertices. Indeed, we may write $u\leq v$ for $u,v\in V$ whenever $u=v$ or there exists a directed path from $u$ to $v$. By extension, we may write $u<v$ if $u\leq v$ and $u\neq v$.

For any positive integer $n$, let $[n]=\{1,\dots,n\}$. An ordered sequence $\sigma=(v_{1},\dots,v_{q})$ of distinct vertices of $V$ is called a linear subextension of $G$ if and only if for every $i,j\in[q]$, $v_{i}\leq v_{j}$ implies $i\leq j$. If $\sigma$ contains all vertices of $V$, then we say that $\sigma$ is a linear extension of $G$.

2.2 Fixed-parameter tractability

Many decision problems take several parameters as input. It can be instructive to consider how the complexity of the problem may change if we assume one or more of those parameters is small relative to the others. The purpose of multivariate analysis of the complexity of a problem is to obtain efficient algorithms when the chosen parameters take small values in practice. We say that a decision problem is fixed-parameter tractable (FPT) if there exists an algorithm that decides if an instance is positive in $\mathcal{O}(f(\kappa)p(n))$ time for some computable function $f$ and some polynomial $p$, where $n$ denotes the size of an instance, and $\kappa$ is a parameter of the instance. Accordingly, we will call such an algorithm an FPT algorithm.

In many cases, the decision problem under consideration has several parameters $\kappa_{1},\dots,\kappa_{p}$. This is reduced to the case of just one parameter by considering the parameter $\kappa=\kappa_{1}+\dots+\kappa_{p}.$ In fixed-parameter tractable algorithmics, the time $\mathcal{O}(f(\kappa)p(n))$ is often written as $\mathcal{O}^{*}(f(\kappa)).$ Thus, $\mathcal{O}^{*}$ hides not only constant factors like $\mathcal{O}$, but also polynomials (exponential functions are usually more important when evaluating the running time of FPT algorithms than polynomial factors). For more details about parameterized complexity, we refer the reader to the monographs of Downey and Fellows [16] and Cygan et al. [14].

3 The workflow satisfiability problem

A workflow specification is defined by a directed acyclic graph $G=(S,E)$, where $S$ is the set of steps to be executed, and $E\subseteq S\times S$ defines a partial ordering on the set of steps in the workflow, in the sense that $(s_{1},s_{2})\in E$ means that step $s_{1}$ must be executed before $s_{2}$ in every instance of the workflow. Note that the order is not required to be total, so the exact sequence of steps may vary from instance to instance. In addition, we are also given a set of users $U$ and an authorization policy $A\subseteq S\times U$, where $(s,u)\in A$ means that user $u$ is authorized to execute step $s$. A workflow specification $G=(S,E)$ together with an authorization policy is called a workflow schema. Throughout the paper, we will assume that for every step $s\in S$, there exists some user $u\in U$ such that $(s,u)\in A$.

A workflow constraint $(T,\Theta)$ limits the users that are allowed to perform a set of steps $T$ in any execution of the workflow. In particular, $\Theta$ identifies authorized (partial) assignments of users to steps in $T$, i.e. $\Theta$ is a set of functions from $T$ to $U$. A (partial) plan is a function $\pi:S^{\prime}\rightarrow U$, where $S^{\prime}\subseteq S$. A plan $\pi:S\rightarrow U$ represents an allocation of steps to users. The workflow satisfiability problem (WSP) is concerned with the existence or otherwise of a plan that is authorized and satisfies all constraints.

More formally, let $\pi:S^{\prime}\rightarrow U$, where $S^{\prime}\subseteq S$, be a plan. Given $T\subseteq S^{\prime}$, we write $\pi|_{T}$ to denote the function $\pi$ restricted to domain $T$; that is $\pi|_{T}:T\rightarrow U$ is defined by $\pi|_{T}(s)=\pi(s)$ for all $s\in T$. Then we say $\pi:S^{\prime}\rightarrow U$ satisfies a workflow constraint $(T,\Theta)$ if $T\not\subseteq S^{\prime}$ or $\pi|_{T}\in\Theta$.

In practice, we do not define a constraint by giving the family of functions $\Theta$ extensionally, as the size of such set might be exponential in the number of users and steps. Instead, we will assume that constraints have “compact” descriptions, in the sense that it takes polynomial time to test whether a given plan satisfies a constraint. This is a reasonable assumption, as all constraints of relevance in practice satisfy this property. For instance, the two most well-known constraints are binding-of-duty (BoD) and separation-of-duty (SoD). The scope of these constraints is binary: a plan $\pi$ satisfies a BoD constraint $(\{s_{1},s_{2}\},=)$ if and only if $\pi(s_{1})=\pi(s_{2})$; and $\pi$ satisfies an SoD constraint $(\{s_{1},s_{2}\},\neq)$ if and only if $\pi(s_{1})\neq\pi(s_{2})$. A natural generalization of these constraints are $\mathsf{atmost}$ and $\mathsf{atleast}$ constraints, in which the scope may be of arbitrary size, and the definition of such constraints includes an additional integer $k$. Given $T\subseteq S$, a plan satisfies $\mathsf{atmost}(T,k)$ (resp. $\mathsf{atleast}(T,k)$) if and only if $|\pi(T)|\leq k$ (resp. $|\pi(T)|\geq k$).

User-independent constraints generalize all these forms of constraints [6]. Informally, such a constraint limits the execution of steps in a workflow, but is indifferent to the particular users that execute the steps. More formally, a constraint $(T,\Theta)$ is user-independent if whenever $\theta\in\Theta$ and $\psi:U\rightarrow U$ is a permutation then $\psi\circ\theta\in\Theta$ (where $\circ$ denotes function composition). A separation of duty constraint, on two steps for example, simply requires that two different users execute the steps, not that, say, Alice and Bob (in particular) must execute them. Similarly, a binding of duty constraint on two steps only requires that the same user executes the steps. More generally, $\mathsf{atleast}$ and $\mathsf{atmost}$ constraints are user-independent. It appears most constraints that are useful in practice are user-independent: all constraints defined in the ANSI-RBAC standard [1], for example, are user-independent. A simple workflow specification, which will be used as a running example, can be found in Appendix A.

A constrained workflow authorization schema is a tuple $(G=(S,E),U,A,C)$, where $(G,U,A)$ is a workflow schema, and $C$ is a set of constraints. We say that a plan $\pi:S\rightarrow U$ is authorized if $(s,\pi(s))\in A$ for every $s\in S$, and we say that $\pi$ is valid if it is authorized and if it satisfies all $c\in C$. Then the Workflow Satisfiability Problem is defined in the following way [22]:

Workflow Satisfiability Problem (WSP)

Input:

A constrained workflow authorization schema $W=(G=(S,E),U,A,C)$

Question:

Is there a valid plan $\pi:S\rightarrow U$?

Henceforth, “workflow schema” will mean “constrained workflow authorization schema”.

3.1 Valued workflow satisfiability

We now review the problem of minimizing the cost of “breaking” the policies and/or constraints. Informally, given a workflow schema, for each plan $\pi$, we define the weight (total cost) $w(\pi)$ associated with the plan $\pi$. The problem, then, is to find a plan with minimum total cost.

More formally, let $((S,E),U,A,C)$ be a workflow schema. Let $\Pi$ denote the set of all possible plans from $S$ to $U$. Then, for each $c\in C$, we define a weight function $w_{c}:\Pi\rightarrow\mathbb{Z}$, where

[TABLE]

The pair $(c,w_{c})$ is a weighted constraint. Then we define the constraint weight of $\pi$ to be

[TABLE]

Note that $w_{C}(\pi)=0$ if and only if $\pi$ satisfies all constraints in $C$.

We next introduce a function $w_{A}:\Pi\rightarrow\mathbb{Z}$, which assigns a cost for each plan with respect to the authorization policy. The intuition is that a plan in which every user is authorized for the steps to which she is assigned has zero cost and the cost of a plan that violates the policy increases as the number of steps that are assigned to unauthorized users increases. More formally, we define the authorization weight of $\pi$ to be

[TABLE]

Then the valued Valued Workflow Satisfiability Problem is defined in the following way [10].

Valued WSP

Input:

A constrained workflow authorization schema $((S,E),U,A,C)$ with weights for constraints and authorizations, as above.

Output:

A plan $\pi:S\rightarrow U$ that minimizes $w(\pi)=w_{C}(\pi)+w_{A}(\pi)$.

Under the assumption that for every plan $\pi$ its weight $w(\pi)$ can be computed in time polynomial in $|S|+|U|+|C|$ (this assumption is justified in many practical situations [10]), Crampton et al. [10] proved the following:

Theorem 1**.**

Valued WSP* can be solved in time $\mathcal{O}^{*}(2^{k\log k}),$ where $k=|S|.$*

3.2 Compositional workflows

This section summarizes the model introduced by Crampton, Gutin and Watrigant [13]. A compositional workflow specification is defined recursively using three operations: serial composition, parallel branching and xor branching. Like a “classical” workflow specification, it can be represented as a DAG $G=(V,E)$. However, in the case of a compositional workflow, not all vertices represent steps. In addition to the set of (classical) steps, $V$ also contains $R$, the set of release points [3], and $O$, the set of orchestration points. We will sometimes directly define a compositional workflow specification as $G=(S\cup R\cup O,E)$.

The DAG of a compositional workflow always contains two special orchestration points: a source vertex $\alpha$, called input and a sink vertex $\omega$, called output. Moreover, an atomic compositional workflow specification (i.e. the base case for constructing such a workflow) consists of a single step or release point $v$, and can be represented by the DAG $G=(\{\alpha,v,\omega\},\{(\alpha,v),(v,\omega)\})$. Given two compositional workflows $G_{1}=(V_{1},E_{1})$ and $G_{2}=(V_{2},E_{2})$ with respective input and output vertices $\alpha_{1},\omega_{1}$ and $\alpha_{2},\omega_{2}$, respectively, we may construct new compositional workflows using serial composition, and parallel branching and xor branching, denoted by $G_{1};G_{2}$, $G_{1}\parallel G_{2}$ and $G_{1}\otimes G_{2}$, respectively. We assume that $V_{1}\cap V_{2}=\emptyset$.

For serial composition, all the steps in $G_{1}$ must be completed before the steps in $G_{2}$. Hence, the DAG of $G_{1};G_{2}$ is formed by taking the union of $V_{1}$ and $V_{2}$, the union of $E_{1}$ and $E_{2}$, and the addition of a single edge from $\omega_{1}$ to $\alpha_{2}$. Thus, $\alpha_{1}$ (resp. $\omega_{2}$) is the input (resp. output) vertex of $G_{1};G_{2}$.

For parallel composition, the execution of the steps in $G_{1}$ and $G_{2}$ may be interleaved. Hence, the DAG of $G_{1}\parallel G_{2}$ is formed by taking the union of $V_{1}$ and $V_{2}$, the union of $E_{1}$ and $E_{2}$, the addition of new input and output vertices $\alpha_{\parallel}$ and $\omega_{\parallel}$, and the addition of edges $(\alpha_{\parallel},\alpha_{1}),(\alpha_{\parallel},\alpha_{2}),(\omega_{1},\omega_{\parallel})$ and $(\omega_{2},\omega_{\parallel})$. This form of composition is sometimes known as an AND-fork [21] or a parallel gateway [23].

In both serial and parallel compositions, all steps in $G_{1}$ and $G_{2}$ are executed. In xor composition, either the steps in $G_{1}$ are executed or the steps in $G_{2}$, but not both. In other words, xor composition represents non-deterministic choice in a workflow specification. The DAG $G_{1}\otimes G_{2}$ is formed by taking the union of $V_{1}$ and $V_{2}$, the union of $E_{1}$ and $E_{2}$, the addition of new input and output vertices $\alpha_{\otimes}$ and $\omega_{\otimes}$, and the addition of edges $(\alpha_{\otimes},\alpha_{1}),(\alpha_{\otimes},\alpha_{2}),(\omega_{1},\omega_{\otimes})$ and $(\omega_{2},\omega_{\otimes})$. Given $G_{1}\otimes G_{2}$, we will say that every pair of vertices $(v,v^{\prime})\in V_{1}\times V_{2}$ are exclusive. We say that a compositional workflow is xor-free if it can be constructed with only serial and parallel operations.

For the sake of readability, we will sometimes simplify the representation of a compositional workflow by replacing an orchestration point having a single in-neighbor $u$ and a single out-neighbor $v$ by the edge $(u,v)$ (for instance, a path $(\alpha_{1},s_{1},\omega_{1},\alpha_{2},s_{2},\omega_{2})$ will be replaced by $(\alpha_{1},s_{1},s_{2},\omega_{2})$).

A compositional workflow specification $G=(V,E)$ together with an authorization policy $A\subseteq S\times U$ will be called a compositional workflow schema. An example of a compositional workflow specification is shown in Figure 2.

3.2.1 Execution sequences

In a compositional workflow having an xor branching, there exists more than one set of steps that could comprise a workflow instance. And in a compositional workflow having only parallel branching, two different workflow instances will contain the same steps but they may occur in different orders. We characterize the set of possible workflow instances in terms of execution sequences.

An execution sequence is an ordered sequence of steps and release points and may be empty. For execution sequences $\sigma=(a_{1},\dots,a_{k})$ and $\sigma^{\prime}=(b_{1},\dots,b_{k})$, we define the following two sets of execution sequences:

[TABLE]

In other words, $\sigma\mathbin{+}\sigma^{\prime}$ represents concatenation of $\sigma$ and $\sigma^{\prime}$; and $\sigma\mathbin{\ast}\sigma^{\prime}$ represents all possible interleavings of $\sigma$ and $\sigma^{\prime}$ that preserve the ordering of elements in both $\sigma$ and $\sigma^{\prime}$. Given sets of execution sequences $\Sigma$ and $\Sigma^{\prime}$, we write $\Sigma\mathbin{+}\Sigma^{\prime}$ and $\Sigma\mathbin{\ast}\Sigma^{\prime}$ to denote $\{\sigma\mathbin{+}\sigma^{\prime}:\sigma\in\Sigma,\sigma^{\prime}\in\Sigma^{\prime}\}$ and $\{\sigma\mathbin{\ast}\sigma^{\prime}:\sigma\in\Sigma,\sigma^{\prime}\in\Sigma^{\prime}\}$, respectively.

For a compositional workflow $G$, we write $\Sigma(G)$ to denote the set of execution sequences for $G$. Then:

• •

for workflow specification $G$ comprising a single step or release point $v$, $\Sigma(G)=\{(v)\}$;

• •

$\Sigma(G_{1};G_{2})=\Sigma(G_{1})\mathbin{+}\Sigma(G_{2})$;

• •

$\Sigma(G_{1}\parallel G_{2})=\Sigma(G_{1})\mathbin{\ast}\Sigma(G_{2})$; and

• •

$\Sigma(G_{1}\otimes G_{2})=\Sigma(G_{1})\cup\Sigma(G_{2})$.

For an execution sequence $\sigma$, let $\sigma_{S}$ and $\sigma_{R}$ be the restriction of $\sigma$ to the set of steps and release points, respectively. Similarly, let $S(\sigma)$ and $R(\sigma)$ be respectively the set of steps and release points contained in $\sigma$.111Hence, the difference between $\sigma_{S}$ and $S(\sigma)$ (resp. $\sigma_{R}$ and $R(\sigma)$) is that the former is an ordered sequence, while the latter is a set. In particular, it might be the case, for two ordered sequences $\sigma$, $\sigma^{\prime}$, that, say, $S(\sigma)=S(\sigma^{\prime})$ while $\sigma_{S}\neq\sigma^{\prime}_{S}$, in the case where $\sigma$ and $\sigma^{\prime}$ are two different orderings of a same set of steps.

Given an execution sequence $\sigma=(v_{1},\dots,v_{n})$ of $G$ and $i\in[n]$, we define ${\rm left}_{\sigma}(v_{i})=(v_{1},\dots,v_{i-1})$, ${\rm right}_{\sigma}(v_{i})=(v_{i+1},\dots,v_{n})$. Also, if $1\leq i<j\leq n$, then define ${\rm btw}_{\sigma}(v_{i},v_{j})=(v_{i+1},\dots,v_{j-1}).$ We will omit the $\sigma$ subscript from ${\rm left}_{\sigma}$, ${\rm right}_{\sigma}$ and ${\rm btw}_{\sigma}$ when it is obvious from context.

3.2.2 Constraints with release points

Suppose we have a requirement that two steps $s_{1}$ and $s_{2}$ be performed by the same user if a certain instance-specific condition holds; and they should be performed by different users otherwise. In other words, the constraint on the execution on $s_{1}$ and $s_{2}$ varies depending on the instance. Release points can be used to encode such requirements by positioning different release points in different, mutually-exclusive branches of the workflow and specifying both constraints on the two steps. Then passing through one branch “switches off” the separation-of-duty constraint, while passing through the other branch switches off the binding-of-duty constraint.

The model for constraints with release points described below [13] is more general than that of Basin, Burri and Karjoth [3]. Let $W=(S\cup R\cup O,E,U,A)$ be a compositional workflow schema. A constraint with release points has the form $c=(T,\Theta,P)$, where $T\subseteq S$ is the scope of the constraint, $P\subseteq R$ represents the release points of the constraints, and $\Theta$ is a family of functions with domain $T$ and range $U$. For $Q\subseteq S$, we denote by $\Theta|_{Q}=\{f|_{Q}:f\in\Theta\}$ the restriction of the family $\Theta$ to $Q$.

Let $\sigma$ be an execution sequence of $W$, and $\sigma_{P}=(r_{1},\dots,r_{q})$ be the ordering of release points of $P$ in $\sigma$. For every $i\in\{1,\dots,q-1\}$, define

[TABLE]

In other words, for $i\in[q-1]$, $T_{i}$ is the set of steps of $T$ occurring between $r_{i}$ and $r_{i+1}$ in $\sigma$.

Given a constraint $c=(T,\Theta,P)$ and an execution sequence $\sigma$, we define the restriction of $c$ to $T_{i}$ to be the constraint $c_{i}=(T_{i},\Theta|_{T_{i}})$. (That is, a constraint with scope limited to $T_{i}$ and having no release points.) We say that a plan $\pi:S(\sigma)\rightarrow U$ satisfies $c$ if and only if for all $i\in\{0,\dots,q\}$, $\pi|_{T_{i}}$ satisfies $c_{i}$, i.e. if $\pi|_{T_{i}}\in\Theta|_{T_{i}}$. Informally, a plan satisfies $c$ if and only if its restriction to each subscope $T_{i}$, $i\in\{0,\dots,q\}$, can be extended to a valid tuple (i.e. a tuple which belongs to $\Theta$). We say $\sigma$ satisfies $c$ if there exists a plan $\pi:S(\sigma)\rightarrow U$ that satisfies $c$.

A constrained compositional workflow schema (CCWS for short) is a tuple $(G=(S\cup R\cup O,E),U,A,C)$, where $(G,U,A)$ is a compositional workflow schema, and $C$ is a set of constraints with release points. We assume the scope of a constraint does not contain two exclusive steps. This is a reasonable assumption since two exclusive steps never occur in the same execution sequence. We say constraint $c=(T,\Theta,P)$ is user-independent (UI) if and only if for every $\theta\in\Theta$ and every permutation $\phi:U\rightarrow U$, we have $\phi\circ\theta\in\Theta$.

3.2.3 WSP with release points

Given a CCWS $W=(S\cup R\cup O,E,U,A,C)$, we say that an execution sequence $\sigma$ is satisfied if there exists an authorized plan $\pi:S(\sigma)\rightarrow U$ that satisfies all constraints in $C$. (Note that authorization does not depend on the ordering of steps or release points.) We say that $W$ is strongly satisfiable if and only if every execution sequence of $W$ is satisfiable. We then define the following decision problem:

WSP with Release Points

Input:

A constrained compositional workflow schema $W=(S\cup R\cup O,E,U,A,C)$

Question:

Is $W$ strongly satisfiable ?

Clearly WSP with Release Points is a generalization of WSP (indeed, a WSP with Release Points with no xor branching and whose all constraints have no release point is equivalent to a WSP instance), and is thus $NP$-hard and $W[1]$-hard when parameterized by $k=|S|$ [22]. Despite the seeming difficulty of the problem (since all execution sequences have to be considered), WSP with Release Points is FPT parameterized by the total number of steps, release points and xor-branchings [13].

4 Approximate and Bounded Workflow Satisfiability

There has been considerable interest in recent years in making the specification and enforcement of access control policies more flexible. Naturally, it is essential to continue to enforce effective access control policies. Equally, it is recognized that there may well be situations where a simple “allow” or “deny” decision for an access request may not be appropriate. It may be, for example, that the risks of refusing an unauthorized request are less significant than the benefits of allowing it. One obvious example occurs in healthcare systems, where the denial of an access request in an emergency situation could lead to loss of life. Hence, there has been increasing interest in context-aware policies, such as “break-the-glass”, which allow different responses to the same request in different situations. Risk-aware access control is another promising line of research that seeks to quantify the risk of allowing a request, where a decision of “0” might represent an unequivocal “deny” and “1” an unequivocal “allow”, with decisions of intermediate values representing different levels of risk.

Similar considerations arise very naturally when we consider workflows. In particular, we may specify authorization policies and constraints that mean a workflow specification is unsatisfiable. Clearly, this is undesirable from a business perspective, since the business objective associated with the workflow can not be achieved. Valued WSP provides a way of determining the minimum cost, in terms of violating constraints and/or the authorization policy, of a plan for the given workflow specification.

In this paper, we extend Valued WSP to CCWSs. Given a CCWS, we define for every pair $(\sigma,\pi)$, where $\pi:S(\sigma)\rightarrow U$, a cost $w(\sigma,\pi)$. In practice, this cost will be determined by the sum of the costs of all constraint and authorization policy violation(s) incurred by the plan, as described in Section 3.1. We assume $w(\sigma,\pi)$ can be computed in time polynomial in the size of the workflow specification.

Let $f:\Sigma\rightarrow(0,1]$ be a frequency distribution such that

[TABLE]

where $f(\sigma)$ denotes the relative frequency of $\sigma$ occurring as the set of steps in a workflow instance. The simplest case is a uniform distribution

[TABLE]

In this case, every execution sequence is equally likely to occur as a workflow instance. Of course, for some workflow specifications, the uniform distribution will not be appropriate and some execution sequences will be much more likely to occur than others. In this paper, we assume that $f$ is distributed uniformly.

Then, given an execution sequence $\sigma$ and a plan $\pi:S(\sigma)\rightarrow U$, we define $\overline{w}(\sigma,\pi)=f(\sigma)\cdot w(\sigma,\pi)$ to be the relative cost of the pair $(\sigma,\pi)$. We may wish to impose an upper bound on the relative cost of every execution sequence, or bound the expected cost of the workflow, or insist that a particular proportion of workflow instances will have a bounded cost. More formally, we introduce the following definition.

Definition 1**.**

Let $B\geqslant 0$ denote a budget. We say a workflow schema has

• •

bounded cost* if for every $\sigma\in\Sigma$, there exists a plan $\pi:S(\sigma)\rightarrow U$ such that*

[TABLE]

• •

bounded expected cost* if for every $\sigma_{i}\in\Sigma$, there exists a plan $\pi_{i}:S(\sigma_{i})\rightarrow U$ such that*

[TABLE]

In the special case $B=0$, a workflow with bounded cost or with bounded expected cost is satisfiable. And in the special case that $f$ is uniform, bounded cost simply means that for every execution sequence $\sigma$, there exists a plan $\pi$ such that $w(\sigma,\pi)\leqslant B$. The above definitions naturally give rise to two decision problems:

Bounded Cost WSP (BC-WSP).

Given a workflow specification and a budget does the workflow specification have bounded cost?

Bounded Expected Cost WSP (BEC-WSP),

Given a workflow specification and a budget does the workflow specification have bounded expected cost?

A specification with bounded cost means that the relative cost of every execution sequence can be bounded. In the special case that $f$ is uniform, the cost of every execution sequence can be bounded by $B$. A specification with bounded expected cost allows some execution sequences to exceed the budget but the cumulative cost is bounded. Such a specification allows for some very rare execution sequences whose only plans are relatively expensive, provided all the more commonly occurring plans have plans that are relatively cheap.

We may also define related search problems: Given a workflow specification, what is the smallest budget $B$ for which the workflow has

(i) bounded cost (ii) bounded expected cost?

Definition 2**.**

Let

[TABLE]

denote the set of execution sequences for which there exists a plan with cost no greater than $B$. We say a workflow specification has probability $p$ of completing within budget if

[TABLE]

In the simple case that $f$ is uniform, the above definition reduces to

[TABLE]

Then, we may define a third decision problem called Approximate BC-WSP: Given a workflow specification, a budget $B$ and a probability $p$, does the workflow have probability $p$ of completing within budget?

5 Solving Bounded Cost WSP

We now describe an algorithm to solve Bounded Cost WSP. Notice that our goal is to determine whether, for every execution sequence, there exists a complete plan with bounded cost. One naive approach would be to enumerate all execution sequences, and solve Valued WSP for each of them. We show, however, that there is a more efficient way to solve the problem. We will define an equivalence relation similar to the one defined by Crampton et al. [13] for the execution sequences, and will see that all equivalent execution sequences have the same weight.

5.1 Execution arrangements and their enumeration

We restate the equivalence relation $\sim$ defined in  [13] for the sake of completeness. We say that execution sequences $\sigma$ and $\sigma^{\prime}$ are equivalent if

(i)

$\sigma_{R}=\sigma^{\prime}_{R}$,

(ii)

$S(\sigma)=S(\sigma^{\prime})$, and

(iii)

for all $s\in S,R(right_{\sigma}(s))=R(right_{\sigma^{\prime}}(s))$.

Informally, two execution sequences are in the same equivalence class when their release points are the same and occur in the same sequences, they have the same set of steps, and for every step, the set of release points occurring to the right are the same. Essentially this means that the set of steps occurring between two release points are also the same. We call each equivalence class, an execution arrangement.

Based on the above characterization, we now define a compact representation of execution arrangement similar to that used by Crampton et al [13]. For an equivalent class containing an execution sequence $\sigma$, an execution arrangement is an ordered sequence $(S_{1},r_{1},S_{2},r_{2},\ldots,r_{q-1},S_{q}\}$ which satisfies the following properties:

$\{S_{1},\ldots,S_{q}\}$ is a partition of $S(\sigma)$. Note that we may have $S_{i}=\emptyset$ for some $i\in[q]$; 2. 2.

$(r_{1},\ldots,r_{q-1})$ is a linear sub-extension of $G$ containing all release points; and 3. 3.

for all $(s_{1},\ldots,s_{q})\in S_{1}\times\ldots\times S_{q}$, $(s_{1},r_{1},\ldots,s_{q-1},r_{q-1},s_{q})$ is a linear sub-extension of $G$.

For an illustration of compact representations of execution arrangements, see Table 1.

The alert reader will notice that we have abused the notation slightly in the last property if $S_{i}=\emptyset$ for some $i\in[q]$. If $S_{i}=\emptyset$ for some $i\in[q]$, we simply omit such steps $s_{i}$ in the sequence $(s_{1},r_{1},\ldots,r_{q-1},s_{q})$. Now, we have the following lemma.

Lemma 1**.**

Let $W=((S\cup R\cup O,E),U,A,C)$ be a CCWS. Let $\sigma$ and $\sigma^{\prime}$ be two execution sequences and $\sigma\sim\sigma^{\prime}$. Then, for a plan $\pi:S(\sigma)\rightarrow U$, we have that $w_{\sigma}(\pi)=w_{\sigma^{\prime}}(\pi)$.

Proof.

Let $c=(T,\Theta,R)$ be a constraint. By definition of $\sim$, we have that $\sigma_{R}=\sigma^{\prime}_{R}=(r_{1},\ldots,r_{q})$. Now, let $i\in[q-1]$, and denote by $T_{i}$ the set $T\cap S(btw_{\sigma}(r_{i},r_{i+1}))$, and by $T^{\prime}$ the set $T\cap S(btw_{\sigma^{\prime}}(r_{i},r_{i+1}))$. We know by definition of $\sim$ that $R(right_{\sigma}(s))=R(right_{\sigma^{\prime}}(s))$ for every $s\in\sigma^{\prime}$. Hence, constraint $c$ is violated by a plan $\pi$ in $\sigma$ if and only if the constraint $c$ is violated by a plan $\pi$ in $\sigma^{\prime}$. Also, authorization does not depend on the ordering of steps or release points. So, if a particular authorization policy is violated by $\pi$ in $\sigma$, then the same authorization policy is violated by $\pi$ in $\sigma^{\prime}$ as well. Therefore we have that $w_{\sigma}(\pi)=w_{\sigma^{\prime}}(\pi)$. ∎

From Lemma 1, the following is clear. Suppose that we find a plan $\pi$ of minimum cost for each of the execution arrangements. Then, this will be sufficient to find a plan for each of the execution sequences. So, we may proceed as follows. First, we enumerate the set of execution arrangements. After that, for each of the execution arrangements, we find a plan of minimum cost. If all such plans are of weight bounded by $B$, then Bounded Cost WSP has a solution; otherwise, it has no solution. Below we will describe details of this approach.

It follows from [13] that the number of execution arrangements is $(|S|+|R|)!$, and their enumeration is non-trivial. The presence of xor branching means that the set of steps and release points differ depending on the executions. We can use the approach of [13] to enumerate all execution arrangements. We provide an outline of the enumeration, rather than describing it in detail; a full description is available in [13]. The overall approach is decomposed into two parts:

elimination of xor branching [13, Section 3.2]; and 2. 2.

enumeration of all execution arrangements in an xor branching [13, Algorithm 2].

Let $G$ be the DAG of the initial workflow instance $W$. After eliminating xor-branchings, we obtain a collection of workflow instances $W[G_{1}],W[G_{2}],\ldots,W[G_{t}]$. Then $W$ is satisfiable if and only if for every $i\in[t]$, $W[G_{i}]$ is satisfiable [13, Lemma 3.2]. The reason here is that an execution of $W[G_{i}]$ is also an execution sequence of $W$. Also, for every execution sequence $\sigma$ of $W$, there exists $i\in[t]$ such that $\sigma$ is an execution sequence of $W[G_{i}]$. Hence, consider an arbitrary $i\in[t]$, and consider an arbitrary execution sequence $\sigma$ of $W[G_{i}]$. If a plan $\pi$ has weight $w^{\star}$ for $\sigma$ in $W[G_{i}]$, then $\pi$ also has weight $w^{\star}$ for the execution sequence $\sigma$ in $W$ since the execution sequences are same. Hence, if a plan $\pi$ for an execution sequence in an xor-free instance has bounded weight, then the same plan also has the weight with same bound in the original workflow instance. Thus, it is sufficient to compute the execution arrangements for each of the xor-free instances and find if there is a plan with bounded weight for each of the execution arrangements.

The existing algorithm for enumerating execution arrangements can be used, unchanged, as it applies to workflow instances containing release points and orchestration points, and is independent of whether costs are associated with policy and constraint violations. We may also make use of the following theorem [13, Theorem 3.5].

Theorem 2**.**

Given an instance of CCWS $W=((S\cup R\cup O,E),U,A,C)$ with release points, there exists an algorithm that removes all xor-branchings, and enumerates the set of all execution arrangements in time $\mathcal{O}^{*}(2^{|\mathcal{B}|}|R|!(|R|+1)^{|S|})$.

Having enumerated the execution arrangements, we must determine whether there exists a plan $\pi$ with bounded cost for each of the execution arrangements. We consider this problem in the next subsection.

5.2 Reduction to Valued WSP

Now for each execution arrangement, we have to determine whether there exists a plan $\pi$ with bounded cost. We show that this can be reduced to solving finitely many instances of the classical Valued WSP (stated in Section 3.1), which contains no release points or orchestration points.

Note that for every execution arrangement, we want to solve Bounded Cost WSP for one execution sequence. The idea is similar to the ideas used in [13]; we describe it here for completeness, and also in order to highlight the differences.

Suppose that $\Sigma=(S_{1},r_{1},S_{2},r_{2},\ldots,r_{q-1},S_{q})$ is an execution arrangement, and $c=(T,\Theta,P)$ is a constraint with release points $P=\{r_{p_{1}},\ldots,r_{p_{|P|}}\}$. We assume without loss of generality that the ordering is a linear extension of release points $R(\Sigma)$. As before, for all $i\in[P-1]$, we define $T_{i}=T\cap S(btw(r_{p_{i}},r_{p_{i+1}}),T_{0}=T\cap S(\mathit{left}(r_{p_{0}})),T_{|P|}=T\cap S(\mathit{right}(r_{p_{|P|}})$, and the “classical” constraint $c_{i}=(T_{i},\Theta|_{T_{i}})$. We know that $c$ is satisfied by an execution sequence $\sigma$ if and only if there exists a plan $\pi$ such that $\pi_{T_{i}}$ satisfies $c_{i}$ for every $i\in\{0,1,\ldots,q\}$. Now, suppose that for a plan $\pi$, the constraint $c_{i}$ is violated by $\pi_{T_{i}}$ for some $i\in\{0,1,\ldots,q\}$. Then, the constraint $c$ is also violated by $\pi$. So, for each $i\in\{1,\ldots,|P|\}$, we define the classical Valued WSP instance $W_{i}=(G_{i}=(S_{i},E_{i}),U,A_{i},C_{i})$ that defines the partial order restricted to $S_{i}$, $A_{i}=A\cap(S_{i}\times U)$ and $C_{i}=\{c_{i}|c\in C\}$.

For our case, we reduce it to finitely many instances of Valued WSP. Suppose that for every $i\in[|P|]$, we find the weight $w_{i}^{\star}$ of a minimum weight plan for the Valued WSP $W_{i}$. If this $w_{i}^{\star}$ meets the bound for every $i\in[|P|]$, then we say that Bounded Cost WSP is a yes-instance. Otherwise we say that Bounded Cost WSP is a no-instance. Hence, we have the following lemma.

Lemma 2**.**

$\Sigma$* is a yes-instance for Bounded Cost WSP if and only if for every $i\in[|P|]$, the cost of the the plan outputted for $W_{i}$ is at most $B$.*

5.3 Running time of the algorithm

In this subsection, we analyze the running time of the algorithm. The worst case running time of the algorithm is the respective running times of the algorithm for solving the following subproblems.

(i) enumerating all xor-free sub-instances;

(ii) given an xor-free instance, enumeration of all execution arrangements;

(iii) given an execution arrangement, reduction to Valued WSP and solving Valued WSP for each of them.

We know from Theorem 2 that the product of steps (i) and (ii) takes $\mathcal{O}(2^{|\mathcal{B}|}|R|!(|R|+1)^{|S|})$ time.

Hence, as a consequence of Lemma 2 and Theorems 2 and 1, we have the following:

Theorem 3**.**

Let $\kappa=|S|+|R|+|\mathcal{B}|.$ Bounded Cost WSP parameterized by $\kappa$ is fixed-parameter tractable, and can be solved in $\mathcal{O}^{*}(2^{|\mathcal{B}|}|R|!(|R|+1)^{|S|}|S|^{|S|})$ time.

By Theorem 1, computing minimum weight plans takes time $\mathcal{O}^{*}(|S|^{|S|})$ and this computation can contribute a significant factor to the running time of the algorithm of Theorem 3 especially if the number of xor-branchings and release points is smaller than the number of steps. In a practical implementation, this aspect of the algorithm can be sped up by observing that the weight of a minimum weight plan $\pi$ is the sum of the weights of minimum weight plans for $S_{1},\dots,S_{q}$ (see the proof of Lemma 1). Thus, each time we compute the weight of minimum weight plan for a set $S_{i}$, we save it in RAM (e.g., in a bucket of a hash table with key $S_{i}$) unless $S_{i}$ is already in RAM and the weight of its minimum weight plan can be obtained directly from RAM.

6 Solving Bounded Expected Cost WSP and Approximate BC-WSP

We now describe how we can reuse the ideas from Section 5 in order to solve Bounded Expected Cost WSP. Recall that our algorithm for Bounded Cost WSP consists of three steps. The first two steps – enumerating all xor-free sub-instances and enumerating execution arrangements – can be reused without modification. The third step, however, requires some changes.

Suppose we have $\left|P\right|$ instances of Valued WSP. Note that the number of execution sequences in different execution arrangements may vary. During the run of Algorithm 2 from [13], we can count how many execution sequences there are in a specific execution arrangement. We store a counter for each of the execution arrangements. Notice that we finally solve Valued WSP for $|P|$ instances where $|P|$ is the number of different execution arrangements.

Recall that $f$ is distributed uniformly over execution sequences. Let $a_{i}$ be the number of execution sequences in the $i$th execution arrangement. Suppose that $w_{i}^{\star}$ is the cost of Valued WSP of the $i$th instance. Then $w_{i}^{\star}$ is the cost of Valued WSP for all the execution sequences of the $i$th execution arrangement. Then the total cost for the $i$th execution arrangement is $a_{i}w_{i}^{\star}$. Then the total cost over all execution sequences is

[TABLE]

which is same as the sum of the minimum costs over all execution sequences. If $W^{*}\leqslant B$, we say that Bounded Expected Cost WSP is a yes-instance.

Finally, we consider Approximate BC-WSP. Recall that we wish to determine whether a workflow schema has probability $p$ of completing within budget $B$. We first initialize a counter $b$ to zero where we count the number of execution sequences that achieves a specific bound. If $w_{i}^{\star}\leqslant B$ for the $i$th execution arrangement, we increase the counter by $a_{i}$ as each of the execution sequences in the $i$th execution arrangement has the same cost. Finally, $b$ is the number of execution sequences where there exists a plan with cost no greater than $B$. If $b/\sum_{i=1}^{|P|}a_{i}\geq p$, we say that the workflow has the probability $p$ of completing within the budget.

7 Related work

Research on workflow satisfiability began with the seminal work of Bertino, Ferrari and Atluri [4] and Crampton [7]. Wang and Li were the first to demonstrate that WSP, subject to specific and limiting restrictions, was fixed-parameter tractable [22]. A substantial body of work now exists on the fixed-parameter tractability of WSP [6, 8, 11]. In particular, it is known that WSP is fixed-parameter tractable (parameterized by the number of steps) when all constraints are regular [11] or user-independent [6].

Basin, Burri and Karjoth introduced the notion of release points [3] in order to model workflows in which the set of steps that are executed may vary and for which constraints only apply to certain sets of steps. They modeled workflows using a process algebra and defined the notion of an enforcement process, which corresponds to a valid plan in our model of workflow satisfiability. They showed that the enforcement process existence (EPE) problem, which corresponds to the workflow satisfiability problem, is NP-hard, and developed a polynomial-time heuristic to solve the EPE problem. Their algorithm achieves good results under the assumption that the user population is large and “the static authorizations are equally distributed between them”.

Crampton, Gutin and Watrigant [13] developed FPT algorithms for WSP with release points, provided all constraints were user-independent. Their algorithms were exact and did not make any assumptions about the distribution of static authorizations.

Crampton, Gutin and Karapetyan [10] introduced the Valued WSP problem in order to determine the most suitable plan(s) for a workflow schema, even if that schema was unsatisfiable, based on the cost of constraint and policy violations. They argued that it may be necessary, perhaps because of business requirements, to allow a workflow to execute, even if it meant that some constraints or authorizations had to be violated. Mace, Morisset and van Moorsel [20] introduced the notion of quantitative resiliency in workflows, which seeks to evaluate how likely a workflow is to complete, given assumptions about the availability of users. Crampton, Gutin, Karapetyan and Watrigant [12] extended Valued WSP to Bi-objective WSP and demonstrated how quantitative resiliency problems could be encoded as instances of Bi-objective WSP.

Bertolissi, dos Santos and Ranise [5] extended bi-objective WSP optimization to multi-objective. They used a WSP model similar to that of Crampton, Gutin and Watrigant [13] but without release points. Thus, one can view [5] as a earlier approach to combine ideas of [10] and [12]. However, Bertolissi, dos Santos and Ranise [5] considered only simple separation of duty constraints instead of the general class of user-independent constraints used in our paper. Another difference between [5] and our paper is that while [5] uses an off-the-shelf Optimization Modulo Theories solver, we design a specialised FPT algorithm. Note that several papers including [12] and the very recent [19] showed that FPT algorithms are superior to various off-the-shelf decision and optimization solvers at solving WSP-related problems.

The problems introduced in this paper continue work on quantitative aspects of workflow satisfiability. We believe these problems have important practical applications. Business continuity is hugely important to commercial organizations, arguably more so than security considerations, so the ability to reason about the costs of executing workflows, specified in terms of security violations, is likely to be of significant value. And it is important that these quantitative problems can be solved by FPT algorithms.

8 Concluding Remarks

In this paper, we have introduced an extended model for workflows that incorporates costs for policy and constraint violation and complex workflow patterns. Some workflows schemas in which the set of steps that are executed may vary from one workflow instance to another may be strongly satisfiable, where every possible instance is satisfiable. However, there may be schemas having execution sequences that are not satisfiable and it may be impractical, undesirable or impossible, given the personnel available, to define a workflow schema that is strongly satisfiable. On the other hand, business considerations may dictate that the workflow is made operational. In such circumstances, it is clearly desirable to be know that the cost of executing the workflow is bounded, in terms of constraint and policy violations. It may also be desirable to be able to determine the maximum cost.

The work in this paper provides the foundations for answering questions of this nature. Moreover, it provides the theoretical basis for algorithms that can be used to solve such questions relatively efficiently, provided the number of steps is relatively small and only user-independent constraints are employed.

Nevertheless, there remains much interesting work to be done. We would like, for example, to consider relaxing the assumption the uniformity condition on $f$ and investigate the possibility of obtaining algorithms of similar running time to that in Theorem 3. We hope to implement the theoretical algorithms described in this paper and evaluate their performance on practical instances of the problems we study. Prior work on implementing FPT algorithms for WSP-like problem (see, e.g., [18]) suggest that the theoretical algorithms described in this paper may be useful in practice, especially if optimizations, such as the one described at the end of Section 5 are employed.

Acknowledgement

The research in this paper was supported by the Leverhulme Trust award RPG-2018-161.

Appendix A Workflow specification example

We present as a running example a simple purchase-order workflow [7] in Figure 1. In the first step of this workflow, the purchase order is created and approved (and then dispatched to the supplier). The supplier will submit an invoice for the goods ordered, which is processed by the create payment step. When the supplier delivers the goods, a goods received note (GRN) must be signed and countersigned. Only then may the payment be approved and sent to the supplier. Observe that this workflow specification contains parallel branches, in the sense that the processing of both $s_{3}$ and $s_{4}$ must occur before $s_{6}$, but the relative ordering of $s_{3}$ and $s_{4}$ is of no importance. We will extend this example to include mutually exclusive branches.

The workflow specification also includes constraints (each having binary scope), mainly in order to reduce the possibility of fraud. Such constraints may be depicted as an undirected, labeled graph, in which the vertices represent steps and edges denote constraints, as illustrated in Figure 1(b). One requirement, for example, is that the steps to create and approve a purchase order are executed by different users. We will extend the example to include constraints having release points.

The compositional workflow specification shown in Figure 2 extends the example in Figure 1 by including orchestration steps and an xor branching. We model the fact that orders below a certain value will not require a countersignature on the GRN. Thus, one branch includes steps to sign and countersign the GRN (which is taken when the value of the order exceeds a certain value), while the other branch contains only the sign GRN step.

The possible execution sequences for the example in Figure 2 are:

• •

$(s_{1},s_{2},s_{4},s_{3},s_{5},s_{6})$

• •

$(s_{1},s_{2},s_{3},s_{4},s_{5},s_{6})$

• •

$(s_{1},s_{2},s_{3},s_{5},s_{4},s_{6})$

• •

$(s_{1},s_{2},s_{4},s^{\prime}_{3},s_{6})$

• •

$(s_{1},s_{2},s^{\prime}_{3},s_{4},s_{6})$

We extend our running example by modifying the SoD constraint defined between $s_{1}$ and $s_{4}$ in order to illustrate how execution sequences and release points might affect the satisfiability of an instance. The resulting workflow specification is illustrated in Figure 3. Specifically, the constraint is released by $r$ positioned between $\omega_{\otimes}$ and $\omega_{\parallel}$. The intuition is to prevent the same person from creating the purchase order and the payment, except when the GRN has been signed (and countersigned, if the upper branch of the xor branching is chosen). Hence, if the “create payment” is processed before the signature/countersignature of the GRN, then the user who created the purchase order cannot create the payment. Otherwise, if the “create payment” is processed after the signature/countersignature of the GRN, then the SoD constraint is released. In the case where the authorization policy is such that only one user is authorized to execute steps $s_{1}$ and $s_{4}$, then some execution sequences will be satisfiable, whereas some others will not be satisfiable.

The compact representation of execution arrangements (see Section 5) for the example of Figure 3 are illustrated in Table 1.