{'fraction_non_alphanumeric': 0.039196567862714506, 'fraction_numerical': 0.0068057722308892355, 'mean_word_length': 4.160092573958543, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 27, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A Projection-Stable Grammatical Model for the Distributed Execution of Administrative Processes with Emphasis on Actors' Views

During the last two decades, the decentralized execution of business processes has been one of the main research topics in Business Process Management. Several models (languages) for processes' specification in order to facilitate their distributed execution, have been proposed. LSAWfP is among the most recent in this area: it helps to specify administrative processes with grammatical models indicating, in addition to their fundamental elements, the permissions (reading, writing and execution) of each actor in relation to each of their tasks. In this paper, we present a model for a completely decentralized and artifact-centric execution of administrative processes specified using LSAWfP. The presented model puts particular emphasis on actors' views: it then allows the confidential execution of certain tasks by ensuring that, each actor potentially has only a partial perception of the processes' global execution states. To accomplish this, the model is based on three projection algorithms allowing to partially replicate the processes' global execution states at a given moment, to consistently update the obtained partial states and to deduce new coherent global states. The proposal of these three algorithms, the proof of underlying mathematical tools' stability and a proposal of their implementation, are this paper's main contributions.


Introduction
Administrative business processes are those of which all cases are known and predictable; that is to say, tasks sequencing rules are simple and clearly defined [1,2]: they are the most frequently encountered in practice [3,4] (the peer review process [5,6,7,8,9], the insurance claims process [10,11], etc.). In its most widespread approach, Business Process Management (BPM) technology breaks down the automation of a given business process to its formal specification (modelling) in a workflow language [4]. The resulting process (workflow) model generally describes all the process's tasks, the control flow that link them (routing) and the actors in charge of executing them [3].
For the decentralized execution of an administrative process described in any workflow language, one can imagine a distributed Workflow Management System (WfMS) made up of several reactive agents or peers, driven by human agents (actors in charge of executing tasks), coordinating with each other using an artifact that they cooperatively edit. In fact, the distributed execution of an administrative process is similar to the cooperative edition of a form that has to circulate from site to site (mobile form) in order to be edited by the different actors of the process. Upon its arrival on a site, the actor associated with the site must be able to examine it and deduce without ambiguity, the already edited fields (these correspond to the already executed tasks of the process), the fields that he must immediately edit (these correspond to the ready tasks that he must execute), and possibly, the sites to which he must return/redirect the form for further processing at the end of its edition. It is easy to imagine that there could be forms with independent fields that need to be filled in by different actors. In this case, in order to speed up processing, it is acceptable that at a given time, there may be several replicas of the form that are simultaneously edited in the system.
A major characteristic of administrative processes is confidentiality: not all actors in an administrative process are necessarily aware of all processing and/or data generated in the process. It is therefore natural to assume that the form that is presented to an actor for editing on a site is only a potentially partial replica of the global form 1 ; this (partial) replica only contains information (relating to processing and data) that is of proven interest to the considered actor. Once a partial replica of a form has been received, it is essential to ensure that all editing actions on it can be consistently integrated into the global form. In order to satisfy this constraint, it is sufficient for each actor to have a local "supervisor" who must control his editing actions.
The form described in the two paragraphs above can be seen as a structured document (a tree) circulating from site to site, to be extended by cooperative editions made at the level of its leaves (positive edition 2 ). The nodes of this tree therefore represent either the tasks already executed, or those ready to be executed; moreover, the relations between nodes (father-son, brother-brother) correspond exactly to the ordering of tasks. This tree is called "artifact" in the artifact-centric approach to business process modelling.
Based on the cooperative editing model of structured documents studied in the works of Badouel et al. [14,15,16,17,18,19], we propose in this paper, a model for the distributed execution of administrative processes (cooperative edition of artifacts) that relies on algorithms to obtain : (1) partial replicas of the global artifact (artifact projection algorithm); these contain only the information relevant to the considered actors; (2) local models that constrain local editing actions on local artifacts (model projection algorithm), so as to ensure that these are always "expandable" as editing actions (updates) on the global artifact (expansion algorithm). The proposed execution model applies only to process models obtained using the language LSAWfP (A Language for the Specification of Administrative Workflow Processes) [7,8,9]. LSAWfP is a new language designed for the specification (using a variant of attributed grammars) of administrative processes with particular emphasis placed on the modelling (using views) of the perceptions that the various actors have on processes and their data. The specification of a particular process in this language is given by a triplet (a Grammatical Model of Administrative Workflow Process -GMAWfP -) W f = (G, L P k , L A k ) wherein, G is the model of tasks and their sequencing, L P k and L A k represent respectively the list of actors and their accreditations 3 . If we consider a GMAWfP W f = (G, L P k , L A k ) to be executed in a decentralized manner, then the main contributions of this paper are as follows: 1) The proposal of algorithms for: • artifacts' projection; which, given an artifact t that conforms to the (global) model G and the accreditation in reading A A i (r) (known as view and denoted V i ) of an actor A i , allows to find its partial replica t V i ; • model's projection; which permits, from a view V i and a global model G, to derive a local model G V i . G V i will guide the actions carried out by a given actor on partial replicas from his site, in order to ensure consistency with respect to the global model G.
• expansion-pruning; which enable the inverse projection of a partial replica t ma j V i updated by a given actor A i according to a local GMWf G V i ; the goal is to integrate the contributions made by the local actor into an artifact t f that conforms to the global model G.
2) A study of stability properties of artifacts and their model, when using the proposed algorithms.

3) A Haskell implementation of the proposed algorithms.
Organization of the manuscript: in the remainder of this manuscript, we briefly present the LSAWfP language and an example of a process modelled using it (sec. 2.2). We then present the artifact-centric model of process execution considered in this paper, in order to motivate the need to propose stable projection algorithms (sec. 2.3). We continue by proposing versions of the three projection algorithms covered in this paper as well as a study of some of their properties (sec. 3). We end with a discussion and a conclusion.

On the Modelling and the Execution of Administrative Business Processes using LSAWfP
Several tools have been developed to address process modelling. Among the most well-known are the BPMN standard (Business Process Model and Notation) [20] which uses a formalism derived from that of statecharts, and the YAWL language (Yet Another Workflow Language) [21,3,22] based on Petri nets. Despite the significant research progress around these workflow languages, they are often criticized for having a much too great expressiveness compared to the needs of professionals in the field [23], for not being based on solid mathematical foundations and/or for not being intuitive [24]: This justifies the emergence of several other languages such as LSAWfP [7,8,9]. In this section, we present the LSAWfP language and its illustration: the specification of the administrative process used as a running example along this paper. The artifact-centric execution model of LSAWfP's specifications is also presented in order to motivate the current work.

A Running Example: the Peer-Review Process
The peer-review process is a commonly used example of business process to illustrate workflow languages [5,6,7,8,9]. We choose it in this manuscript because it is easy to describe and (that's the most important) it perfectly illustrates the concepts that we handle. The description that we consider is the same as the one in [7]: the process involves four actors (an editor in chief -EC -, an associated editor -AE -and two referees -R1 and R2 -) coordinating to evaluate a manuscript (paper) submitted for their review.
• The process starts when the EC receives the paper; • Upon receipt, the EC pre-validates the paper (let us call this task "A"); after the pre-validation, he can accept or reject the paper for various reasons (subject of minor interest, paper not within the journal scope, non-compliant format, etc.); • If he rejects the paper, he writes a report (task "B") then notifies the corresponding author (task "D") and the process ends; • Otherwise, he chooses an AE and sends him the paper; • The AE prepares the manuscript (task "C") forms a referees committee (two members in our case) and then triggers the peer-review process (task "E"); • Each referee reads, seriously evaluates the paper (tasks "G1" and "G2") and sends back a report (tasks "H1" and "H2") and a message (tasks "I1" and "I2") to the AE; • After receiving reports from all referees, the AE takes a decision and informs the EC (task "F") who sends the final decision to the corresponding author (task "D").

Process Modelling with LSAWfP
LSAWfP is a recent language specifically designed for administrative process modelling. It relies on a variant of attributed grammars to provide a framework for the modelling of the main conceptual aspects of such processes: these are the aspects related to tasks' scheduling (the lifecycle model), to data consumed and produced by tasks (the informational model), and to resources in charge of executing tasks (the organizational model) [25]. In addition, LSAWfP puts a particular emphasis on the modelling (using views) of the perceptions that the various stakeholders have on processes and their data in order to guarantee confidentiality. To model a given process with LSAWfP, four key steps must be followed: (1) model the process scenarios using annotated trees and (2) derive from annotated trees, an abstract grammar which will be used as lifecycle model; then (3) identify the actors involved in the process execution and (4) establish the role played by each of them using a list of accreditations.

Modelling Process Scenarios using Artifacts
LSAWfP is founded on the principle that, by definition, all execution scenarios, all actors and the role they play in relation to tasks of a given administrative process P ad , are known in advance. LSAWfP therefore proposes to model each P ad 's execution scenario using an annotated tree t i called target artifact. In such a tree, each node (labelled X i ) potentially corresponds to a task X i of P ad and each hierarchical decomposition (a node and its sons) corresponds to a scheduling: the task associated with the parent node must be executed before those associated with the son nodes; the latter must be executed according to an order -parallel or sequential -that can be specified by particular annotations " " (is sequential to) and " " (is parallel to) which will be applied to each hierarchical decomposition. The annotation " " (resp. " ") reflects the fact that the tasks associated with the son nodes of the decomposition must (resp. can) be executed in sequence (resp. in parallel).
For the running example (the peer-review process), there is only two execution scenarios: the one in which the EC immediately rejects the paper and the one in which the paper goes through the validation process. These can be modelled using the two artifacts art 1 and art 2 in figure 1. In particular, we can see that art 1 shows how the task "Receipt and pre-validation of a submitted paper" assigned to the EC, and associated with the symbol A (see sec. 2.1), must be executed before tasks associated with the symbols B and D that are to be executed in sequence.

Deducing the Grammatical Model of Workflow (GMWf)
After modelling the scenarios of the studied process using target artifacts, LSAWfP suggests to extract from them, an abstract grammar called a Grammatical Model of Workflow (GMWf). This is done by simply substituting the set of target artifacts by a grammar G (a GMWf) in which, each symbol refers to a task and, each production p is of one of the following two forms: p : X 0 → X 1 . . . X n or p : X 0 → X 1 . . . X n . These two forms of productions perfectly models the two types of ordering (parallel or sequential) retained in the design of the target artifacts. In this case, each target artifact t i is conform to G and we note t i ∴ G; also the root symbols of the different target artifacts make up the set of axioms of G. A GMWf can then be formally defined as follows: • S is a finite set of grammatical symbols or sorts corresponding to various tasks to be executed in the studied business process; • A ⊆ S is a finite set of particular symbols called axioms, representing tasks that can start an execution scenario (roots of target artifacts), and • P ⊆ S × S * is a finite set of productions decorated by the annotations " " (is sequential to) and " " (is parallel to): they are precedence rules. A production P = X P(0) , X P(1) , · · · X P(|P|) is either of the form P : X 0 → X 1 . . . X |P| , or of the form P : X 0 → X 1 . . . X |P| and |P| designates the length of P right-hand side. A production with the symbol X as left-hand side is called a X-production.

Identifying the Actors of the Process
The identification of the actors taking part in the execution of the process is easily done with the help of its textual description. For example, according to the description of the peer-review process, four (k = 4) actors participate in its execution: an editor in chief (EC), an associated editor (AE) and two referees (R1 and R2). So we deduce that the list of actors is L P k = {EC, AE, R1, R2}.

Establishing the List of Accreditations
LSAWfP proposes a mechanism called accreditation, inspired by the nomenclature of rights used in Unix-like systems, to ensure better coordination between actors and to eventually guarantee the confidentiality of certain actions and data.
The accreditation of a given actor provides information on its rights (permissions) relatively to each sort (task) of the studied process's GMWf. There is three types of accreditation: 1. The accreditation in reading (r): an actor accredited in reading on sort X must have free access to its execution state (data generated during its execution). The set of sorts on which an actor is accredited in reading is called his view. Any sort X belonging to a given view V i (X ∈ V i ) is said to be visible, and those not belonging to it are said to be invisible. 2. The accreditation in writing (w): an actor accredited in writing on sort X can execute the associated task 4 . Any actor accredited in writing on a sort is accredited in reading on it.
3. The accreditation in execution (x): an actor accredited in execution on sort X is allowed to ask the actor who is accredited in writing in it, to execute it. More formally, an accreditation is defined as follows: is the set of symbols on which A i is accredited in writing and A A i (x) ⊆ S is the set of symbols on which A i is accredited in execution.
From the task assignment for the peer-review process in the running example, it follows that the accreditation in writing of the EC is A EC(w) = {A, B, D}. Moreover, since he can only execute task D if task C (executed by the AE) is already executed (see artifacts art 1 and art 2 , fig. 1), he must be accredited in execution on C to be able to request its execution; therefore, we have A EC(x) = {C}. In addition, in order to be able to access all the information on the progress of the peer-review evaluation (task C) and synthesize the right decision to be returned, the EC must be able to consult reports (tasks I1 and I2) and messages (tasks H1 and H2) of the referees, as well as the decision made by the AE (task F). These tasks, in Finally the Grammatical Model of Administrative Workflow Process: with LSAWfP, the modelling of a process results in a triplet W f = (G, L P k , L A k ) (called 4 Let's recall that the execution of a task is assimilated to the edition (extension) of a particular node in an artifact. 5 Remember: any actor accredited in writing on a sort is accredited in reading on it.  a Grammatical Model of Administrative Workflow Process -GMAWfP -) wherein,

Actor
G is the GMWf, L P k is the list of actors and L A k is the list of their accreditations.

An Artifact-Centric Model for the Distributed Execution of GMAWfP
The artifact-centric paradigm, emerged in the early 2000s, has become the most exploited current of thought for process modelling and execution (workflow management) over the last two decades [3]. Several works [26,27,28,29,30,31,32,33,34] have been undertaken to develop this paradigm. According to it, workflow management focuses on both automated processes and data manipulated using the concept of business artifact. A business artifact is considered as a document that conveys all the information concerning a particular case of execution of a given business process, from its inception in the system to its termination. In this section, we present an artifact-centric model for the distributed execution of GMAWfP inspired by the work of Badouel et al. on cooperative editing of structured documents [14,15,16,18,19]. We begin by presenting individually, the key concepts of the execution model, before examining the overall behaviour of the distributed system.

Key Elements and Constraints of the Execution Model
The Execution Environment: to execute a given GMAWfP in a decentralized mode, we consider a completely decentralized (P2P) WfMS model (which we call P2P-WfMS-View) whose instances (the peers) are installed on the sites of the various actors involved in processes execution. During the process execution, these peers communicate (sending/receiving requests/responses) by exchanging copies of a (global) artifact said to be under execution. Such an artifact provides information on already executed tasks and on those ready to be executed.
As in the work of Badouel et al. [14,15,16,18,19], we represent an artifact under execution by a tree (a structured document) that contains buds. These indicate at a moment, the only places where contributions are expected. A bud can be either unlocked or locked depending on whether the corresponding task (node) is ready to be executed (edited) or not. Buds are typed; a bud of type X ∈ S is a leaf node labelled either by X ω or by X ω depending on its state (locked or unlocked) (see fig. 2). The local actions of a given actor will therefore have the effect of extending (editing) its received copy of the (global) artifact by developing, through appropriate productions, the different unlocked buds it contains. The Confidential Execution of Certain Tasks: for confidentiality reasons, each actor acts on a potentially partial replica of the local copy of the (global) artifact: this partial replica contains only the information to which the concerned actor can have access. Technically, a partial replica t V i of an artifact t is obtained by projection (using an operator π said of artifact projection) of t according to the view V i of the concerned actor: we note The Need of a Local GMWf at each Site: since the local actions of a particular actor depend on his perception of the process, it is necessary to control them in order not only to preserve the possible confidentiality of certain tasks, but also to ensure the consistency of local updates. To do this, one must derive a local GMWf on each site, by projecting the global GMWf according to the view of the local actor (GMWf projection). This projection is carried out using Π operator and the GMWf obtained is noted The Expansion Operation: still with the aim of ensuring system convergence, the contributions made by a given actor and contained in an updated partial replica t ma j V i , must be integrated into the local copy of the (global) artifact before any synchronization between peers. It is therefore necessary to be able to merge these two artifacts, which are based on two different models. We find here, a version of the expansion problem as formulated in [14].

Execution Model and Peer Activity
Globally then, before the execution of a given process, peers are configured using its GMAWfP (W f = (G, L P k , L A k )). From the global GMWf G and the view V i of the local actor, each peer derives by projection, a local GMWf Then, the execution of a process case is triggered when an artifact t is introduced into the system (on the appropriate peer); this artifact is actually an unlocked bud of the type of one axiom A G ∈ A (initial task) of the (global) GMWf G (see fig. 3).
During execution, peers synchronize themselves by exchanging their local copies of the artifact being executed.
After receiving an artifact t ∴ G on a given peer, the latter projects it (see Peer i in fig. 3) according to the local view V i . The obtained partial replica is then completed (edited) when needed: the result of this edition is an artifact t ma j . At the end of the completion, the expansion-pruning of the obtained updated partial replica t ma j V i ∴ G V i is made in order to obtain the updated configuration t f ∴ G of the (global) artifact local copy (see Peer i in fig. 3). If the resulting configuration shows that the process should be continued at other sites 6 , then replicas of the artifact are sent to them. Else 7 , a replica is returned to the peer from whom the artifact was previously received.

Projection Algorithms for the Distributed Execution of GMAWfP
The GMAWfP execution model is mainly based on three algorithms: artifact projection, GMWf projection and expansion. In this section, we propose versions of these algorithms as well as a study of some of their mathematical properties guaranteeing the correction of the execution model, and the coherence of the distributed system formed by the peers in charge of the execution of a given GMAWfP. Technically, the projection t V i of an artifact t according to the view V i = A A i (r) is obtained by deleting in t all nodes whose types do not belong to V i (all invisible nodes). In our case, the main challenges in this operation are: (1) nodes of t V i must preserve the previously existing execution order between them in t, (2) t V i must be build by using exclusively the only two forms of production retained for GMWf and The projection operation is noted π. Inspired by the one proposed in [14], it projects an artifact by preserving the hierarchy (father-son relationship) between nodes of the artifact (it thus meets challenge (1)); but in addition, it inserts into the projected artifact when necessary, new additional (re)structuring symbols (accessible in reading and writing by the agent for whom the projection is made). This enables it to meet challenge (2). The details of how to accomplish the challenge (3) are outlined immediately after the algorithm (algorithm 1) is presented.  Figure 4 illustrates the projection of an artifact of the peer-review process relatively to the R1 (first referee) and EC (Editor in Chief) views. Note the presence in t V EC of new (re)structuring symbols (in gray). These last ones make it possible to avoid introducing in t V EC , the production p : C → H1 I1 H2 I2 F whose form does not correspond to the two forms of production retained for the GMWf writing 8 .
Let's consider an artifact t and note by n = X [t 1 , . . . ,t m ] a node of t labelled with the symbol X and having m sub-artifacts t 1 , . . . ,t m . Note also by p n , the production of the GMWf that was used to extend node n; the type of p n is either sequential (i.e. p n is of the form p n : X → X 1 . . . X m where X 1 , . . . , X m are the roots of the sub-artifacts t 1 , . . . ,t m ) or parallel (p n : X → X 1 . . . X m ). Concretely, to project t according to a given view V (i.e to find projs t = π V (t)), a depth path of t is performed and invisible nodes are erased or replaced by new nodes associated with (re)structuring symbols to preserve the subtree structure. To do so, the recursive processing presented in algorithm 1, is applied to the root node n = X [t 1 , . . . ,t m ] of t.
Algorithm 1 Algorithm to project a given artifact according to a given view.
• If symbol X is visible (X ∈ V ) then : 1. n is kept in the artifact; 2. For each sub-artifact t i of n, having node n i = X i t i 1 , . . . ,t i k as root (of which p n i is the production that was used to extend it), the following processing is applied : a. The projection of t i according to V is done. We obtain the list projs t If the type of p n i is the same as the type of p n or the projection of t i has produced no more than one artifact (|projs t i | ≤ 1), we just replace t i by artifacts t i V 1 , . . . ,t i V l of the list projs t i ; Otherwise, a new (re)structuring symbol S i is introduced and we replace the subartifact t i with a new artifact new_t i whose root node is n t i = S i t i V 1 , . . . ,t i V l ; 3. If the list of new sub-artifacts of n contains only one element t 1 having n 1 = S 1 t 1 V 1 , . . . ,t 1 V l (with S 1 a newly created (re)structuring symbol) as root node, we replace in this one, t 1 by the sub-artifacts t 1 V 1 , . . . ,t 1 V l of n 1 . This removes a nonimportant (re)structuring symbol S 1 .
• Else, n is deleted and the result of the projection (projs t ) is the union of the projections of each of its sub-artifacts: Note that the algorithm described here applies to all artifacts (including those containing buds) because there is no need to apply any special treatment (locking or unlocking) on buds: they must also be just erased or kept in the artifact to ensure consistency of the execution model. Note also that, this algorithm can return several artifacts (a forest). To avoid that it produces a forest in some cases and thus meet challenge (3), we make the following assumption: GMAWfP manipulated in this work are such that all actors are accredited in reading on the GMWf axioms (axioms' visibility assumption).
The designer must therefore ensure that all actors are accredited in reading on all GMWf axioms. To do this, after modelling a process P ad and obtaining its GMWf G = (S , P , A), it is sufficient (if necessary) to create a new axiom A G on which, all actors will be accredited in reading, and to associate it with new unit productions 9 pa : A G → X a where, X a ∈ A is a symbol labelling the root of a target artifact.
Moreover, the designer of the GMWf must statically choose the actor responsible for initiating the process. This actor will therefore be the only one to possess an accreditation in writing on the new axiom A G .

Studying the Stability Property with the Artifact Projection Algorithm
Proposition 3. For all GMAWfP W f = (G, L P k , L A k ) verifying the axioms' visibility assumption, the projection of an artifact t which is conform to its GMWf (t ∴ G) according to a given view V , results in a single artifact t V = π V (t) (stability property of artifacts through the usage of π).
Proof. Let's show that π V (t) produces a single tree t V which is an artifact. Note that the only case in which the projection of an artifact t according to a view V produces a forest, is when the root node of t is associated with an invisible symbol X (X / ∈ V ). Knowing that t ∴ G and that W f validates the axioms' visibility assumption, it is deduced that the root node of t is labelled by one of the axioms A G of G and that A G ∈ V (hence the uniqueness of the produced tree). Since the projection operation preserves the form of productions, it is concluded that t V = π V (t) is an artifact. Algorithm 2 Algorithm to project a given GMWf according to a given view.
1. First of all, it is necessary to generate all the target artifacts denoted by G (see note (1) below); we thus obtain a set arts G = {t 1 , . . . ,t n }; 2. Then, each of the target artifacts must be projected according to V . We thus obtain a set arts G V = t V 1 , . . . ,t V m (with m ≤ n because there may be duplicates; in this case, only one copy is kept) of artifacts partial replicas; 3. Then, collect the different (re)structuring symbols appearing in artifacts of arts G V , making sure to remove duplicates (see note (2) below) and to accordingly update the artifacts and the set arts G V . We thus obtain a set S V Struc of symbols and a final set just has to use the set of productions to generate the set of artifacts having one of the axiom A G ∈ A as root. In fact, for each axiom A G , it should be considered that every A G -production P = (A G , X 1 · · · X n ) induces artifacts {t 1 , . . . ,t m } such as: the root node of each t i is labelled A G and has as its sons, a set of artifacts {t i 1 , . . . ,t i n }, part of the Cartesian product of the sets of artifacts generated when considering each symbol X 1 , · · · , X n as root node. Note (2): In this case, two (re)structuring symbols are identical if for all their appearances in nodes of the different artifacts of arts G V , they induce the same local scheduling.  5(c)). From the local target artifacts thus obtained, the searched GMWf is produced ( fig. 5(d)). The GMWf projection algorithm presented here only works for GMWf that do not allow recursive symbols 11 . We therefore assume that: For the execution model presented in this paper, the manipulated GMAWfP are those whose GMWf do not contain recursive symbols (non-recursive GMWf assumption).
With this assumption, it is no longer possible to express iterative routing between process tasks (in the general case); except in cases where the maximum number of iterations is known in advance. Proof. Let's show that G V = Π V (G) is a GMWf for a new GMAWfP W f V = G V , L P k , L A V k that verifies the assumptions of axioms' visibility and non-recursivity of GMWf. As W f = (G, L P k , L A k ) validates the non-recursivity of GMWf assumption, the set of target artifacts (arts G = {t 1 , . . . ,t n }) that it denotes is finite and can therefore be fully enumerated. Knowing further that W f validates the axioms' visibility assumption, it is deduced that the set arts

Some Properties of the GMWf Projection Algorithm
is finite and the root node of each artifact t V i is associated with an axiom A G ∈ A (see proposition 3). G V being built from the set arts G V , its axioms A V = A are visible to all actors and its productions are only of the two forms retained for GMWf.
In addition, each new (re)structuring symbol (S ∈ S V Struc )) is created and used only once to replace a symbol that is not visible and not recursive (by assumption) when projecting artifacts of arts G . The new symbols are therefore not recursive. By which is conform to the GMWf G according to a given view V , is an artifact which is conform to the projection of G according to V (∀t, t ∴ G ⇒ π V (t) ∴ Π V (G)).
Proof. Knowing that the considered GMAWfP W f = (G, L P k , L A k ) verifies the axioms' visibility and the non-recursivity of GMWf assumptions, it is deduced that the set of its target artifacts arts G (those who helped to build its GMWf G) is finite and any artifact that is conform to its GMWf G is a target artifact (∀t, t ∴ G ⇔ t ∈ arts G ). Therefore, considering a given artifact t such that t is conform to G (t ∴ G), one knows that it is a target artifact (t ∈ arts G ) and its projection according to a given view V produces a single artifact t V = π V (t) (see "stability property of π", proposition 3) such as t and t V have the same root (one of the axioms A G ∈ A of G). Since t is a target artifact, its projection t V (through the renaming of some potential (re)structuring symbols) is part of the set arts G V of artifacts that have generated G V = Π V (G) by applying the projection principle described in the algorithm 2. Therefore, the productions involved in the construction of t V are all included in the set of productions of the GMWf G V = Π V (G).

As the set of axioms of
Proposition 6. Consider a GMAWfP W f = (G, L P k , L A k ) verifying the axioms' visibility and the non-recursivity assumptions. For all artifact t V which is conform to Π V (G), it exists at least one artifact t which is conform to G such that Proof. With proposition 4 ("stability property of Π") it has been shown that the projection G V = Π V (G) according to the view V of a GMWf G verifying the axioms' visibility and the non-recursivity assumptions, is a GMWf verifying the same assumptions. On this basis and using similar reasoning to that used to prove the proposition 5, it's been determined that an artifact t V that is conform to G V , is one of its target artifacts (local target artifact for the view V ): i.e, t V ∈ arts G V .
Referring to the projection process which made it possible to obtain G V , it is determined that the set arts G V is exclusively made up of the projections of the set arts G = {t 1 , . . . ,t n } of G's target artifacts. t V is therefore the projection of at least one target artifact t i ∈ arts G of G (t V = π V (t i )). Knowing that ∀t, t ∴ G ⇔ t ∈ arts G (see proof of proposition 5), it is deduced that t i ∴ G and the proof of this proposition is made. 2 By applying the GMWf projection algorithm presented above (algorithm 2) to the running example, one obtain the productions listed in table 2 for the different actors respectively. In the illustrated case here, we have considered an update of the GMWf of the peer-review process so that it validates the axioms' visibility assumption.

The Algorithm
Consider an (global) artifact under execution t, and t V = π V (t) its partial replica on the site of an actor A i whose view is V . Consider the partial replica t ma j V ≥ t V obtained by developing some unlocked buds of t V as a result of A i 's contribution. The expansion problem consists in finding an (global) artifact under execution t f , which integrates nodes of t and t V . To solve this problem made difficult by the fact that t and t V are conform to two different models (G and G V = Π V (G)), we perform a three-way merge [35]. We merge the artifacts t and t V using a (global) target artifact t g such that: (a) t is a prefix of t g (t ≤ t g ) V is a prefix of the partial replica of t g according to V t ma j The proposed algorithm proceeds in two steps. Table 2: Local GMWf productions of all the actors involved in the peer-review process.
Step 2 -Merging t, t ma j V and t g The problem here is to find an artifact t f that includes all the contributions already made during the workflow execution. The structure of the searched artifact t f is the same as that of t g : hence the interest to use t g as a guide. The merging is carried out by the algorithm 4. Technically, the three artifacts t, t ma j V and t g are explored in depth simultaneously and a specific treatment is applied according to the configuration of the visited nodes: if the three nodes visited at a given time Algorithm 3 Algorithm to search a merging guide.
1. First of all, we have to generate the set arts G = {t 1 , . . . ,t n } of target artifacts denoted by G; 2. Then, we must filter this set to retain only the artifacts t i admitting t as a prefix (criterion (a)) and whose projections according to V (t i V j ) admit t ma j V as a prefix (criterion (b)). It is said that an artifact t a (whose root node is n a = X a [t a 1 , . . . ,t a l ]) is a prefix of a given artifact t b (whose root node is if and only if the root nodes n a and n b are of the same types (i.e X a = X b ) and: a. The node n a is a bud or, b. The nodes n a and n b have the same number of sub-artifacts (i.e l = m), the same type of scheduling for the sub-artifacts and each sub-artifact t a i of n a is a prefix of the sub-artifact t b i of n b . We obtain the set guides = t g 1 , . . . ,t g k of artifacts that can guide the merging; 3. Finally, we randomly select an element t g from the set guides.

Algorithm 4 Three-way merging algorithm.
A prefixed depth path of the three artifacts (t, t ma j V and t g ) is made simultaneously until there is no longer a node to visit in t g . Let n t i (resp. n t ma j V j and n t g k ) be the node located at the address w i (resp. w j and w k ) of t (resp. t ma j V and t g ) and currently being visited. If nodes n t i , n t ma j V j and n t g k are such that (processing): 1. n t ma j V j is associated with a (re)structuring symbol ( fig. 6(d)) then: we take a step forward in the depth path of t ma j V and we resume processing; 2. n t i , n t ma j V j and n t g k exist and are all associated with the same symbol X ( fig. 6(a) and 6(b)) then: we insert n t ma j V j (it is the most up-to-date node) into t f at the address w k ; if n t ma j V j is a bud then we prune (delete sub-artifacts) t g at the address w k ; we take a step forward in the depth path of the three artifacts and we resume processing. 3. n t i , n t ma j V j and n t g k exist and are respectively associated with symbols X i , X j and X k such that X k = X i and X k = X j ( fig. 6(e)) then: we add n t g k in t f at address w k . This is an upstair bud; we take a step forward in the depth path of t g and we resume processing. 4. n t i (resp. n t ma j V j ) and n t g k exist and are associated with the same symbol X ( fig. 6(c) and 6(f)) then: we insert n t i (resp. n t ma j V j ) into t f at the address w k ; if n t i (resp. n t ma j V j ) is a bud, we prune t g at the address w k ; we take a step forward in the depth path of the artifacts t (resp. t ma j V ) and t g , then we resume processing.
are mergeable (they are of the same type and some are updates of others) then, the most up-to-date node is retained and added to the resulting artifact; otherwise, the nodes preventing the merge are ignored (pruning).

Some Properties of the Expansion Algorithm
Proposition 7. For any update t ma j V in accordance with a GMWf G V = Π V (G), of a partial replica t V = π V (t) obtained by projecting (according to the view V ) an artifact t being executed in accordance with the GMWf G of a GMAWfP verifying the axioms' visibility and the non-recursivity assumptions, there is at least one target artifact (the three-way merge guide) t g ∈ arts G of G such as: V is a prefix of the partial replica of t g according to V t ma j Proof. Thanks to the proposals 4, 5 and the artifact editing model used here 12 , it is established that since the artifact t being executed in accordance with G is a prefix of a non-empty set of G's target artifacts arts G = t 1 , . . . ,t n (∀1 ≤ i ≤ n, t ≤ t i ), its projection t V according to the view V is a prefix of a non-empty set : elements of arts G are potential merging guides candidates that all verify the property (a). In addition, using the propositions 4 and 6, it is established that each element of arts G V is the projection of at least one element of arts G according to the view V (1). Given that t ma j V is obtained by developing buds of t V in accordance with G V , it is inferred that t ma j V is a prefix of a nonempty subset arts ma j G V ⊆ arts G V of local target artifacts for the view V (2). With the proposition 6 once again, it is determined that for each artifact t V j ∈ arts ma j G V , there is at least one artifact t g j that is conform to G such as t V j = π V t g j : this new set arts ma j G = {t g 1 , . . . ,t g k } is made up of potential merging guides candidates that all verify the property (b). Results (1) and (2) show that arts ma j G and arts G are not disjoint. As a consequence, the set guides = arts ma j G ∩ arts G of potential merging guides that all verify both property (a) and (b) is not empty. 2 Corollary 8. For an artifact t being executed in accordance with a GMWf G of a GMAWfP verifying the axioms' visibility and the non-recursivity assumptions, Figure 6: Some particular cases to be managed during the expansion.
and an update t ma j V ≥ t V of its partial replica t V = π V (t) according to the view V , the expansion of t ma j V contains at least one artifact and the expansion-pruning algorithm presented here returns one and only one artifact.
This result (corollary 8) derives from the proof of the proposition 7 (there is always at least one artifact in the expansion of t ma j V under the conditions of corollary 8) and from the fact that in the last instruction of the algorithm 3, an artifact is randomly selected an returned from a non-empty set of potential guides (only one of the expansion artifacts is used in the three-way merging).

A Haskell Implementation of the Algorithm presented in this Work
You can find types and functions (coded in Haskell 13 ) that perform the projections as described in this paper in the following Git 14 repository: https:// github.com/MegaMaxim10/GMAWfP-Projection-Algorithms. These tools have been proposed as a proof of concepts. More specifically, they include types for encoding annotations (sequential, parallel, locked, unlocked, etc.) on artifacts, their nodes and productions. There are also simple types for manipulating productions, artifacts, GMWf,... as well as the actual projection functions. All of these tools are provided in a file that can be directly interpreted using a Haskell interpreter like the Glasgow Haskell Compiler 15 . A readme and comments have been added to make it easier to get to grips with the provided implementation as shown in the screenshot in figure 7.
One observation that can be quickly made by consulting the provided Haskell code is that, it is quite long. This shows that the proposed algorithms are difficult to present with common notations (in pseudo-code form or even directly in code); this is why we have opted to present them with instructions written in natural language and sprinkled with a few mathematical formulas (it was more concise and precise that way). Nevertheless, we have chosen to use Haskell (a functional language) to code our functions because, the Haskell code is generally self-descriptive (i.e. very close to semi-formal descriptions) and more compact than those written in other languages. of them here and discuss our results as we go along.
In their structured cooperative editing model, Badouel et al. [14] proposed a tree projection algorithm operating in the general case: i.e. even in the case in which trees are not annotated and their roots may be invisible; the projection may thus produce a forest. The artifact projection algorithm proposed in this manuscript is a specialization of their own in the case of annotated trees, constructed using only two types of productions: it was therefore necessary to be able to add new (re)structuring symbols during the projection in order to guarantee the stability of models through this operation. Moreover, the scope of application of the algorithm we propose requires that the projection always provides a single artifact: hence the axioms' visibility assumption.
The authors of [14] also proposed a solution to the expansion problem. More precisely, they proposed to associate to the updated partial replica whose expansion is sought, a tree automaton with exit states [18] generating the documents of the expansion. This tree automaton is constructed using the global grammatical model, the considered view and the updated partial replica. In our case, an additional parameter has been added: the global artifact whose partial replica has been updated. This is where the interest of performing a three-way merge comes from. Moreover, we did not need the automaton structure because we made the assumption of nonrecursivity of the manipulated grammatical model. Let us also mention that our expansion is followed by a pruning to better correspond to the field of application of this paper (the decentralized execution of GMAWfP).
About our expansion-pruning algorithm, note that the choice of the merging guide is made randomly from a set of potential candidates. This consideration was made to simplify the work presented here. Indeed, if the initial grammatical model is specified without ambiguity (an ambiguity could come from an execution scenario that contains another one) then there is no problem with this consideration. However, in the presence of a grammatical model subject to design errors, the choice of a three-way merge guide must be made with caution because it determines the continuation of the execution (the scenario to follow): this choice could therefore be made by one of the actors involved in the execution of the process (maybe the process owner). This opens an interesting perspective on the verification of the specifications produced with LSAWfP.
The authors of [16] have proposed a grammatical model for structured cooperative editing. They also proposed an algorithm for projecting a grammar according to a view. Their algorithm proceeds by successive rewrites of the productions whose right hand side contains invisible symbols: the invisible symbols are replaced by the right hand sides of productions for which they appear on the left hand side. The rewrites are made until there are no more invisible symbols. As in our case, (re)structuring symbols are added if necessary and the initial model must not admit recursion: it therefore seems that the projection of grammatical models admitting recursive symbols is an interesting avenue of research. However, our GMWf projection algorithm is completely based on the artifact projection algorithm. Rewritings of the productions are thus implicitly realized during the projection of the artifacts.
In a more general perspective, Foster et al. [36,37] proposed a solution to the view update problem in the case of tree-structured data. More specifically, they offer a domain-specific programming language in which all expressions denote bi-directional transformations on trees. In a sense, these transformations make it possible to project a so-called "concrete tree" in order to obtain a simplified view (a so-called "abstract view") of it. In the other direction, transformation operations allow to merge a modified abstract view with the original concrete tree to obtain a modified concrete tree. The algorithms proposed by Foster et al. manipulate unranked trees (i.e trees with unranked nodes) while ours only manipulate ranked trees. They are therefore not interested by documents models (grammars) which are an essential tools in our study. Let's note also that, the concept of views they use in their work is different from ours; it's rather more close to the one encountered in works on databases [38,39,40,41,42].

Confidentiality using Views in BPM Approaches
We are not aware of many studies that have looked at the consistency of views in the decentralized execution of processes using BPM technology. We hereby present a few that have mentioned the concept of views.
The studies in [43,44,45,46,47,48,49] propose mechanisms for the construction of views guaranteeing the stability of the base models. Here, the views are in fact, process models that guarantee a certain degree of confidentiality. The studies in [43,44,45,46] apply in the case of process-centric workflows, while those in [47,48,49] apply in the case of artifact-centric workflows. The main difference between these studies and ours is that, we manipulate trees and grammatical models where they are interested in arbitrary graphs or stack automata.
In the SwinDeW [50] approach to decentralised workflow management, the authors propose a "know what you should know" policy to manage confidentiality. According to this policy, a workflow is partitioned (projected) into individual tasks after it is modelled completely (using any workflow language), and definition of individual tasks is then distributed to appropriate peers for storage. Unlike ours, the SwinDeW approach is not artifact-centric and the authors do not really propose projection algorithms; rather, they propose a formalism for modelling each task in order to facilitate their distribution and decentralized execution.
Hull et al. [29] proposed a new approach to interoperation of organizations hubs based on business artifacts. It provides a centralized point where stakeholders can access data of common interest and check the current status of an aggregate process. They proposed three kinds of access restrictions namely windows, views and Create-Read-Update-Delete (CRUD). "Windows" provide a mechanism to restrict which artifacts a stakeholder can see; "views" provide a mechanism to restrict what parts of an artifact a stakeholder can see; and the CRUD is used to restrict the ways that stakeholders can read and modify artifacts. This approach differs from ours by the fact that it is centralized and that its confidentiality policy is only interested in the artifacts and not in their models.

Conclusion
In this work, we have presented the LSAWfP language for the specification of administrative workflow processes using grammatical models. We then presented a decentralized and artifact-centric execution model (P2P-WfMS-View) of the workflow processes specified using LSAWfP. Based on the principles of this model, we proposed versions of its key algorithms (algorithm for projecting an artifact, algorithm for projecting a GMWf and algorithm for expanding a partial replica). The proposed algorithms are perfectly usable since we have proven the stability of our main mathematical tools when using them. We have implemented them in Haskell and tested them with very satisfactory results. However, in order for our algorithms to produce the expected results, we have made some assumptions. Notably the nonrecursivity of GMWf assumption, which had the direct effect of limiting a little bit the expressiveness of LSAWfP. An interesting perspective of this work therefore consists in proposing other versions of the algorithms presented here, which would take up the same fundamental principles while raising the non-recursivity of GMWf assumption in order to offer more facility to the designers of GMAWfP.