A Direct QUBO Formulation for Alignment-Based Conformance Checking: A Preliminary Quantum Annealing Study

1. Introduction

Process mining studies how event data can be used to analyze, monitor, and improve real processes (van der Aalst 2016). Within this area, conformance checking compares the behavior recorded in an event log with the behavior allowed by a process model (Carmona et al. 2022). One of the most informative techniques for this task is based on alignments, which explain a trace as a sequence of synchronous moves, log moves, and model moves (van der Aalst et al. 2012). Because log-level conformance is computed by solving this problem repeatedly for traces or trace variants, optimal alignment finding is a core computational task behind alignment-based conformance checking.

Optimal alignments, however, can be expensive to compute: for important classes of process models the problem is computationally hard, and the cost grows quickly with model size, trace length, and control-flow complexity (Schwanen et al. 2025). Alignment-based conformance checking can thus become costly exactly where it is most informative. Previous work on SAT and MILP encodings shows that alignment finding can be expressed in general optimization formalisms beyond classical shortest-path search (Boltenhagen et al. 2021,Chatain and Carmona 2016,Schwanen et al. 2024), so it is natural to ask whether the same problem can be encoded in a form compatible with quantum optimization.

In this paper, we study the alignment problem through the lens of Quadratic Unconstrained Binary Optimization, or QUBO (Punnen 2022). A QUBO represents an optimization problem over binary variables using linear and quadratic terms, and it can be handled by exact solvers, classical heuristics, and quantum annealers (Rajak et al. 2022), so one representation can be explored across different computational backends. Current hardware faces strong connectivity and embedding constraints, so quantum annealing is not yet ready for practical conformance checking, but a QUBO formulation lets us study in a controlled way whether alignment semantics can be translated faithfully into a quantum-compatible optimization problem.

Our focus is deliberately narrow: we neither study end-to-end log conformance on industrial event logs nor claim that quantum hardware already outperforms strong classical conformance checking algorithms. Instead, we present a direct QUBO formulation for optimal alignments on safe Petri nets, together with a proof-of-concept implementation that supports exact solving, classical simulated annealing, and execution on a D-Wave Advantage2 quantum processing unit (D-Wave Systems 2025a). The goal is to understand whether this formulation is semantically correct, when it appears promising, and what currently prevents it from scaling. The paper synthesizes and refines ideas first developed in a M.Sc. thesis (Geuskens 2026a).

This paper is therefore a preliminary study with a mixed but informative empirical picture. On small representative benchmarks, the QUBO recovers correct optimal alignments, including cases with concurrency, loops, silent transitions, and duplicate labels, while scalability is strongly limited by current hardware connectivity and the overhead of minor embedding. Between these two results, one interesting signal emerges: on some loop-heavy instances, the quantum annealer performs better than classical simulated annealing on the same logical QUBO. Figure 1 summarizes the logic of the paper.

To be meaningful for process mining, this line of work must clarify whether the direct QUBO computes the same optimal alignments as standard conformance checking, which properties of models and traces make the encoding easy or hard, whether quantum annealing helps on at least some instance classes, and whether current hardware can represent the formulation robustly, leading to the following research questions:

RQ1. 

Can standard optimal alignment finding be expressed directly as a QUBO and solved correctly on small representative Petri net examples?

RQ2. 

Which properties of a process model or trace make the resulting QUBO easy or hard to solve?

RQ3. 

Are there classes of alignment instances for which a quantum annealer performs better than classical simulated annealing on the same QUBO?

RQ4. 

What currently prevents this approach from scaling to more realistic conformance checking tasks?

The paper makes three contributions: a direct QUBO formulation for optimal alignments on safe Petri nets, a proof-of-concept implementation with an empirical evaluation on exact, classical, and quantum backends, and process mining insights about correctness, difficulty, promising cases, and present scalability limits.

The remainder of the paper covers related work (Section 2), preliminaries (Section 3), the direct QUBO formulation (Section 4), the proof-of-concept implementation (Section 5), the empirical evaluation (Section 6), a discussion of implications (Section 7), and the conclusion (Section 8).

2. Related Work

Related research falls into three lines of work: classical alignment computation, alternative optimization encodings for alignment problems, and QUBO or quantum-optimization methods.

2.1. Classical Alignment Computation in Process Mining

Alignments were introduced as a cost-based way to compare observed behavior in an event log with the behavior allowed by a process model (van der Aalst et al. 2012). In the classical process mining literature, the standard exact approach is based on synchronous product nets, which combine the process model and the trace into one search structure (Adriansyah et al. 2011). Optimal alignments can then be computed by shortest-path or heuristic-search techniques, most notably $A^{*}$-based methods (Carmona et al. 2022,van Dongen 2018).

These methods remain the main reference point because they compute standard optimal alignments with strong correctness guarantees (Carmona et al. 2022). However, the problem remains computationally hard (Schwanen et al. 2025), which motivates alternative formulations. Our work does not replace this classical view; it asks whether the same optimization target can be expressed in a different computational language, namely QUBO.

2.2. Alternative Optimization Encodings for Alignment Problems

A second line of work studies alignment and conformance checking problems through general optimization or satisfiability formalisms rather than explicit state-space search. SAT-based encodings have shown that alignment-related conformance tasks can be represented by bounded logical constraints (Boltenhagen et al. 2021,Chatain and Carmona 2016). Likewise, mixed-integer linear optimization has been used to formulate alignment computation for specific model classes such as process trees (Schwanen et al. 2024).

These works are close in spirit to ours because they move alignment reasoning into a generic optimization formalism, but they neither provide a direct QUBO formulation of standard optimal alignments on safe Petri nets nor design their encodings with quantum annealing in mind. In contrast, we construct the alignment problem directly in a quadratic binary form that can be executed by exact solvers, classical QUBO samplers, and a quantum annealer without changing the logical problem definition.

2.3. QUBO and Quantum Optimization

QUBO is a standard modeling formalism for combinatorial optimization over binary variables (Punnen 2022). It is relevant here because the same formulation can be handled by classical heuristics and by quantum annealing (Rajak et al. 2022). In the broader optimization literature, generic reductions from SAT to QUBO (Nülein et al. 2023,Zielinski et al. 2023) and from integer linear programs to quantum-optimization settings (Chang et al. 2020) show that many discrete optimization problems can, in principle, be translated into a quantum-compatible form.

This line of work is enabling rather than process mining-specific: since SAT and MILP encodings of alignments already exist, indirect translations to QUBO are possible in principle, but such routes introduce many auxiliary variables, do not exploit the semantics of the original problem, and are unlikely to be the most compact or process-aware way to represent Petri net behavior on current quantum hardware. This is the main reason for pursuing a direct encoding instead of a pipeline such as alignment → SAT → QUBO.

Overall, to the best of our knowledge, prior work neither provides a direct QUBO formulation of standard optimal alignments for safe Petri nets, nor studies such a formulation from a process mining perspective using exact, classical stochastic, and quantum execution backends; this is the gap addressed here.

3. Preliminaries

3.1. Traces and Safe Petri Nets

A trace records one observed execution of a process as a finite sequence of activity labels (van der Aalst 2016). We write a trace as $\sigma =\langle a_1,\dots ,a_n\rangle$, where each $a_i$ belongs to an activity alphabet $\mathcal{A}$. In this paper, we solve the alignment problem for one trace at a time.

We use labeled safe Petri nets as process models (Desel et al. 2004,van der Aalst 2016). A Petri net is a tuple $N=(P,T,F,\ell )$, where P is a set of places, T is a set of transitions with $P\cap T=\varnothing$, $F\subseteq (P\times T)\cup (T\times P)$ is the flow relation, and $\ell :T\to \mathcal{A}\cup \left\{\tau \right\}$ is a labeling function. A transition labeled $\tau$ is silent, meaning that it has no corresponding event in the trace. Different transitions may share the same visible label.

A marking assigns tokens to places. Because we restrict ourselves to safe Petri nets, every place contains at most one token, so a marking can be seen as a function $M:P\to \{0,1\}$. For a transition $t\in T$, we write $•t=\{p\in P\mid (p,t)\in F\}$ and $t•=\{p\in P\mid (t,p)\in F\}$ for its input and output places. Similarly, for a place $p\in P$, we write $•p=\{t\in T\mid (t,p)\in F\}$ and $p•=\{t\in T\mid (p,t)\in F\}$.

A transition t is enabled in marking M if each input place of t contains a token, that is, if $M\left(p\right)=1$ for all $p\in •t$. Firing an enabled transition produces a new marking $M^{\prime }$ given by

$$M^{\prime }\left(p\right)=\left\{\begin{array}{cc}M\left(p\right)+1,\hfill & \mathrm{if}p\in t•\setminus •t,\hfill \\ M\left(p\right)-1,\hfill & \mathrm{if}p\in •t\setminus t•,\hfill \\ M\left(p\right),\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

Given an initial marking $M_{\mathrm{init}}$ and a final marking $M_{\mathrm{fin}}$, a firing sequence is called a model run if it transforms $M_{\mathrm{init}}$ into $M_{\mathrm{fin}}$.

3.2. Alignments

Alignment-based conformance checking compares a trace and a process model by means of a sequence of moves (van der Aalst et al. 2012). Each move has a trace side and a model side. We use the placeholder symbol − to denote the absence of an activity or transition. A synchronous move has the form $(a,t)$ with $\ell \left(t\right)=a$. A log move has the form $(a,-)$, meaning that the trace advances without firing a model transition. A model move has the form $(-,t)$, meaning that the model fires a transition without consuming a trace event.

An alignment of trace $\sigma$ to model N is a sequence of such moves whose first components, after removing all occurrences of −, reproduce exactly $\sigma$, while the second components, after removing all occurrences of −, form a model run of N. We denote the set of all alignments of $\sigma$ to N by ${\Gamma }_{\sigma ,N}$.

We use the standard alignment cost: synchronous moves have cost 0, log moves and visible model moves have cost 1, and model moves on silent transitions have cost 0 (Carmona et al. 2022,van der Aalst et al. 2012). Formally, for a move m,

$$\mathrm{cost}\left(m\right)=\left\{\begin{array}{cc}0,\hfill & \mathrm{if}m=(a,t)\mathrm{and}\ell \left(t\right)=a,\hfill \\ 0,\hfill & \mathrm{if}m=(-,t)\mathrm{and}\ell \left(t\right)=\tau ,\hfill \\ 1,\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

The cost of an alignment $\gamma =\langle m_1,\dots ,m_k\rangle$ is $\mathrm{cost}\left(\gamma \right)={\sum }_{i=1}^k\mathrm{cost}\left(m_i\right)$. An optimal alignment is an alignment ${\gamma }^{*}\in {\Gamma }_{\sigma ,N}$ with minimum total cost. We write $\mathrm{cost}(\sigma ,N)$ for the cost of an optimal alignment.

3.3. Quadratic Unconstrained Binary Optimization

A QUBO problem is an optimization problem over binary variables (Punnen 2022). In its standard form,

$$\underset{\mathbf{x}\in {\{0,1\}}^n}{min}H\left(\mathbf{x}\right)={\mathbf{x}}^{\top }Q\mathbf{x}+{\mathbf{c}}^{\top }\mathbf{x},$$

where $\mathbf{x}$ is a binary vector, Q contains quadratic interaction terms, and $\mathbf{c}$ contains linear terms. The function H is often called the energy of the QUBO.

Because a QUBO is unconstrained, logical or combinatorial constraints are usually enforced through penalty terms. A common construction is

$$H\left(\mathbf{x}\right)=H_{\mathrm{obj}}\left(\mathbf{x}\right)+\lambda H_{\mathrm{const}}\left(\mathbf{x}\right),$$

where $H_{\mathrm{obj}}$ represents the optimization objective, $H_{\mathrm{const}}$ penalizes invalid solutions, and $\lambda >0$ is a penalty factor. The goal is to choose $\lambda$ large enough so that invalid solutions never become more attractive than valid ones.

3.4. Quantum Annealing and Embeddings

Quantum annealing is a hardware-based method for searching for low-energy solutions of a QUBO (Rajak et al. 2022). Unlike an exact solver, a quantum annealer does not guarantee that the optimum is found; it returns a collection of candidate solutions, usually called samples, and the lowest-energy samples are taken as the most promising ones.

On real hardware, the logical QUBO cannot always be mapped directly to the physical processor because not every pair of physical qubits is connected (D-Wave Systems 2026). Therefore, a minor embedding is required: one logical variable may need to be represented by a chain of physical qubits. Long or highly connected chains are more fragile, and chain breaks can reduce solution quality; in the evaluation, this is one of the main bottlenecks for scalability.

4. Approach

4.1. Problem Setting and High-Level Idea

Let $\sigma =\langle a_1,\dots ,a_n\rangle$ be a trace, let $N=(P,T,F,\ell )$ be a safe labeled Petri net, and let $M_{\mathrm{init}}$ and $M_{\mathrm{fin}}$ be its initial and final markings. We assume first that $n\ge 1$ and discuss the empty trace at the end of this section. Let $S\in \mathbb{N}$ be a fixed alignment horizon with $S\ge n$.

The goal is to encode the problem of finding an optimal alignment of $\sigma$ to N as one QUBO. Since a QUBO has a fixed number of variables, we encode exactly Sslots instead of a variable-length alignment. Each slot may represent one of four possibilities: a synchronous move $(a,t)$, where one trace event is consumed and one transition with the same visible label is fired; a log move $(a,-)$, where one trace event is consumed and no transition is fired; a model move $(-,t)$, where one transition is fired and no trace event is consumed; or a filler move $(-,-)$, where neither the trace nor the model advances. Filler moves have zero cost and are removed after decoding; they are needed because the optimal alignment may be shorter than S. A zero-constraint-energy assignment should describe a padded alignment that satisfies three requirements: the trace events are consumed exactly once and in the correct order; the model-side transition sequence is a valid Petri net run from $M_{\mathrm{init}}$ to $M_{\mathrm{fin}}$; and every slot that consumes a trace event and fires a transition is label-consistent. Among all such valid padded alignments, the QUBO objective minimizes the standard alignment cost.

Figure 2 introduces the running example used in this section, and Figure 3 shows the fixed-length view of the encoding.

We use the Iverson bracket notation $\left[\phi \right]$, which evaluates to 1 if statement $\phi$ is true and to 0 otherwise.

At a high level, each slot stores the state before the slot (the current marking of the Petri net and the current position in the trace) and the action in the slot (whether one trace event is consumed and which model transition, if any, is fired). The constraints ensure that the state before slot $s+1$ is exactly the result of applying the action in slot s to the state before slot s.

4.2. Decision Variables

For every slot $s\in \{1,\dots ,S\}$, transition $t\in T$, and trace position $j\in \{1,\dots ,n+1\}$, we introduce the following binary variables:

• $x_{s,t}\in \{0,1\}$: equals 1 if transition t is fired in slot s.
• $z_s\in \{0,1\}$: equals 1 if slot s consumes one trace event.
• $I_{s,j}\in \{0,1\}$: equals 1 if, before slot s, the next unconsumed trace event is $a_j$. The state $j=n+1$ means that the complete trace has already been consumed.
• $w_{s,t}\in \{0,1\}$: auxiliary variable intended to represent $z_s{x}_{s,t}$.
• $y_{s,j}\in \{0,1\}$ for $j\in \{1,\dots ,n\}$: auxiliary variable intended to represent $z_s{I}_{s,j}$, that is, slot s consumes event $a_j$.

For every place $p\in P$ and $s\in \{1,\dots ,S+1\}$, we introduce marking variables $m_{s,p}\in \{0,1\}$. The variable $m_{s,p}$ describes the marking before slot s, and $m_{S+1,p}$ describes the marking after the final slot. The initial and final markings are fixed: $m_{1,p}=M_{\mathrm{init}}\left(p\right)$ and $m_{S+1,p}=M_{\mathrm{fin}}\left(p\right)$ for all $p\in P$. Likewise, the trace starts at its first event: $I_{1,1}=1$ and $I_{1,j}=0$ for all $j\in \{2,\dots ,n+1\}$. In the implementation, these fixed variables are substituted by constants and removed from the QUBO.

The auxiliary variables are purely technical: without them, the natural label-consistency and trace-update constraints would contain cubic terms; $w_{s,t}$ and $y_{s,j}$ keep the formulation quadratic.

4.3. Constraint Terms

We now define the constraint part of the QUBO. Each term is nonnegative and equals zero exactly when the corresponding rule is respected, possibly together with the auxiliary-variable constraints on which it depends; the full constraint energy, the sum of all terms, is therefore zero if and only if every individual constraint is satisfied.

One trace position per slot. Before each slot, the encoding must point to exactly one trace position:

$$H_{\mathrm{index}}={\displaystyle \sum _{s=1}^S}{\left({\displaystyle \sum _{j=1}^{n+1}}{I}_{s,j}-1\right)}^2.$$

(1)

At most one transition per slot. A single alignment slot may fire at most one model transition. Let $A_s={\sum }_{t\in T}{x}_{s,t}$. The condition $A_s\in \{0,1\}$ is enforced by

$$H_{\mathrm{trans}}={\displaystyle \sum _{s=1}^S}{A}_s(A_s-1)={\displaystyle \sum _{s=1}^S}\left(\sum _{t\in T}{x}_{s,t}\right)\left(\sum _{t\in T}{x}_{s,t}-1\right).$$

(2)

For binary variables this term is zero if no transition or exactly one transition is selected, and positive otherwise.

Trace-event consumption. If slot s consumes a trace event, then it must consume exactly the current trace event. The variables $y_{s,j}$ identify which event is consumed. We enforce ${\sum }_{j=1}^n{y}_{s,j}=z_s$ and $y_{s,j}\le I_{s,j}$. The corresponding QUBO penalties are

$$H_{\mathrm{yz}}={\displaystyle \sum _{s=1}^S}{\left(z_s-{\displaystyle \sum _{j=1}^n}{y}_{s,j}\right)}^2$$

(3)

and

$$H_{\mathrm{yI}}={\displaystyle \sum _{s=1}^S}{\displaystyle \sum _{j=1}^n}{y}_{s,j}(1-I_{s,j}).$$

(4)

Together with the one-hot constraint on $I_{s,j}$, these terms imply that $z_s=1$ is possible only when the trace pointer is at some real event position $j\le n$, and then exactly the current event is consumed; if the pointer is already at $n+1$, then $z_s=0$ is forced.

Trace-index update. The trace pointer should advance by one exactly when an event is consumed. For convenience, define $y_{s,0}=y_{s,n+1}=0$. Then the trace-index update is $I_{s+1,j}=I_{s,j}+y_{s,j-1}-y_{s,j}$ for $s=1,\dots ,S-1$ and $j=1,\dots ,n+1$. This is enforced by

$$H_{\mathrm{I}}={\displaystyle \sum _{s=1}^{S-1}}{\displaystyle \sum _{j=1}^{n+1}}{\left(I_{s+1,j}-I_{s,j}-y_{s,j-1}+y_{s,j}\right)}^2.$$

(5)

The sum stops at $S-1$ because $I_{s,j}$ is defined only before the S slots. Completion of the trace at the end of slot S is handled separately below.

Auxiliary product for synchronous moves. A slot is synchronous precisely when it both consumes a trace event and fires a transition. To keep label-consistency quadratic, we introduce $w_{s,t}=z_s{x}_{s,t}$ and enforce it with the standard quadratic reduction

$$H_{\mathrm{w}}={\displaystyle \sum _{s=1}^S}\sum _{t\in T}\left(3w_{s,t}+z_s{x}_{s,t}-2w_{s,t}{z}_s-2w_{s,t}{x}_{s,t}\right).$$

(6)

For binary variables, the summand is zero exactly when $w_{s,t}=z_s{x}_{s,t}$.

Label-consistent synchronous moves. Together with $H_{\mathrm{w}}$, label consistency is enforced by

$$H_{\mathrm{sync}}={\displaystyle \sum _{s=1}^S}\sum _{t\in T}{\displaystyle \sum _{j=1}^n}{w}_{s,t}{I}_{s,j}\left(1-[\ell \left(t\right)=a_j]\right).$$

(7)

If $z_s=1$ and $x_{s,t}=1$, then $w_{s,t}=1$, and since $I_{s,j}=1$ for exactly one current trace position, the term above is zero only if the fired transition has the same visible label as the current trace event. In particular, a silent transition cannot be used as a synchronous move, because $\tau$ is not a trace activity label.

Petri net state update. The marking must evolve according to the Petri net firing rule: we require $m_{s+1,p}=m_{s,p}+{\sum }_{t\in •p}{x}_{s,t}-{\sum }_{t\in p•}{x}_{s,t}$ for every place p. This is enforced by

$$H_{\mathrm{mark}}={\displaystyle \sum _{s=1}^S}\sum _{p\in P}{\left(m_{s+1,p}-m_{s,p}-\sum _{t\in •p}{x}_{s,t}+\sum _{t\in p•}{x}_{s,t}\right)}^2.$$

(8)

This equation also enforces ordinary enabling conditions: if a transition consumes a token without reproducing it, the equation cannot be satisfied unless the token is present before the slot, and because markings are binary, it prevents producing a token into an already marked place.

A small extra term is needed only for self-loop arcs, where a transition both consumes from and produces to the same place. There, the consume and produce effects cancel in the marking equation, so the equation alone does not check whether the token was present before firing. Let $B=\left\{\right(p,t)\in P\times T\mid p\in •t\cap t•\}$. Then

$$H_{\mathrm{self}}={\displaystyle \sum _{s=1}^S}\sum _{(p,t)\in B}{x}_{s,t}(1-m_{s,p})$$

(9)

ensures that such a transition can fire only if the self-loop place is marked.

Complete trace consumption. By the end of the horizon, the full trace must have been consumed. Since $I_{S,n+1}=1$ means that the trace has already been consumed before slot S, and $y_{S,n}=1$ means that the final event $a_n$ is consumed in slot S, trace completion is expressed by the OR condition $I_{S,n+1}\vee y_{S,n}$. The corresponding quadratic penalty is

$$H_{\mathrm{complete}}=1-I_{S,n+1}-y_{S,n}+I_{S,n+1}{y}_{S,n}.$$

(10)

Putting everything together, the full constraint energy is

$$\begin{array}{cc}\hfill H_{\mathrm{const}}=& H_{\mathrm{index}}+H_{\mathrm{trans}}+H_{\mathrm{yz}}+H_{\mathrm{yI}}+H_{\mathrm{I}}+H_{\mathrm{w}}+H_{\mathrm{sync}}\hfill \\ \hfill & +H_{\mathrm{mark}}+H_{\mathrm{self}}+H_{\mathrm{complete}}.\hfill \end{array}$$

(11)

Empty trace. For $n=0$, the trace is already consumed at the start. One may then either omit the trace-index variables entirely or keep a single fixed state $I_{s,1}=1$ for all slots. There are no y variables, $H_{\mathrm{complete}}$ is omitted, and $H_{\mathrm{yz}}$ reduces to $H_{\mathrm{yz}}^{n=0}={\sum }_{s=1}^S{z}_s$, which forces $z_s=0$ for all slots. The remaining marking and transition constraints are unchanged, so the QUBO searches for a model run from $M_{\mathrm{init}}$ to $M_{\mathrm{fin}}$ using only model moves and filler moves.

4.4. Objective Function and Decoding

Among all feasible encodings, we minimize the standard alignment cost. A log move occurs when a trace event is consumed but no transition is fired. A visible model move occurs when a visible transition is fired but no trace event is consumed. Therefore, the objective is

$$H_{\mathrm{obj}}={\displaystyle \sum _{s=1}^S}{z}_s\left(1-\sum _{t\in T}{x}_{s,t}\right)+{\displaystyle \sum _{s=1}^S}\left(\sum _{t\in T:\ell \left(t\right)\ne \tau }{x}_{s,t}\right)(1-z_s).$$

(12)

On every feasible encoding, each slot has at most one fired transition, so $H_{\mathrm{obj}}$ counts exactly the log moves and visible model moves and thus equals the standard alignment cost.

The final QUBO is

$$H_{\mathrm{align}}=H_{\mathrm{obj}}+\lambda H_{\mathrm{const}},$$

(13)

where $\lambda >0$ is a penalty factor.

Decoding a feasible binary solution is immediate. For each slot s: if $z_s=1$ and exactly one $x_{s,t}=1$, the slot becomes the synchronous move $(a_j,t)$ where $I_{s,j}=1$; if $z_s=1$ and all $x_{s,t}=0$, it becomes the log move $(a_j,-)$ where $I_{s,j}=1$; if $z_s=0$ and exactly one $x_{s,t}=1$, it becomes the model move $(-,t)$; and if $z_s=0$ and all $x_{s,t}=0$, it is a filler move and is removed. A zero-constraint-energy assignment cannot have any other slot type.

Two properties are worth noting: duplicate visible labels are naturally supported, because (7) only checks label equality, and silent transitions are naturally supported, because they can appear as model moves with zero cost in (12).

4.5. Search-Space Reduction

Before constructing the final QUBO, several variables can be fixed without changing the set of valid alignments.

First, before slot s, at most $s-1$ trace events can have been consumed, so the next trace position cannot be larger than s. Hence, for all $j>s$, the variables $I_{s,j}$ can be fixed to 0, and consequently $y_{s,j}=0$ as well.

Second, the Petri net can rule out some states and actions early in the horizon. We compute conservative earliest-reachability lower bounds for places and transitions: if a place cannot possibly be marked before slot s, then $m_{s,p}$ is fixed to 0, and if a transition cannot possibly be enabled in slot s, then $x_{s,t}$ is fixed to 0. A variable is fixed only when the corresponding state or action is impossible in every valid run, so the pruning is safe.

These reductions preserve correctness while shrinking the QUBO and easing its embedding onto quantum hardware.

4.6. Correctness of the Encoding

We now state the correctness guarantee. Because the horizon is fixed, the result is necessarily relative to the set of alignments whose length is at most S. Let ${\Gamma }_{\sigma ,N}^{\le S}=\{\gamma \in {\Gamma }_{\sigma ,N}\mid \left|\gamma \right|\le S\}$ be the set of valid alignments of $\sigma$ to N with length at most S.

Proposition 1.

Let σ be a trace with $\left|\sigma \right|=n\ge 1$, let N be a safe labeled Petri net with initial marking $M_{\mathrm{init}}$ and final marking $M_{\mathrm{fin}}$, and let $S\ge n$. Assume that ${\Gamma }_{\sigma ,N}^{\le S}\ne \varnothing$. Consider the QUBO $H_{\mathrm{align}}=H_{\mathrm{obj}}+\lambda H_{\mathrm{const}}$ defined above, with the fixed initial and final marking variables and the fixed initial trace-index variables substituted into the QUBO. If $\lambda >S$, then:

1.

every alignment $\gamma \in {\Gamma }_{\sigma ,N}^{\le S}$ can be represented by a binary assignment $\mathbf{x}$ with $H_{\mathrm{const}}\left(\mathbf{x}\right)=0$ and $H_{\mathrm{obj}}\left(\mathbf{x}\right)=\mathrm{cost}\left(\gamma \right)$;

2.

every global minimizer ${\mathbf{x}}^{*}$ of $H_{\mathrm{align}}$ satisfies $H_{\mathrm{const}}\left({\mathbf{x}}^{*}\right)=0$ and decodes to an optimal alignment in ${\Gamma }_{\sigma ,N}^{\le S}$.

Proof. 

We prove the claim in four steps.

Step 1: zero-constraint energy implies a valid padded alignment. Let $\mathbf{x}$ be a binary assignment with $H_{\mathrm{const}}\left(\mathbf{x}\right)=0$. Since $H_{\mathrm{const}}$ is a sum of nonnegative terms, every individual constraint term must be zero.

From $H_{\mathrm{index}}=0$, each slot s has exactly one active trace-index variable $I_{s,j}$. From $H_{\mathrm{trans}}=0$, at most one transition is selected in each slot.

The terms $H_{\mathrm{yz}}=0$ and $H_{\mathrm{yI}}=0$ imply that $z_s=1$ if and only if exactly one $y_{s,j}$ is active, and any active $y_{s,j}$ must correspond to the current trace position $I_{s,j}=1$. Thus, when a slot consumes a trace event, it consumes the current one. If the pointer is already at $n+1$, then $I_{s,j}=0$ for all $j\le n$, forcing all $y_{s,j}=0$ and hence $z_s=0$: no event can be consumed after the trace has been completed.

The term $H_{\mathrm{I}}=0$ enforces $I_{s+1,j}=I_{s,j}+y_{s,j-1}-y_{s,j}$ for every $s<S$. Hence the trace pointer advances by exactly one when an event is consumed and otherwise stays unchanged. Since the initial trace position is fixed to $I_{1,1}=1$, the consumed trace events are exactly a prefix of $\sigma$ and are consumed in order. Finally, $H_{\mathrm{complete}}=0$ implies $I_{S,n+1}=1$ or $y_{S,n}=1$: either the full trace has been consumed before slot S, or the final trace event is consumed in slot S. Consequently, the trace projection of the decoded non-filler slots is exactly $\sigma$.

Next consider the model side. The initial marking is fixed to $M_{\mathrm{init}}$, and the final marking after slot S is fixed to $M_{\mathrm{fin}}$. Since $H_{\mathrm{mark}}=0$, every slot satisfies $m_{s+1,p}=m_{s,p}+{\sum }_{t\in •p}{x}_{s,t}-{\sum }_{t\in p•}{x}_{s,t}$ for all $p\in P$. If no transition is fired in slot s, this equation leaves every place unchanged. If a transition t is fired, the equation applies exactly the Petri net token update. For every input place $p\in •t\setminus t•$, it requires $m_{s+1,p}=m_{s,p}-1$, possible with binary variables only if $m_{s,p}=1$, so the consumed token must be present. For every output place $p\in t•\setminus •t$, it requires $m_{s+1,p}=m_{s,p}+1$, possible only if $m_{s,p}=0$, so the update remains safe. For self-loop places $p\in •t\cap t•$, the effects cancel in the marking equation, and $H_{\mathrm{self}}=0$ enforces $m_{s,p}=1$ whenever $x_{s,t}=1$. Therefore every fired transition is enabled and the marking update is valid. Since $m_{S+1,p}=M_{\mathrm{fin}}\left(p\right)$, the model-side projection is a model run from $M_{\mathrm{init}}$ to $M_{\mathrm{fin}}$.

It remains to check synchronous moves. From $H_{\mathrm{w}}=0$, each $w_{s,t}$ equals $z_s{x}_{s,t}$. If a slot both consumes an event and fires transition t, then $w_{s,t}=1$, and since exactly one trace-index variable is active, $H_{\mathrm{sync}}=0$ implies $\ell \left(t\right)=a_j$ for the active trace event $a_j$. Hence every slot that is both a trace move and a model move is a legal synchronous move. Thus every assignment with $H_{\mathrm{const}}=0$ decodes to a valid alignment padded with filler moves.

Step 2: every bounded valid alignment has a zero-constraint encoding. Let $\gamma \in {\Gamma }_{\sigma ,N}^{\le S}$ be any valid alignment with length $r\le S$, padded with $S-r$ filler moves to exactly S slots.

We assign the variables slot by slot. Before each slot s, set $m_{s,p}$ to the marking reached by the model projection of the previous non-filler slots, and set $I_{s,j}=1$ for the next unconsumed trace position j. For a log move, set $z_s=1$ and all $x_{s,t}=0$; for a model move $(-,t)$, $z_s=0$ and $x_{s,t}=1$; for a synchronous move $(a_j,t)$, $z_s=1$ and $x_{s,t}=1$; for a filler move, $z_s=0$ and all $x_{s,t}=0$. In all cases, set $y_{s,j}=z_s{I}_{s,j}$ and $w_{s,t}=z_s{x}_{s,t}$. The next marking and next trace index are then set according to the actual alignment move.

Because $\gamma$ is a valid alignment, its trace projection is exactly $\sigma$, its model projection is a valid run from $M_{\mathrm{init}}$ to $M_{\mathrm{fin}}$, and every synchronous move has a matching label. Therefore all trace-index, marking, self-loop, auxiliary-product, label-consistency, and completion constraints are satisfied, and the resulting binary assignment has $H_{\mathrm{const}}=0$.

Step 3: for feasible assignments, the objective equals alignment cost. Let $\mathbf{x}$ satisfy $H_{\mathrm{const}}\left(\mathbf{x}\right)=0$. Then each slot has at most one selected transition. If $z_s=1$ and no transition is selected (log move), the first part of (12) contributes 1 and the second 0. If $z_s=1$ and one transition is selected (synchronous move), the first part contributes 0 and the second is multiplied by $1-z_s=0$. If $z_s=0$ and one visible transition is selected (visible model move), the first part contributes 0 and the second 1. If $z_s=0$ and one silent transition is selected (silent model move), or no transition is selected (filler move), both parts contribute 0. Thus $H_{\mathrm{obj}}$ counts exactly the log moves and visible model moves, and therefore equals the standard alignment cost of the decoded alignment.

Step 4: global minimizers are feasible and optimal. Since ${\Gamma }_{\sigma ,N}^{\le S}\ne \varnothing$, by Step 2 there exists a feasible assignment, and by Step 3 every feasible assignment has objective value at most S, because each slot contributes at most one unit of alignment cost.

It remains to show that no infeasible assignment can have lower total energy when $\lambda >S$. All constraint terms are nonnegative integer-valued on binary assignments, so any violated constraint gives positive constraint energy. The only subtlety is that $H_{\mathrm{obj}}$ can be negative on infeasible assignments if more than one transition is selected in a slot while $z_s=1$; this is penalized by $H_{\mathrm{trans}}$.

For a slot s, write $A_s={\sum }_{t\in T}{x}_{s,t}$. The slot contribution of $H_{\mathrm{trans}}$ is $A_s(A_s-1)$, and that of $H_{\mathrm{obj}}$ is $z_s(1-A_s)+(1-z_s){\sum }_{t:\ell \left(t\right)\ne \tau }{x}_{s,t}$. If $z_s=0$, this objective contribution is nonnegative. If $z_s=1$, it equals $1-A_s$, which is again nonnegative for $A_s\le 1$. For $A_s\ge 2$, the combined objective-plus-transition-penalty contribution is $1-A_s+\lambda A_s(A_s-1)=(A_s-1)(\lambda A_s-1)$, which is positive and at least $2\lambda -1$. Since $\lambda >S\ge 1$, this is larger than S.

Therefore an infeasible assignment either violates some constraint other than $H_{\mathrm{trans}}$, in which case its total energy is at least $\lambda >S$ after accounting for the nonnegative combined contribution of $H_{\mathrm{obj}}+\lambda H_{\mathrm{trans}}$, or it violates only $H_{\mathrm{trans}}$, in which case the previous paragraph shows that its total energy already exceeds S. In both cases its energy is greater than S.

Since some feasible assignment has energy at most S, every global minimizer has $H_{\mathrm{const}}=0$. Among feasible assignments, $H_{\mathrm{align}}=H_{\mathrm{obj}}$, which by Step 3 equals the alignment cost. Therefore every global minimizer decodes to an alignment of minimum cost in ${\Gamma }_{\sigma ,N}^{\le S}$. □

Proposition 1 shows that the proposed QUBO solves the standard alignment problem up to the chosen horizon S. If ${\Gamma }_{\sigma ,N}^{\le S}$ is empty, then no feasible zero-constraint assignment exists; in that case, the horizon is too small and must be increased.

5. Implementation

5.1. Overall Workflow

Given a trace $\sigma$, a safe Petri net N, and a horizon S, the implementation performs four steps:

1.

it constructs the logical QUBO defined in Section 4;

2.

it removes variables whose values are known in advance;

3.

it sends the reduced QUBO to a selected solver or sampler;

4.

it checks feasibility and decodes feasible solutions into alignments1.

This separation matters for the evaluation: the encoder always produces the same logical optimization problem, while the execution backend can be exchanged, so all backends can be compared on the same QUBO instance.

The implementation is available as the intentionally lightweight Python package qps (Geuskens 2026b), which focuses on constructing, executing, and decoding the alignment QUBO rather than on providing a full process mining framework.

5.2. QUBO Construction and Variable Fixing

The encoder constructs the objective term $H_{\mathrm{obj}}$, the constraint term $H_{\mathrm{const}}$, and the combined QUBO $H_{\mathrm{align}}=H_{\mathrm{obj}}+\lambda H_{\mathrm{const}}$ exactly as described in Section 4. The parts are kept separate because, after solving or sampling, we also want to know whether a returned assignment is feasible and, if so, what alignment cost it represents2.

Before execution, the implementation applies the safe variable-fixing reductions described in subsec:approachpruning: trace-based pruning of impossible trace-index and consumption variables, and model-based pruning using earliest-reachability bounds for places and transitions. The reductions only shrink the logical QUBO before it reaches the selected backend; the model-based bounds are computed once per Petri net and reused across its traces.

The remaining QUBO is smaller and usually easier to solve or embed, which is especially important for quantum execution, where every unnecessary logical variable may lead to additional physical qubits and longer chains.

5.3. Execution Backends

The reduced QUBO can be executed with different backends.

For exact reference solutions, the implementation linearizes the quadratic terms and solves the result with SCIP (Hojny et al. 2025). These solutions verify that the lowest-energy feasible assignments indeed correspond to optimal alignments.

As a classical stochastic baseline, the same logical QUBO is sampled with simulated annealing, which samples low-energy states through iterative Metropolis-Hastings updates while gradually lowering an effective temperature. This baseline is not a simulation of the quantum hardware, so the classical sampler and the quantum annealer can be compared without changing the alignment encoding.

For quantum execution, the implementation uses D-Wave’s Ocean toolchain (D-Wave Systems 2025b,D-Wave Systems 2025c). The encoder still produces only the logical QUBO; hardware-specific steps such as coefficient scaling, minor embedding, chain-strength selection, sampling on the QPU, and unembedding of the returned samples are handled by the D-Wave software stack. The encoder thus defines what optimization problem should be solved, whereas the selected backend determines how it is executed3.

5.4. Feasibility Checking and Decoding

After solving or sampling, each returned binary assignment is evaluated on $H_{\mathrm{const}}$ and $H_{\mathrm{obj}}$ separately, and only assignments with $H_{\mathrm{const}}=0$ are treated as feasible. This filtering is essential for stochastic methods, because low total energy does not imply that an assignment is a valid alignment4.

Feasible assignments are then decoded slot by slot from left to right: using the variables $z_s$ and $x_{s,t}$, the decoder reconstructs whether slot s represents a synchronous, log, model, or filler move, and filler moves are removed. If only the alignment cost is needed, full decoding is unnecessary, since on feasible assignments $H_{\mathrm{obj}}$ already equals the standard alignment cost; this is useful for fitness computation over many traces.

5.5. Reuse Across Traces

In process mining, many traces or trace variants must usually be aligned against the same process model. The implementation therefore reuses all model-dependent preprocessing across traces, most notably the earliest-reachability bounds introduced above. Moreover, traces of the same length share the same general variable layout, so only trace-specific label-dependent terms need updating. This does not remove the cost of solving the optimization problem itself, but it reduces repeated preprocessing in larger experiment batches.

The prototype prioritizes transparency and faithfulness to the mathematical formulation over aggressive low-level optimization, which is appropriate for studying the encoding itself across backends.

6. Evaluation

The evaluation addresses four questions: whether the proposed QUBO recovers correct optimal alignments, which factors drive instance difficulty, when the QPU helps compared with simulated annealing, and what currently limits scalability5.

6.1. Experimental Setup

The evaluation is designed as a controlled proof-of-concept study.

Benchmark models and traces. We use handcrafted safe Petri nets that isolate the control-flow patterns most relevant to alignment computation: sequential nets ${\mathit{seq}}_n$, exclusive-choice nets ${\mathit{choice}}_n$, parallel nets ${\mathit{par}}_n$, loop nets ${\mathit{loop}}_n$, and flower models ${\mathit{flower}}_n$. In addition, we use a slightly richer toy model $N_{\mathrm{toy}}$ for parameter studies, one variant with a silent transition, and one variant with duplicate visible labels. For each model, we manually construct both fitting and non-fitting traces covering simple deviations such as missing events, extra events, wrong routing choices, and repeated loop behavior6.

These benchmark instances are intentionally small: with current hardware, realistic mined Petri nets and real-life event logs would typically yield QUBOs too large or too densely connected for a clean study of the method. The synthetic setting separates two issues that would otherwise be mixed: whether the encoding is correct, and whether current hardware can handle it.

Execution backends.Table 1 summarizes the tools used in the evaluation7. Unless an experiment explicitly studies a parameter, backend settings are kept at their defaults, which avoids tuning one backend more aggressively than another.

The QPU is accessed through D-Wave’s Ocean SDK (D-Wave Systems 2025b,D-Wave Systems 2025c), exact solutions are obtained by linearizing the QUBO and solving it with SCIP (Hojny et al. 2025), and simulated annealing serves as the main classical baseline because it solves the same logical QUBO without changing the problem formulation. Classical preprocessing and baseline runs are executed on an HPC system with Intel Xeon Sapphire CPUs.

Correctness reference. For every benchmark instance, we compute an exact optimum with SCIP and compare its cost with the cost returned by a standard process mining alignment implementation in PM4Py. The two references agree on all instances, so the true optimum is known and we can evaluate whether a sample is not only feasible but also globally optimal.

Reported metrics. We report two groups of metrics. The first concerns alignment quality: the feasibility rate (fraction of returned samples with $H_{\mathrm{const}}=0$), the success probability (fraction of samples achieving the known global optimum), the recall (fraction of distinct optimal alignments appearing in the sample set), and, when useful, the 95% samples-to-solution, which summarizes how many samples are needed to observe an optimal solution with high probability.

The second group concerns QUBO and hardware complexity: the number of logical QUBO variables and, for QPU runs, the number of physical qubits after embedding, the number and length of chains, the mean chain-break fraction, and the QPU access time. Unless stated otherwise, QPU timing refers to the access time reported by the backend and excludes internet and cloud-queue latency, which depends on the client connection rather than the alignment encoding.

Experiment-specific parameters. The alignment horizon S, the penalty factor $\lambda$, the QPU annealing time, and the chain strength are part of the phenomenon under study, so each experiment states which values are used and, when relevant, varied. This is especially important for S, which directly controls the size of the QUBO and thus strongly influences both classical and quantum performance.

Finally, because minor embedding on the QPU is heuristic, different embeddings of the same logical QUBO can lead to slightly different results. Where this variation matters, we repeat QPU runs and report averages, stating the number of repetitions.

6.2. Can the Method Recover Correct Optimal Alignments?

Test cases. We use the benchmark families introduced above (${\mathit{seq}}_3$, ${\mathit{choice}}_3$, ${\mathit{par}}_3$, ${\mathit{loop}}_3$, ${\mathit{flower}}_3$) plus two correctness-sensitive variants: one model with a silent transition and one with duplicate visible labels. Together, these benchmarks cover the main sources of difficulty for alignment semantics: sequential replay, routing choices, multiple optimal alignments caused by concurrency, repeated loop behavior, silent model behavior, and ambiguity caused by non-unique visible labels.

Because the instances can be inspected manually, the distinct optimal alignments were known, so recall can be computed exactly.

Main result. Across all basic benchmark families, the proposed QUBO recovers the correct optimal alignments: the exact solver, simulated annealing, and the QPU agree on the optimum alignment cost, and both samplers achieve recall 1.

This is the central correctness result of the paper: the encoding is not merely producing plausible low-energy solutions, since the lowest feasible QUBO solutions correspond exactly to standard optimal alignments8.

Table 2 highlights that the result is not limited to fitting sequential traces: the encoding also behaves correctly for concurrency, silent transitions, and duplicate visible labels, which often cause trouble in conformance checking.

Why these cases matter. In parallel models, several explanations of the same trace can be equally good, and a correct alignment method should not artificially prefer one execution order. Silent transitions are common in discovered and manually designed models, so an encoding that cannot represent silent model moves would be of limited use. Duplicate labels occur when different states of a process share the same visible activity name; correctness then requires reasoning at the transition level. Figure 4 illustrates these three cases.

Recall of all optimal alignments. Because the basic instances are small, we can also ask whether the samplers return all distinct optimal alignments, which is especially relevant for parallel models. Figure 5 summarizes the recall: for every family, both the QPU and simulated annealing achieve recall 1, so on these small cases the stochastic nature of the samplers is not a correctness problem.

Interpretation. For the representative small cases studied here, the method produces the right answer, including the semantic corner cases that matter in practice. The results show something modest but fundamental: the direct QUBO formulation is semantically faithful to standard alignment computation on these benchmark classes.

6.3. What Makes Instances Easy or Hard?

We now ask which properties of an instance make the resulting QUBO easy or hard to solve; for process mining users, this tells us when the method is likely to work well and why it may fail. We study three factors: the alignment horizon S, the structure of the Petri net, and the trace length.

The horizon S is the strongest difficulty driver. The horizon S fixes the maximum number of slots the QUBO may use. If S is larger than the true optimal alignment length, the optimal alignment does not change; the QUBO simply gets extra room for filler moves. The effect of S is therefore easy to interpret: any degradation as S increases comes from the larger search space and the harder embedding, not from a change in alignment semantics.

This is exactly what we observe. As S grows, the number of logical QUBO variables grows linearly, but the number of required physical qubits grows faster, because the larger logical problem induces more chains and more interactions between them. Feasibility and success probability drop, especially on the QPU; simulated annealing also weakens, but more gradually.

Figure 6 summarizes the qualitative trend for the $N_{\mathrm{toy}}$ max-S experiment9.

For a practitioner, the takeaway is that S should be chosen as tightly as possible: too small may exclude the true optimum, while too large makes the QUBO harder for both samplers, and especially for the QPU.

Model structure matters, not only model size. A second important result is that two models of similar size can behave very differently: exclusive-choice models become difficult much faster than certain similarly sized parallel models, even when the latter use at least as many logical variables. The main issue is how interactions are distributed inside the QUBO.

Choice-heavy models create a few variables that interact with many others; when such highly connected variables are embedded on the QPU, the corresponding chains are pulled by many neighboring couplings at once, which increases the chance of chain breaks. In contrast, a more distributed structure can be easier for the hardware even with slightly more variables overall. Figure 7 visualizes this contrast between a hub-like interaction pattern and a more distributed one.

Trace length is also a difficulty factor, but less cleanly. Longer traces produce larger QUBOs because the trace-index part of the encoding grows. However, unlike the horizon S, trace length also changes the alignment problem itself: there are more events to explain and more positions at which deviations can occur, so its effect is less regular than that of S. In particular, on loop-based models, longer traces can create many competing near-optimal explanations, changing both the size and the shape of the search landscape. We return to this in Section 6.4, where loop-heavy cases turn out to be the most promising ones for the QPU.

Summary of the difficulty results.Table 3 summarizes the main insights of this subsection for a process mining reader.

Together, these results answer RQ2: the hardest instances are not merely the biggest ones. The most important difficulty drivers are a loose horizon S and a model structure that concentrates many interactions on a few variables; difficulty depends on how the process is structured, not only on how large it is.

6.4. When Does the QPU Help?

We now compare the QPU with simulated annealing (SA) on the same logical QUBO. The question is not whether the QPU is better in general, which would be too strong a claim on current hardware, but whether there are specific alignment instances for which the QPU produces better solutions than a classical QUBO sampler.

Overall comparison. Across the easier benchmark instances, both backends perform well, so these instances are too simple to reveal a meaningful advantage for either side. On the harder instances created by increasing the horizon S or by using embedding-unfriendly model structures, the QPU often degrades faster than SA because minor embedding and chain breaks become dominant. The evaluation therefore does not support a general claim that the QPU is better than SA for alignment finding, but the experiments reveal one clear exception: loop-heavy cases.

The main positive signal appears on loop-heavy instances. To study this effect, we keep the process model fixed as ${\mathit{loop}}_3$ and increase the trace length10. The resulting instances remain interpretable, but become harder because the loop creates many competing explanations of the same observed behavior. Here the QPU achieves a higher success probability than SA for the longer traces, an effect not visible in the earlier benchmark families.

Figure 8 is the key result of this subsection: on the loop-based scaling experiment, the QPU overtakes SA on success probability. This is the strongest empirical reason to believe that quantum annealing may become useful for some process mining problems.

Why loops are different. In loop-heavy models, many alignments are close to correct but not quite optimal: early wrong choices in explaining a repeated fragment may still lead to a nearly optimal alignment later, creating a search space with many local minima. SA improves a solution through local updates, which can struggle when many low- and medium-quality explanations sit in separate valleys, whereas quantum annealing samples low-energy states of the full QUBO and may navigate such rugged landscapes more effectively. Figure 9 illustrates this. The explanation in terms of rugged landscapes and tunneling is consistent with the observed pattern, but remains an interpretation, not a proven mechanism.

Why the QPU doesnothelp everywhere. The QPU only helps when the logical search problem is hard but the physical embedding is still manageable. If the embedding becomes too fragile, chain breaks dominate and the potential benefit disappears, as in the larger or more densely connected instances discussed earlier. The loop-based advantage is therefore conditional: the search landscape must be hard enough to expose a weakness of SA, and the embedding must still be good enough that the QPU can represent the problem faithfully. Table 4 summarizes this subsection.

Takeaway for RQ3. The answer to RQ3 is mixed but positive in one specific sense: the evaluation does not show a broad advantage of the QPU over simulated annealing, but loop-heavy alignment instances are a promising case in which the QPU can produce better solutions than SA.

6.5. What Blocks Scalability Today?

The short answer to RQ4 is that the main scalability bottleneck is current hardware connectivity, not the alignment idea itself: the QUBO formulation remains logically correct as instances grow, but mapping it onto today’s quantum hardware becomes increasingly difficult.

The core problem is the logical-to-physical mapping. The alignment formulation lives on a logical level of binary variables and quadratic interactions, while the QPU operates on a physical graph of qubits and couplers that is not fully connected, so one logical variable often must be represented by a chain of several physical qubits. As already suggested by Figure 6, the number of logical variables grows only moderately with the horizon S, but the number of physical qubits can grow much faster: the QPU must solve an even larger embedded problem. Figure 10 illustrates this issue.

Chain breaks directly reduce alignment quality. Longer and more stressed chains are more likely to break, and a broken chain can turn an otherwise low-energy sample into an infeasible or suboptimal alignment. As chains become more numerous and fragile, the feasibility rate and success probability fall. This is exactly the pattern observed both when S increases and when model structure creates a few highly connected variables; the quality drop stems not from a change in alignment semantics, but from the physical difficulty of representing the logical interactions on hardware.

Topology matters more than raw qubit count. A particularly important result is that the limitation is not mainly the number of available qubits but how they are connected. Our experiments comparing increasing $choic{e}_n$ models with modified $pa{r}_n$ models make this point clearly11.

QPU performance drops quickly as n increases for $choic{e}_n$, while for modified $pa{r}_n$ the number of logical variables is similar or even larger, yet the QPU remains much more stable. The $choic{e}_n$ instances concentrate many interactions on a few variables, which stresses the corresponding chains, while the modified $pa{r}_n$ instances distribute interactions more evenly, leading to fewer chain breaks at similar scale. Figure 11 visualizes this comparison and supports the strongest empirical statement of this subsection: connectivity and interaction distribution matter more than raw problem size alone.

A second practical limit is the need to choose S in advance. Even apart from hardware topology, the formulation requires a fixed horizon S: too small a horizon may exclude the optimal alignment entirely, while too large a horizon inflates the logical QUBO and the physical embedding, as seen in Section 6.3. The method therefore works best when a good upper bound on the alignment length is known, which realistic conformance checking cannot always guarantee.

What this means for process mining users. The limitation is not that the alignment problem is poorly expressed as a QUBO, since Section 6.2 showed that the encoding is semantically faithful; it is that today’s QPU hardware cannot yet represent larger or more interaction-heavy alignment QUBOs robustly enough. Table 5 summarizes the bottlenecks discussed above.

Answer to RQ4. What currently stops the approach from scaling is mainly the topology of the QPU: limited connectivity forces embeddings with many fragile chains, which break more often as the logical problem becomes larger or more unevenly connected.

6.6. Threats to Validity

The evaluation is intentionally narrow: it tests whether the proposed QUBO formulation is semantically correct, identifies the main difficulty drivers, and examines current hardware bottlenecks. This creates several limitations.

Small synthetic benchmarks. The experiments use small handcrafted Petri nets and traces rather than large real-life event logs. This isolates basic control-flow patterns and keeps the exact optimum verifiable, but it limits external validity: real mined models are often larger, noisier, and structurally less clean. The results are evidence for feasibility under controlled conditions, not of practical readiness on industrial-scale tasks.

Restriction to safe Petri nets and the standard cost model. The formulation targets safe labeled Petri nets and the standard alignment cost; these assumptions are reasonable for a first study, but richer cost models, broader net classes, and more specialized settings need additional work.

Dependence on the horizon S. In several correctness-oriented experiments, S is chosen close to the known optimum length so that the behavior of the encoding can be studied cleanly. In practice this length is not known in advance, so part of the evaluation is more favorable than a realistic deployment. Section 6.3 addresses this by varying S, but selecting a good horizon remains a real limitation.

Hardware-specific conclusions. The QPU results were obtained on one D-Wave Advantage2 system with the software stack and embedding tools available during the study, so the numerical breakpoints should not be over-generalized to future hardware or software. The stable conclusion is qualitative: embedding and connectivity constraints, not the logical QUBO, are the main scalability bottleneck.

Heuristic embeddings and stochastic variation. Minor embedding is heuristic, and both samplers are stochastic, so two executions of the same logical instance need not return the same solution distribution. We repeat QPU runs and report averages where embedding variation matters most, but some residual variability remains, one reason why the paper emphasizes robust qualitative patterns rather than isolated absolute numbers.

Comparison scope. The empirical comparison applies exact solving, simulated annealing, and quantum annealing to the same QUBO. This is the right comparison for evaluating the formulation itself, but not a benchmark against the strongest classical alignment algorithms, so the paper does not claim end-to-end superiority over state-of-the-art classical conformance checking.

Timing interpretation. For the QPU, cloud access and network latency are partly outside the control of the method, while classical baseline times depend on the specific HPC environment and default settings, so reported times are most useful for relative trends within this study.

These threats do not undermine the main contribution, but they bound the conclusions to feasibility and semantic faithfulness under controlled conditions; large-scale deployment still depends on improvements in horizon selection, decomposition, and hardware connectivity.

7. Discussion

This paper is an early step toward a broader question: how can process mining problems be expressed in optimization forms compatible with emerging computational paradigms? The immediate technical contribution is a QUBO formulation for alignment finding, but the broader message is that conformance checking can be studied as a structured binary optimization problem, a shift that is useful even before quantum hardware becomes practically competitive.

QUBO as a modeling language, not only as a quantum interface. QUBO is not merely a technical requirement for quantum annealing; it is also a compact modeling language for discrete optimization. The proposed formulation separates the alignment problem into an objective part capturing the alignment cost and a constraint part capturing trace progression and Petri net execution semantics, making the optimization problem explicit and inspectable.

Classical alignment algorithms are usually presented as search procedures over a state space (Carmona et al. 2022); a QUBO formulation instead presents the same task as an energy landscape over binary variables. This does not make the problem easier by itself, but it gives access to a broad family of solvers and samplers: exact solvers, classical metaheuristics, hybrid decomposition methods, and quantum annealers.

The relevant question is not only speed. Discussions about quantum computing often focus on speedup; a more useful question at the current stage is which parts of process mining problems map naturally to quantum-compatible optimization, and which do not. This paper suggests that the basic semantics of alignments map naturally to QUBO: trace progression, model execution, all move types, silent transitions, and duplicate labels can be expressed in a quadratic binary formulation. The difficult part is not semantic expressiveness but scalability: the challenge is no longer whether alignments can be encoded, but how such encodings can be made smaller, sparser, and easier to embed or decompose.

Process structure becomes a computational object. A recurring insight is that the difficulty of the QUBO is determined not only by the number of places, transitions, or trace events, but also by the structure of the process model: branching, loops, concurrency, and the distribution of interactions. Traditionally, process-model quality is judged using criteria such as fitness, precision, generalization, and simplicity (Carmona et al. 2022,van der Aalst 2016). If new computational backends become relevant, computational encodability may become another dimension, since behaviorally similar models can differ strongly in how difficult they are to encode, sample, or embed. Future work could study model transformations that preserve conformance semantics while improving the structure of the optimization problem.

The horizon problem remains central. The fixed alignment horizon S is one of the most important limitations of the current formulation, and it is not unique to this paper: bounded encodings such as SAT-style formulations face a similar issue (Boltenhagen et al. 2021,Chatain and Carmona 2016). A bound is needed to obtain a finite optimization problem, but the right bound is rarely known in advance, so future work should treat S as a central part of the algorithmic design. Possible directions include adaptive schemes that grow the horizon only when necessary, upper-bound heuristics based on classical replay or approximate alignment methods, and decomposition approaches that compute local bounds for model fragments. Such methods would help whether the final backend is classical, quantum, or hybrid.

Hybrid approaches are likely more realistic than pure quantum approaches. The most plausible future use of quantum optimization in process mining is not a fully quantum alignment algorithm, but hybrid conformance checking, where classical methods perform model reduction, decomposition, pruning, and bound estimation, while quantum or QUBO-based samplers handle selected hard subproblems. This fits process mining: event logs contain many repeated trace variants, process models often have decomposable structure, and conformance checking already benefits from abstraction and decomposition (Carmona et al. 2022). A quantum annealer may help only on subproblems that combine high combinatorial ambiguity with manageable encoding size; identifying them is itself a process mining research problem.

Quantum hardware should influence encoding design. The proposed formulation was designed to be direct and semantically clear, which is appropriate for a preliminary study, but future encodings should be more hardware-aware. On current annealing hardware, the number of logical variables is only one part of the story; sparsity, graph degree, coefficient range, and embedding structure are equally important (D-Wave Systems 2026), and a smaller QUBO is not always better if it creates dense interactions or large coefficient imbalances. The new design objective is to encode the alignment problem in a way that is friendly to the target backend: fewer long chains and less concentrated interaction structure for quantum annealing, a smoother energy landscape for classical QUBO heuristics, and tighter formulations with stronger relaxations for exact solvers. The best formulation may therefore depend on the intended backend.

A cautious outlook. Direct QUBO-based alignment finding is not ready to replace classical conformance checking methods, but it is a promising research direction because it opens the alignment problem to a wider range of optimization technologies and exposes new questions about the structure of process models. Progress is needed on three fronts: more compact and structure-aware encodings, horizon selection and decomposition as part of the method rather than external assumptions, and quantum hardware with better connectivity, reliability, and effective embedding capacity. If these developments converge, quantum-compatible optimization may become a useful tool for selected conformance checking problems, especially those with many competing explanations and complex loop behavior.

8. Conclusion

This paper presented a direct QUBO formulation for alignment-based conformance checking on safe Petri nets. The goal was deliberately modest: not to claim that quantum annealing is ready to replace classical algorithms, but to study whether standard optimal alignments can be represented faithfully in a quantum-compatible optimization form.

The results show that this is possible: on small representative benchmarks, the proposed QUBO recovers correct optimal alignments, including cases with concurrency, loops, silent transitions, and duplicate visible labels: the formulation captures the essential semantics of alignment finding.

The evaluation also shows where the current limits lie: the most important difficulty drivers are the alignment horizon S and the interaction structure induced by the process model, and QPU performance is strongly limited by minor embedding, chain lengths, and chain breaks; the main obstacle is thus not the logical formulation itself, but mapping larger or more densely connected alignment QUBOs onto present quantum hardware.

The study also identifies a promising direction: loop-heavy instances are the most interesting candidates for future quantum or hybrid approaches, because they can create rugged search landscapes with many competing explanations. Future work should focus on compact encodings, adaptive horizon selection, decomposition, and hybrid classical-quantum workflows.

Overall, direct QUBO-based alignment finding is feasible in principle and useful as a bridge between process mining and quantum-compatible optimization. Practical large-scale use remains future work, but the results clarify what must improve for this direction to become relevant for real conformance checking.