Business Process Text Sketch Automation Generation Using Large Language Model

1^st Rui Zhu
4^th Honghao Xiao School of Software
Yunnan University
Kunming, China
[email protected] School of Software
Yunnan University
Kunming, China
[email protected] 2^nd Quanzhou Hu
5^th Chaogang Wang School of Software
Yunnan University
Kunming, China
[email protected] School of Software
Yunnan University
Kunming, China
[email protected] 3^rd WenXin Li
6^th Zixin Zhou School of Software
Yunnan University)
Kunming, China
[email protected] School of Software
Yunnan University
Kunming, China
[email protected]

Abstract

Business Process Management (BPM) is gaining increasing attention as it has the potential to cut costs while boosting output and quality. Business process document generation is a crucial stage in BPM. However, due to a shortage of datasets, data-driven deep learning techniques struggle to deliver the expected results. We propose an approach to transform Conditional Process Trees (CPTs) into Business Process Text Sketches (BPTSs) using Large Language Models (LLMs). The traditional prompting approach (Few-shot In-Context Learning) tries to get the correct answer in one go, and it can find the pattern of transforming simple CPTs into BPTSs, but for close-domain and CPTs with complex hierarchy, the traditional prompts perform weakly and with low correctness. We suggest using this technique to break down a difficult CPT into a number of basic CPTs and then solve each one in turn, drawing inspiration from the divide-and-conquer strategy. We chose 100 process trees with depths ranging from 2 to 5 at random, as well as CPTs with many nodes, many degrees of selection, and cyclic nesting. Experiments show that our method can achieve a correct rate of 93.42%, which is 45.17% better than traditional prompting methods. Our proposed method provides a solution for business process document generation in the absence of datasets, and secondly, it becomes potentially possible to provide a large number of datasets for the process model extraction (PME) domain.

Index Terms:

Business Process Management, Business process document generation, Conditional Process Tree, Business Process Text Sketch, divide-and-conquer

I Introduction

Refer to caption — Figure 1: Overall framework. Through a deep cross-track way through the CPT, each processing of a single layer of the CPT is divided into two ways. a. No operator. By using code or rules, BPTS can be generated when processing activities or conditions. b. Involving operators. When operators are involved, it is necessary to consider how to smoothly connect multiple BPTSs into one BPTS, and we draw on the knowledge of LLMs to help us accomplish the task.

With the potential to reduce costs, improve productivity, and achieve higher levels of quality, Business Process Management (BPM) has been attracting more and more attention recently [1]. As an important part of BPM, business process document generation can help companies clarify and standardize business processes and organize and sort out business. On the other hand, business process documentation can be used as an important tool for enterprise communication and collaboration. However, due to the lack of datasets in the field, it is difficult to deliver the performance that deep learning deserves. A closely related domain is Process Model Extraction (PME), which aims to extract business process models from business process description texts using Natural Language Processing (NLP) techniques. Annotated data in this domain is similarly scarce, and data for much of this domain is often not publicly available. To make matters worse, most of the available data is somehow extracted from the dataset originally proposed by Friedrich [2] and can hardly be considered as a reference dataset in practice. The only exception is the dataset proposed by Qian [3], but this dataset is only annotated with words and sentences and does not have a complete process model annotation [4]. Consequently, it is also impossible to use the dataset from the PME domain.

In recent years, Large Language Models (LLMs) [5, 6, 7] have achieved surprising performance on many NLP tasks. To activate the capabilities of LLMs, prompt learning [8] and In-Context learning [9], and prompt engineering¹¹1https://github.com/dair-ai/Prompt-Engineering-Guide are beginning to emerge. Prompt Learning is mainly used in low-resource scenarios, such as Zero-shot learning and Few-shot learning. According to this, we propose a method of using LLMs to automatically generate Business Process Text Sketchs (BPTSs) to alleviate the awkward situation of lacking datasets in the field of business process document generation. The embodiment of BPTSs is natural language, which ignores the semantics of activities and conditions while maintaining the time links between activities in business process descriptions. Theoretically, it can be instantiated as a business process description text for any domain. So when the Conditional Process Tree (CPT) is instantiated, the generated BPTS will also be the instantiated business process description text, thus achieving the purpose of business process document generation. It is worth mentioning that although BPTS ignores the semantic information of activities and conditions, it retains the framework for describing the entire process, including hierarchical and timing relationships. Perhaps what the PME field needs to learn is also about hierarchical and temporal relationships. We can generate a large number of CPT-BPTS pairs using our rules and approach, thus providing a potential possibility to expand the PME domain dataset.

However, traditional prompting methods (Few-shot In-Context Learning) have difficulty in performing extremely well on close-domain and transformation problems with complex hierarchical structures. In order for LLMs to learn the rules for the close-domain problem, we need to give them a lot of domain knowledge and examples, which makes it challenging to manage the prompt template. Currently, there is no reliable method to find the best prompt, and since we use tree-structured input, the CPTs need to be serialized when fed into LLMs using traditional prompting methods, which results in the structural and node information of the CPTs being compressed into one dimension. LLMs not only need to parse the hierarchical structure of CPTs but also have to learn how to translate the hierarchy into the corresponding natural language representation, which increases their burden. We offer an automatic BPTS generation approach to break down a large CPT into numerous basic CPTs and then solve each one separately, drawing inspiration from the divide-and-conquer strategy. For the simple CPTs, we no longer consider them as inference transformation tasks but language rewriting tasks that LLMs are better at. Our main contributions are as follows:

•

For the first time, we suggest using LLMs to create business process documentation in order to address the dearth of datasets in this field.
•

In order to increase the accuracy of CPT to BPTS conversion, we suggest using the divide-and-conquer strategy to break down a complex CPT into simpler CPTs and then solve each one in turn.

The related work is introduced in the second chapter of this paper, and the definitions of the CPT, BPTS, and language rewriting tasks are introduced in the third chapter. The method portion is covered in the fourth chapter, the experimental section is covered in the fifth chapter, this paper’s limits are covered in the sixth chapter, and the conclusion and discussion are covered in the sixth chapter.

II Related Work

II-A Process Model Extraction

There is currently some work accumulated in the Process Model Extraction (PME) field, but many of these datasets are not publicly available. Some publicly available datasets have only a few dozen business process description texts, while others only annotate sentences and words without a complete process model annotation. It is impossible to apply the PME domain dataset to the field of business process document generation. Han et al.[1] proposed the use of Ordered Neuron LSTM (ON-LSTM) to learn language models and their potential semantic hierarchy from Process Definition Documents (PDDs). The dataset they used consists of 210 PDD document graph pairs, which are not publicly available. Qian et al.[3] proposed the Multi Grained Text Classifier (MGTC) to classify sentences in process texts. They conducted experimental evaluations on two publicly available datasets, each containing 2636 and 2172 sentences, constructed from cooking recipes and maintenance manuals, which only labeled the words of some sentences. Zhu et al. [10] improved the Named Entity Recognition (NER) method to identify the active entities in the business process description text and then used ON-LSTM in an unsupervised discovery process to describe the potential hierarchy between the active entities contained in the document. Zhu et al. [11] found that there are some signal entities such as “if”, “after”, etc. in the business process description text. They first obtain the signal entities, conditional entities, and activity entities in the text through sequence annotation, which are called semantic roles. Then, based on predefined rules, a Graph Neural Network (GNN) is constructed using semantic role sequences to predict the temporal relationships of activities in business process documents through multi-layer semantic fusion. They provided some unmarked business process description text. Bellan et al. [12] utilized large-scale Pre-Training Models (PTMs) and In-Context Learning to directly extract activities, participants, and the execution relationships between participants and the activities they perform from business process description texts. Use a small amount of data.

II-B Easy to hard

The divide-and-conquer strategy, which divides difficult problems into manageable ones and solves them sequentially to produce effective results, serves as the inspiration for some works. Zhou et al. [13] proposed a Least-to-Most prompt method, which is divided into Decomposition and Subproblem Solving. For mathematical reasoning problems, they first decompose the problem through LLMs, and then input the decomposed problems into LLMs in turn to obtain the answers. Gao et al. [14] proposed Easy-to-Hard Learning (E2H) to solve the problem of Information extraction. They divided Information extraction tasks into easy stages, hard stages, and main stages. They first trained on the task of the easy stage, then on the task of the hard stage, and finally on the task of the main stage. The goal of the easy stage is to enable the model to learn basic skills to help solve major tasks. The goal of the Hard stage is to construct training samples that are more difficult than the original training samples used to train the model. Main stage training is the main task.

III Preliminaries

Definition 1

Conditional Process Tree. Let A be a finite set of activities, with $\tau\notin A$ representing a silent activity. Let $C$ be a finite set of conditions, $c\in C$ is an arbitrary condition. $\oplus=\{\to,\times,\wedge,\propto\}$ is the set of Conditional Process Tree operators. A Conditional Process Tree is recursively defined as follows:

•

if $a\in A\cup\{\tau\}$ , then $Q=a$ is a Conditional Process Tree,
•

if $c\in C$ , then $Q=a$ is a Conditional Process Tree and
•

if $Q_{1},Q_{2},…,Q_{n}$ are Conditional Process Trees where n $\geq$ 1, and $\oplus\in\{\to,\vee\}$ , then $Q=\oplus(Q_{1},Q_{2},…,Q_{n})$ is a Conditional Process Tree and
•

if $Q_{x},Q_{y}$ are Conditional Process Trees and $c\in C$ is a condition, then $Q=\times\_c(Q_{x},Q_{y})$ is a Conditional Process Tree and
•

if $Q_{x}$ is a Conditional Process Tree and $c\in C$ is a condition, then $Q=\propto(c,Q_{x})$ is a Conditional Process Tree.

According to our definition, the first child node in the CPT is the one on the left, increasing in number from left to right. An example of a CPT is shown in Figure 2. The sequence node “ $\to$ ” indicates that its children are executed in order from left to right. The exclusive node “ $\times\_c$ ” indicates that the first child node is executed when the condition “ $c$ ” is satisfied, otherwise, the second child node is executed. The loop node “ $\propto$ ” indicates that the loop determines whether the condition of its first child node is satisfied, executes the second child node if it is satisfied, and quits the loop if it is not. The parallel node “ $\wedge$ ” means that its children are executed simultaneously. In the figure, $a1$ , $a2$ , $a3$ and $a4$ are codes representing abstract activities. $c1$ and $c2$ are also codes representing abstract conditions. This CPT can be serialized as “ $\to(a1,\times\_c1(\propto(c2,a4),\wedge(a2,a3)))$ ”. Its corresponding BPTS may be “Executing activity a1. If condition c1 is met, the loop judges whether condition c2 is met. If it is met, activity a4 is executed, and once condition c2 is not met, the loop ends. If condition c1 is not met, both activities a2 and a3 are executed at the same time.

Definition 2

Business Process Text Sketch. It is a framework for describing business processes that maintains the timing relationships between activities and ignores the semantic information of activities and conditions.

Definition 3

Language Rewriting Task. It refers to using the knowledge of LLMs to convert input into a natural language that means the same and is consistent with human descriptive habits.

IV Methodology

For simple Conditional Process Trees (CPTs), traditional prompts and Large Language Models (LLMs) can solve the problem, but for complex CPTs LLMs often cannot find patterns. The definition of CPT is a recursive reference definition 1, where a subtree of CPT is also CPT. When processing a CPT, its subtree can be processed in the same way before processing itself. In CPT, the parent node of subtrees is an operator that represents how subtrees are combined. Hence, when subtrees are solved, the parent tree can be simply merged with and solved by the subtrees, and the independent subtrees. To sum up, the conversion of CPT can be solved through the divide-and-conquer algorithm method.

The overall framework of our method is shown in Figure 1. Firstly, we use a deep traversal method to traverse the entire CPT tree. The deep traversal will start at the leaf node, first traverse its child nodes, and then return to itself. This feature is very suitable for our method, where we first build a simple subtree and use the answers obtained to build a more complex parent tree. There are two ways to generate BPTS in the figure. The first is that a leaf node describes an action or a circumstance that does not require LLMs to address it when it is encountered. It is already the smallest unit described in the entire process. The second type is encountered when encountering non-leaf nodes, which are often operators that represent the way in which their sub-activities (resolved) are combined (sequential, exclusive, parallel, loop). Therefore, we use LLMs to handle the operator and its sub-activities. So the input of the prompt needs to be dynamically constructed through code, but the instruction of the prompt remains unchanged.

IV-A Divide And Conquer

The LLM is a sequence-to-sequence model, so when we want to input CPT, we need to serialize it, which will result in the structure information and node information of CPT being compressed into a sequence. This makes it necessary for LLMs to parse the hierarchical structure of CPT and accurately combine the hierarchical structure and node information to transform CPT into a corresponding Business Process Text Sketch (BPTS) at once, increasing the difficulty of transformation. We build BPTS from the underlying simple CPT through deep traversal, drawing inspiration from the divide-and-conquer strategy, and then use the built BPTS as a known outcome to build shallower BPTS. Complex CPT transformation problems will be broken down into a number of simpler ones using our approach. In the algorithm, we only process one layer of simple CPT each time. Please refer to Algorithm 1 for specific details.

input : Instruction

I

and Conditional Process Tree

NODE

output : Business Process Text Sketch

2 This is a recursive algorithm called RecursiveGen;

3 if The current node $NODE$ is a non-leaf node then

4 for child in $NODE$ . $children$ do

// Recursively call yourself

5 subBPTS

\leftarrow

RecursiveGen( $I$ ,child);

// Storage sub Process Sketch

6 pList.append(subBPTS);

8 prompt

\leftarrow

constructPrompt( $I$ ,pList, $NODE.elem$ );

// Prompt Large Language Models

9 BPTS

\leftarrow

ChatGPT(prompt);

10 return BPTS ;

12else

13 if $NODE$ . $type$ == $activity$ then

14 BPTS

\leftarrow

{}^{\prime}execute

activity^{\prime}

NODE.elem

;

16 else

17 BPTS

\leftarrow

NODE.elem

;

19 return BPTS ;

Algorithm 1 Business Process Text Sketch generation algorithm

IV-B Task Conversion

To reduce the decline in performance caused by the reasoning conversion problem of close-domain, we turned this problem into a language rewrite task for LLMs to be better at. We do not consider the handling of leaf nodes, as they are already the smallest unit of process description. We mainly consider the handling of non-leaf nodes. When dealing with non-leaf nodes, we know the operator type of the non-leaf node and the BPTS corresponding to all subtrees of the operator. Instead of attempting to comprehend the transformation rules by using the rich subject information and examples given to LLMs, we now take a more direct approach. By using input that resembles pseudocode to represent the relationship between an operator and the matching BPTS of its subtree, we may instruct LLMs to translate the input into more fluent plain language without altering its original meaning. Domain knowledge was eliminated as a result of the problem’s transformation, and the instruction prompt was altered to “Cover the input into fluent natural language without changing its meaning”. The prompt templates for the four operators are shown in Figure 3. In Algorithm 1, the $constructPrompt$ function completes such construction.

input : maximum depth

DEPTH

, probability of generating zero child nodes

P_{ZERO}

, probability of generating two word nodes

P_{TWO}

, upper bound

NUM_{UP}

and lower bound

NUM_{LOW}

for generating other child nodes

output : Random tree

3 Initialize the queue $Q$ and add the root node $ROOT$ to the $Q$ ;

4 while $Q$ is not empty and current depth is less than $DEPTH$ do

5 node

\leftarrow

Take the first element of the queue

Q

;

// The probability of generating other number of nodes is 1-

P_{ZERO}

P_{TWO}

6 children

\leftarrow

Construct child nodes based on

P_{ZERO}

P_{TWO}

NUM_{UP}

and

NUM_{LOW}

;

7 node.

children

\leftarrow

children ;

8 Queue children ;

10return

ROOT

;

Algorithm 2 Random tree generation algorithm

input : Current node

N

output : Rough Conditional Process Tree

3 This is a recursive algorithm called RCPTGen;

4 if The current node $N$ is a non-leaf node then

5 if The number of child nodes of $N$ is equal to 2 then

6 Node

N

is given as

\to

\times

\propto

\wedge

;

8 else

9 Node

N

is given as

\times

\propto

;

11 if Node $N$ is given as $\times$ then

12 Add condition

c

\times

;

14 for child: $N$ . $children$ do

// Recursively call yourself

15 RCPTGen(child);

18else

19 Node

N

is given activity a;

Algorithm 3 Rough Conditional Process Tree generation algorithm

input : Rough Conditional Process Tree

R

output : Conditional Process Tree

3 Initialize the queue $Q$ , add the root node $ROOT$ of $R$ to the $Q$ and initialize flag $F$ to FALSE;

4 while $Q$ is not empty do

5 if $F$ is FALSE then

6 node

\leftarrow

Take the first element of the queue

Q

;

F

\leftarrow

FALSE;

9 if The current node node is a non-leaf node then

10 for child: node. $children$ do

11 if The operator of node is the same as the operator of child, and is $\to$ or $\wedge$ then

12 Remove the child node child ;

F

\leftarrow

TRUE;

15 else if The operator of node is $\propto$ then

16 Replace the first child node with condition c;

F

\leftarrow

TRUE;

19 else

20 Queue child ;

Algorithm 4 Conditional Process Tree generation algorithm

IV-C Dataset Generation

Due to CPT’s structured nature, rules may be used to generate it in huge quantities, and when combined with our way to create process description text, the outcome is a large number of CPT-BPTS pairings that could potentially be PME domain datasets. The CPT is generated using the following rules: 1) Add a random number of child nodes to produce a random tree without node information. The precise method entails first defining the maximum $depth$ , the probability of creating zero child nodes $p_{zero}$ , the chance of generating two child nodes $p_{two}$ , and the lower and upper bounds of other numbers of generating child nodes $num_{low}$ and $num_{up}$ . Use breadth-first traversal to haphazardly add zero, two, or other numbers of child nodes to the current node. The depth of the created conditional process tree is less than or equal to depth since it will generate a zero number of child nodes. Refer to Algorithm 2. 2) According to the rules of CPT, nodes are assigned elements with a certain probability, which can be operators, conditions, and activities. The rule is as follows: a. If the number of sub-nodes of the current node is equal to 2, the operators $\to$ , $\times$ , $\wedge$ or $\propto$ can be assigned; b. If the number of child nodes of the current node is greater than 2, the operators $\to$ or $\wedge$ can be assigned; c. If the current node has no child nodes, assign an activity; refer to Algorithm 3. 3) There are three irrational structures in the CPT that were produced using this rule: a. The child node is $\to$ , and its parent node is also $\to$ . b. The child node is $\wedge$ , and its parent node is also $\wedge$ . c. The current node is $\propto$ , and its first child node is not a condition. Therefore, it is necessary to conduct a rationalization check on the CPT and remove or replace unreasonable subtrees, as shown in Algorithm 4.

V Experiments

We contrasted our suggested approach with traditional prompts to show its efficacy, as shown in Figure 4. The traditional prompt template consists of six components, whose names and purposes are shown below: 1) Instruction. The tasks that Large language Models (LLMs) are expected to complete. 2) Context. Introduction to background knowledge. 3) Prompt. Prevent LLMs from learning some toxic laws. 4) Example. Introduce Few-shot Learning. 5) Output Indicator. Specify the output format. 6) Conditional Process Tree. Input the Conditional Process Tree (CPT) sequence. We carefully selected CPTs of various difficulty levels. As shown in Table I, the depth range of the conditional process tree is from 2 to 5, and every depth includes every operator. There are other CPTs that include many levels of loops and selections, with a maximum nesting level of 3. Finally, some CPTs with a number of nodes greater than 15 were selected. A total of 100 CPTs were selected.

TABLE I: Composition of test dataset

Aspect	Type	Number
Depth	= 2	10
	= 3	20
	= 4	20
	= 5	20
Multilayer	Loop	10
Multilayer	Selection	10
Number of nodes	>15	10
Total	Category 7	Quantity 100

TABLE II: Test dataset statistics.

Aspect	Type	Number
Activity	Max	20
Activity	Min	1
Node	Max	29
Node	Min	3
Operator	Max	12
Operator	Min	1
Multi-layer Selection	= 2 or 3	18
Multi-layer Loop	= 2 or 3	17

The statistics of the selected CPTs are displayed in Table II. 29 nodes are the maximum number, 20 activities are the maximum number, and 12 operators are the maximum number. For multilayer selection and looping, there are 18 and 17 CPTs, respectively.

The “gpt-3.5 turbo” model is what we use because it is the most potent model that OpenAI can access at the moment. To ensure the certainty of the answer generated by the model, we set the API parameter $temperature$ to 0, Set $top\_p$ to 1, and $n$ to 1. All other parameters have default values. Due to the lack of Source text, we enlisted the help of three graduate professionals to assess the effectiveness of creating Business Process Text Sketches (BPTSs). The evaluation criteria are: A score of 1 will be awarded if the generated BPTS completely matches the input CPT, there is no ambiguity, and the language is fluent. A score of 0 will be assigned if the generated BPTS and the input CPT do not agree. In the case of ambiguity in the generated BPTS, the score is based on the likelihood of correct understanding. For example, if there is an ambiguity, the likelihood of correct understanding is 0.5, so the score is 0.5. If there is complete correspondence, no ambiguity, but the language is not smooth, the evaluator’s own feelings must be scored, and the score must be greater than 0.5.

V-A Overall performance

We asked three evaluators to score the 100 data points generated using traditional prompts and the 100 data points generated using our approach according to the evaluation criteria. We took the average score of the three evaluators as the final score.

As shown in Table III, our proposed method performs better overall than the traditional prompt method, with an overall accuracy improvement of 45.17%. We compare the performance of the two methods from six aspects: the depth of the CPT, multi-layer loops, multi-layer selection, number of activities, number of operators, and number of nodes. In Table II, we take the average of the maximum and minimum number of activities as the segmentation line for simple and complex CPTs. Similarly, the number of operators and nodes is divided in the same way. From Figure 5, it can be seen that the accuracy of CPT conversion is 1.0 for the depth of 2. In addition, the performance of traditional prompts is lower than our method, and our method can greatly improve the accuracy of CPT conversion. In the conversion task of complex CPTs, our method has more obvious advantages, especially in the conversion of CPTs with a large number of nodes. The accuracy of our method is 10 times that of traditional prompts. Obviously, regardless of the method, as the complexity of CPT increases, its conversion accuracy will decrease.

TABLE III: Overall performance

Method	Accuracy
Traditional	48.25
Ours	93.42*

V-B Error analysis

There are four main issues in the generated BPTS, namely: 1) loop condition errors. The correct BPTS should be “execute the following activity cyclically if the condition is met”, but the generated BPTS should be “execute the following activity cyclically if the condition is not met”. 2) Language confusion. When the input CPT has a cross-layer parallel structure, the parallel expression statements of the generated BPTS will become chaotic, making it difficult to understand the generated BPTS. 3) Parallel and sequential cannot be distinguished. In parallel statements, “followed by” will appear, while in sequential statements, “at the same time” will appear. 4) Hierarchy parsing error. When there are too many operators and the hierarchy is deep, this error is likely to occur. Some examples of errors are shown in Appendix A-A.

V-C Case 1 business process document generation

After the CPT is instantiated, it can be converted into business process description text through our method. We chose an instantiated CPT with a maximum number of layers not exceeding the experimental maximum, which mainly describes the business process of bank lending, as shown in Figure 6.

The business process description text generated using our method is shown in Figure 7. The generated usability process description text is unexpected; for example, the condition describes “greater than”, and the opposite of the condition in the output BPTS is “less than or equal” rather than just “less than”.

V-D Case 2 dataset generation

Our algorithm can quickly generate a large number of CPTs. Among the generated 2500 CPTs, the maximum depth is 5, the maximum number of nodes is 40, the maximum number of activities is 25, and the maximum number of operators is 20. Generating 2500 CPTs with a maximum depth of 5 takes less than 2 seconds. We have selected three examples that are relatively difficult but have high-quality generated text. These three examples have different styles of descriptions, as shown in Appendix A-B.

VI Limitation

The style of the BPTS generated by our method mainly depends on the style of the prompt template. Although the generated BPTS can accurately describe the CPT, it is closely related to the narrative style of the prompt template, and sometimes it may generate BPTS that do not conform to human descriptive habits. Furthermore, it is clear from the example of generating errors that there is a strong likelihood that the prompt is to blame for the error in generating BPTS. It is undeniable that the quality of prompt templates will directly affect the quality of generating BPTS, and we do not have a method to improve the quality of prompt templates. In addition, although our method generates BPTS with high accuracy, there is no method to detect the quality of the generated BPTS.

VII Conclusion And Disscusion

We propose a method for automatically generating Business Process Text Sketchs using a Large Language Model. Divide-and-conquer strategy-inspired, we broke down a complex CPT into numerous simple CPTs and solved each one separately. Then, we transformed the simple CPT inference transformation task into a language rewriting task that LLMs are better at. Experiments have shown that our method can achieve higher accuracy in generating BPTS compared to traditional prompt methods. Our work alleviates the awkward situation of lacking datasets in the domain of business process document generation, and our method also provides potential possibilities for dataset generation in the PME domain.

References

[1] Xue Han, Lianxue Hu, Lijun Mei, Yabin Dang, Shivali Agarwal, Xin Zhou, and Pengwei Hu. A-bps: automatic business process discovery service using ordered neurons lstm. In 2020 IEEE International Conference on Web Services (ICWS), pages 428–432. IEEE, 2020.
[2] Fabian Friedrich, Jan Mendling, and Frank Puhlmann. Process model generation from natural language text. In Advanced Information Systems Engineering: 23rd International Conference, CAiSE 2011, London, UK, June 20-24, 2011. Proceedings 23, pages 482–496. Springer, 2011.
[3] Chen Qian, Lijie Wen, Akhil Kumar, Leilei Lin, Li Lin, Zan Zong, Shu’ang Li, and Jianmin Wang. An approach for process model extraction by multi-grained text classification. In Advanced Information Systems Engineering: 32nd International Conference, CAiSE 2020, Grenoble, France, June 8–12, 2020, Proceedings 32, pages 268–282. Springer, 2020.
[4] Patrizio Bellan, Mauro Dragoni, and Chiara Ghidini. Process extraction from text: state of the art and challenges for the future. arXiv preprint arXiv:2110.03754, 2021.
[5] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.
[6] OpenAI. Gpt-4 technical report, 2023.
[7] Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al. Sparks of artificial general intelligence: Early experiments with gpt-4. arXiv preprint arXiv:2303.12712, 2023.
[8] Timo Schick and Hinrich Schütze. Exploiting cloze questions for few shot text classification and natural language inference. arXiv preprint arXiv:2001.07676, 2020.
[9] Sewon Min, Xinxi Lyu, Ari Holtzman, Mikel Artetxe, Mike Lewis, Hannaneh Hajishirzi, and Luke Zettlemoyer. Rethinking the role of demonstrations: What makes in-context learning work? arXiv preprint arXiv:2202.12837, 2022.
[10] LI Tong ZHU Rui, LV Changlong. Automatic business process model deep generation based on ordered neurons long short term memory. Computer Integrated Manufacturing System, 28(10):3225–3238, 2022.
[11] Rui Zhu, Wenxin Li, and Canchang Jin. Tag: Uml activity diagram deeply supervised generation from business textural specification. In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 956–961. IEEE, 2023.
[12] Patrizio Bellan, Mauro Dragoni, and Chiara Ghidini. Extracting business process entities and relations from text using pre-trained language models and in-context learning. In International Conference on Enterprise Design, Operations, and Computing, pages 182–199. Springer, 2022.
[13] Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Olivier Bousquet, Quoc Le, and Ed Chi. Least-to-most prompting enables complex reasoning in large language models. arXiv preprint arXiv:2205.10625, 2022.
[14] Chang Gao, Wenxuan Zhang, Wai Lam, and Lidong Bing. Easy-to-hard learning for information extraction. arXiv preprint arXiv:2305.09193, 2023.

Appendix A Appendix

A-A Error generations

TABLE IV: Example of error generation

Conditional Process Tree	Business Process Text Sketch	Reason for error
$\propto(c1,\to(a\_4,\propto(c2,a\_6)))$	Continuously check condition c1 until it is no longer true. If c1 is true, execute activity a_4 and then continuously monitor condition c2 until it becomes false. Once c2 is false, perform activity a_6.	Loop condition error
$\to(a\_1,a\_2,\wedge(\to(a\_3,\wedge(a\_4,$ $a\_5,a\_6,a\_7)),\to(\times\_c1(a\_8,$ $a\_9),\propto(c2,a\_11),\wedge(a\_12$ $,a\_13,a\_14,a\_15,a\_16),$ $a\_17,a\_18),a\_19,a\_20,a\_21$ $))$	The following steps will be carried out in a specific order. First, we will execute activity a_1, followed by activity a_2. Next, we will perform five steps concurrently. In the first step, we will execute activity a_3, and then in the next four steps, we will execute activities a_4, a_5, a_6, and a_7 simultaneously. In the second step, we will execute activity a_8 if condition c1 is met, otherwise, we will execute activity a_9. We will then continuously check condition c2 until it is no longer true. Once it becomes true, we will run activity a_11. After that, we will execute five steps simultaneously, which include activities a_12, a_13, a_14, a_15, and a_16. In the fourth step, we will execute activity a_17, and finally, in the fifth step, we will execute activity a_18. In the third step, we will execute activity a_19, and in the fourth step, we will execute activity a_20. Lastly, in the fifth step, we will execute activity a_21.	Language confusion
$\to(a\_1,\propto(c4,a\_6),\wedge(\to(a\_7,$ $a\_8,\times\_c2(a\_9,a\_10)),a\_11,$ $a\_12,a\_13),\times\_c3(a\_14,$ $a\_15))$	The following steps will be carried out in a specific order. First, activity a_1 will be executed. Then, condition c4 will be continuously checked until it is no longer true. Once it becomes true, activity a_6 will be run. At the same time, four steps will be carried out simultaneously. The first step involves executing activity a_7, followed by activity a_8. If condition c2 is met, activity a_9 will be executed, but if it is not met, activity a_10 will be executed instead. The second step involves executing activity a_11, the third step involves executing activity a_12, and the fourth step involves executing activity a_13. Finally, if condition c3 is met, activity a_14 will be executed. However, if condition c3 is not met, activity a_15 will be executed instead.	Sequential relationships become parallel

A-B Successful generations

TABLE V: Three examples of successful generations with different styles

Conditional Process Tree	Process description text
$\wedge(a\_1,\times\_c1(a\_2,\wedge(a\_3,\times\_c2(a\_4,a\_5))),a\_6,$ $\propto(c4,\to(\wedge(a\_11,a\_12,a\_13),\propto(c5,a\_15),a\_16,$ $\wedge(a\_17,a\_18,a\_19,a\_20,a\_21))))$	There are four steps that will be carried out at the same time. The first step is to execute activity a_1. The second step involves checking if condition c1 is met. If it is, activity a_2 will be executed. If not, two steps will be taken simultaneously. The first step is to execute activity a_3, while the second step is to check if condition c2 is satisfied. If it is, activity a_4 will be executed. If not, activity a_5 will be executed instead. The third step is to execute activity a_6. The fourth step involves continuously checking condition c4 until it is no longer satisfied. If it is, a specific process will be followed that involves multiple steps. Firstly, activities a_11, a_12, and a_13 will be executed simultaneously. Secondly, condition c5 will be continuously checked until it is no longer true. Once it becomes true, activity a_15 will be executed. Thirdly, activity a_16 will be executed. Lastly, activities a_17, a_18, a_19, a_20, and a_21 will be executed simultaneously in five steps.
$\to(\times\_c1(\times\_c2(a\_1,a\_2),a\_3),\wedge(a\_4,\times\_c3(a\_5$ $,a\_6)),a\_7)$	The following steps will be carried out in a specific order. First, if condition c1 is met, activity a_1 will be executed only if condition c2 is also met. However, if condition c2 is not met, then activity a_2 will be executed instead. If condition c1 is not fulfilled, then activity a_3 will be executed. Secondly, two steps will be carried out simultaneously. The first step involves executing activity a_4. The second step involves checking if condition c3 is met. If it is met, activity a_5 will be executed. If it is not met, activity a_6 will be executed instead. Lastly, activity a_7 will be executed.
$\to(\propto(c3,\propto(c4,a\_7)),a\_8,\wedge(\propto(c5,a\_10),\to($ $\times\_c2(a\_11,a\_12),\wedge(a\_13,a\_14,a\_15,a\_16,a\_17$ $))))$	The process will follow these steps in order: 1. Check condition c3 continuously until it is no longer true. Once it is met, check condition c4 until it is no longer true. When c4 becomes true, execute activity a_7. 2. Execute activity a_8. 3. Two steps will occur simultaneously. The first step involves continuously checking condition c5 until it is no longer true. Once c5 becomes true, run activity a_10. The second step will proceed as follows: if condition c2 is met, perform activity a_11. If not, perform activity a_12 instead. After that, execute activities a_13, a_14, a_15, a_16, and a_17 simultaneously.