📄 other

A Scoring-Based Approach for Structuredness-Aware Business Process Classification

This paper proposes and evaluates a scoring-based approach that automatically classifies business processes into structuredness categories (structured, semi-structured, loosely structured, and unstructured) by analyzing fine-grained temporal and existential activity relationships within event logs to address the lack of automated support in process mining.

Original authors: Kerstin Andree, Ivan Kuzmin, Luise Pufahl

Published 2026-07-24

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Kerstin Andree, Ivan Kuzmin, Luise Pufahl

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are walking through a giant, bustling city. Some parts of the city are like a subway system: the tracks are laid out, the trains run on a strict schedule, and you know exactly where you will end up if you get on at the right station. Other parts are more like a jazz festival or a chaotic street fair; people wander, conversations start and stop randomly, and the path you take depends entirely on who you bump into and what mood you're in. In the world of business, companies run on "processes"—the step-by-step recipes they use to get things done, like processing an invoice or treating a patient. Some of these recipes are rigid and predictable (like the subway), while others are flexible and messy (like the street fair).

For a long time, computers that analyze these business recipes (a field called "process mining") have been great at mapping out the subway lines. But they've struggled to automatically tell the difference between a rigid subway and a chaotic street fair. They can see the lines, but they can't easily say, "This process is super structured," or "This one is totally loose." This matters because if you try to manage a street fair like a subway, you'll crush the creativity. If you treat a subway like a street fair, you'll cause chaos. The big question is: Can we teach a computer to look at the messy data of a business and instantly know what kind of process it is?

This paper, written by researchers at the Technical University of Munich, says "Yes, we can." They built a new tool that acts like a detective for business processes. Instead of just counting how many different paths a process takes, their tool looks at the tiny relationships between every single step. They found that by giving points (a "score") to specific types of relationships—like "Activity A must happen before Activity B" versus "Activity A and B can happen whenever they want"—they can automatically sort any business process into one of four categories: Structured (the rigid subway), Semi-Structured (a mix of both), Loosely Structured (the flexible street fair), or Unstructured (pure chaos).

Here is how their detective work actually happens, using a simple analogy. Imagine you are trying to figure out the personality of a group of friends just by watching how they hang out.

The Old Way: You might just count how many times they go to the park together. If they go often, you think they are a tight-knit group. But this misses the nuance.
The New Way (This Paper): You look at the specific rules of their friendship. Do they always sit in the same order? (That's a "temporal dependency"). If one person shows up, does another have to show up too? (That's an "existential dependency").

The researchers realized that different "personalities" of processes have different "friendship patterns."

Structured processes are like a military drill. If you see a pattern where "Step A is always followed immediately by Step B," that's a huge clue. It's a rigid rule.
Loosely structured processes are like a group of friends at a party. "Step A might happen, or it might not," and "Step B could happen before A, or after A, or not at all." This is a pattern of independence.

The team created a computer algorithm that scans a log of business activities (like a diary of everything that happened) and builds a giant scoreboard. It counts how many times it sees "rigid rules" versus "flexible freedom." Then, it applies a special set of weights. Think of it like a video game scoring system:

If the log is full of "Directly Follows" (A then B, no exceptions), the Structured team gets +3 points.
If the log is full of "Independence" (A and B have no rules), the Loosely Structured team gets +2.5 points.
If the log is a mix, the Semi-Structured team gets points.

The computer adds up all the points for each category. The category with the highest score wins. If the top two scores are very close, the computer admits, "I'm not sure, this is a borderline case," which is actually a very honest and useful answer.

To test if their scoreboard worked, the researchers did two things. First, they created fake business processes in a computer simulation. They made some that were perfectly rigid, some that were totally chaotic, and some that were in between. Their algorithm got it right 100% of the time on the clean fake data, and even when they added "noise" (fake mistakes or random glitches to the data), the tool was smart enough to ignore the noise and still find the right answer.

Second, they wanted to see if humans could do it better. They showed eight different process maps to 13 experts (people who study business processes) and asked them to guess the category. The results were interesting:

The experts were great at spotting the extremes. Everyone agreed on the super-rigid processes and the super-chaotic ones.
But when it came to the messy middle ground (the semi-structured and loosely structured ones), the humans disagreed. Some thought a process was "semi-structured," others thought it was "loosely structured." It was hard for them to tell the difference.

The computer, however, was consistent. It matched the experts on the easy cases and provided a clear, objective label for the messy middle cases where humans were confused. For example, one real-world process (a game called ChickenHunt) was classified by the computer as "loosely structured." The experts mostly agreed, noting that players had total freedom to choose their moves. Another process, a standard insurance claim, was correctly identified as "semi-structured" because it had rigid parts mixed with flexible choices.

The paper doesn't claim this is a magic wand that solves every problem forever. The authors admit that their tool works best when the data is relatively clean and that the "scoring weights" they used were tuned based on their specific simulations. They also note that if a process is truly "unstructured" (meaning absolutely no rules exist at all), it's a bit of a theoretical edge case, but their tool can still spot it because it sees only independence and no rules.

In the end, this paper suggests that we don't need to guess whether a business process is a subway or a street fair. By looking closely at the tiny rules (or lack of rules) between every single step, a computer can automatically score the process and tell us exactly what kind of beast it is. This helps companies decide how to manage their work: do they need strict rules and checklists, or do they need to give their employees the freedom to be creative? The tool provides a clear, automated answer to that question, turning a confusing mess of data into a simple, understandable label.

Technical Summary: A Scoring-Based Approach for Structuredness-Aware Business Process Classification

Problem Statement

Business processes vary significantly in their degree of predictability and flexibility, ranging from highly standardized workflows to loosely structured, knowledge-intensive activities. This spectrum is typically categorized into four classes: structured, semi-structured, loosely structured, and unstructured. Identifying a process's level of structuredness is critical for organizations as it dictates the selection of appropriate modeling paradigms (e.g., imperative vs. declarative languages) and informs governance and improvement initiatives.

However, current process mining techniques lack automated support for assessing process structuredness directly from event logs. Existing approaches often rely on manual analysis of trace variants or require domain experts to interpret behavioral patterns, which introduces subjectivity and scalability issues. Furthermore, existing discovery algorithms often map behavioral patterns to specific modeling languages (e.g., BPMN or Declare) rather than providing an automated, language-agnostic classification of the underlying process behavior. The central research question addressed is: How can we automatically classify the level of structuredness for a given process by observing behavioral patterns in an event log?

Methodology

The proposed approach is a scoring-based classification system that operates in two primary stages: (1) the automated discovery of fine-grained activity relationships from event logs, and (2) the application of a weighted scoring heuristic to classify the log into a structuredness class.

1. Extended Activity Relationships Notation

To capture process behavior more precisely than traditional Directly Follows Graphs (DFGs), the authors extend the activity relationships notation introduced by Andree et al. [14]. This notation distinguishes between two dimensions of dependency:

Temporal Dependencies ( $d_{temp}$ ): The ordering of activities. The authors introduce a "true eventual" dependency ( $\prec_t$ ) to explicitly exclude direct succession, differentiating it from standard eventual dependencies. They also distinguish between no observed ordering ( $x$ ) and bidirectional ordering ($-$) for parallel activities.
Existential Dependencies ( $d_{exist}$ ): The occurrence dependencies between activities (e.g., implication, co-occurrence, independence).

This dual-dimensional approach allows for a more nuanced characterization of process behavior, separating when activities occur from whether they occur.

2. Relationship Discovery Algorithm

The authors developed a discovery algorithm (Algorithms 1 and 2) that takes an event log as input and constructs an Activity Relationships Matrix.

Preprocessing: The algorithm employs an automatic, trace-level noise filtering mechanism. It derives a minimum variant frequency threshold using a gap-based estimator and a size-aware floor-based estimator to separate legitimate process variants from noise without relying on arbitrary tolerance parameters.
Temporal Discovery: The algorithm analyzes the order of activity pairs across traces, utilizing Strongly Connected Components (SCCs) to handle loops and distinguishing between direct, eventual, and true eventual dependencies.
Existential Discovery: The algorithm classifies traces based on the presence or absence of activity pairs to determine existential types (e.g., implication, co-occurrence, independence).
Validation: The algorithm was validated on synthetic logs containing various control-flow patterns (parallelism, XOR, loops, nesting). It achieved 100% accuracy in discovering both temporal and existential dependencies in noise-free logs and maintained this accuracy in noisy logs after applying the trace-level filter.

3. Scoring-Based Classification Heuristic

Once the activity relationships matrix is generated, a scoring algorithm classifies the log into one of the four structuredness classes ($S, SS, LS, US$).

Pre-filtering: A specific pre-filter identifies Unstructured (US) processes. If all activity pairs share the exact same temporal and existential type (specifically independence) and no direct-follows relationships exist, the process is classified as unstructured.
Weighted Scoring: For the remaining classes, the algorithm computes a weighted score based on the distribution of relationship types.
- Marginal vs. Joint Ratios: The system calculates the ratio of each relationship type. It employs a dominance-based selection mechanism: if a specific joint combination of temporal and existential dependencies (e.g., temporal independence + existential implication) dominates a marginal slot (exceeding a threshold $\theta = 0.35$ ), a specific joint weight is applied. Otherwise, a marginal weight is used.
- Class-Specific Weights: Weights are assigned based on the definitions of structuredness classes. For example, direct temporal dependencies and existential co-occurrences receive high positive weights for the Structured class, while existential independence receives high positive weights for Loosely Structured and negative weights for Structured.
Borderline Detection: If the score margin between the top two classes falls below a threshold ( $\delta = 0.2$ ), the output is flagged as a borderline case (e.g., $S/SS$).

Key Contributions

Automated Structuredness Classification: The paper proposes the first automated approach to classify event logs into structuredness classes ($S, SS, LS, US$) without requiring manual intervention or reference models.
Extended Notation and Discovery Algorithm: The authors introduce an extension to the activity relationships notation (including "true eventual" dependencies) and a corresponding discovery algorithm that extracts these relationships directly from event logs, overcoming the limitation that previous methods required manual derivation from BPMN diagrams.
Synthetic Dataset: A dataset of 38 labeled synthetic event logs was generated to train and validate the classification heuristic, covering the full spectrum of structuredness.
Empirical Validation: The approach was evaluated against both the synthetic dataset and a survey of human experts classifying real-world and synthetic processes.

Results

Algorithmic Accuracy: The discovery algorithm achieved 100% accuracy in identifying temporal and existential dependencies on synthetic logs, even in the presence of noise, provided the trace-level filtering was applied.
Classification Performance:
- In the evaluation involving 8 processes (P1–P8) and 13 participants, the algorithm's classifications aligned with expert assessments and ground truth derived from literature for most cases.
- For Structured (P3, P4) and Unstructured (P8) processes, the algorithm achieved high agreement with experts.
- For Semi-structured (P1, P2) processes, the algorithm correctly identified the dominant characteristics, aligning with the majority of expert opinions.
- For Loosely Structured (P5, P6, P7) processes, the results were mixed. In P5, the algorithm classified the process as semi-structured while literature described it as loosely structured. The authors attribute this to the "distributed flexibility" of real-world logs, where independence is spread across multiple temporal types rather than concentrated in a single dominant joint pattern, causing the dominance-based scoring to default to marginal weights.
Human vs. Machine: The survey revealed that manual classification is generally easy for processes at the extremes (highly structured or unstructured) but becomes significantly more difficult for intermediate levels (semi-structured and loosely structured). This highlights the value of an automated approach for handling the cognitive complexity of distinguishing intermediate structuredness levels.

Significance and Claims

The paper claims to provide a systematic and objective foundation for process structuredness analysis. By linking structuredness classes to interpretable activity dependency patterns, the approach offers a reproducible alternative to manual expert assessment.

The authors emphasize that their contribution is not a "black box" machine learning model but a theory-driven, score-based approach that explicitly connects classification outcomes to specific behavioral characteristics (e.g., the prevalence of independence vs. direct succession). This interpretability is presented as a key advantage for process analysis and decision-making.

The paper modestly acknowledges limitations:

The classification relies on the quality of the underlying discovery algorithm and noise filtering.
The dominance-based mechanism may struggle with real-world logs where flexibility is distributed rather than concentrated, potentially leading to borderline classifications for complex processes.
The "Unstructured" class is treated as a theoretical edge case, and its empirical occurrence in real-world settings remains an open question.
The approach currently requires a clear gap in variant frequency distributions for optimal noise filtering; in highly variable logs without such gaps, the fallback mechanism may be less precise.

Ultimately, the work aims to enable organizations to automatically characterize their processes, thereby facilitating the selection of appropriate modeling paradigms and supporting process maturity assessments without the need for extensive manual analysis or pre-existing reference models.