Learnable Petri Net Neural Network Using Max-Plus Algebra

Abstract

Interpretable decision-making algorithms are important when used in the context of production optimization. While concepts like Petri nets are inherently interpretable, they are not straightforwardly learnable. This paper presents a novel approach to transform the Petri net model into a learnable entity. This is accomplished by establishing a relationship between the Petri net description in the event domain, its representation in the max-plus algebra, and a one-layer perceptron neural network. This allows us to apply standard supervised learning methods adapted to the max-plus domain to infer the parameters of the Petri net. To this end, the feed-forward and back-propagation paths are modified to accommodate the differing mathematical operations in the context of max-plus algebra. We apply our approach to a multi-robot handling system with potentially varying processing and operation times. The results show that essential timing parameters can be inferred from data with high precision.

1. Introduction

Petri nets are a versatile tool and have been used for decades to model discrete event systems, including manufacturing processes [1], traffic flows [2], or logistics [3]. Various extensions of Petri nets exist, namely timed Petri nets to incorporate the system’s timing [4], coloured Petri nets to integrate various entities within a framework [5], and continuous and hybrid Petri nets extending Petri nets to continuous variables.

However, as Petri nets are essentially a tool for system simulation, they generally lack an easy-to-handle mathematical description, mainly due to the non-linearities caused by the firing of transitions. However, for the important subgroup of timed event graphs, a mathematical representation using tropical geometry, also known as max-plus algebra, exists [6]. The tropical algebra allows for a concise mathematical model of the system behaviour in two different representations, namely the dater and counter representation [7].

Furthermore, while Petri nets have been widely used, they come with the limitation that systems have to be tediously modelled, resulting in a long and expensive modelling process, while dynamic changes to the modelled systems are difficult to account for. Specifically, parameters of Petri nets, e.g., processing and transfer times in timed Petri nets, are typically assumed to be known and constant [7]. This appears to be a considerable limitation, particularly when considering that huge amounts of data are collected and readily available to improve the modeling capability of Petri nets and to adjust the model if the underlying system dynamics change over time.

Unfortunately, approaches to add learning capabilities within Petri nets are mostly lacking. At the same time, the recent tremendous advancements in neural networks and their learning capabilities raise the question of whether these techniques can be applied to the training of Petri nets as well.

In addition, in modern production systems, processing and operation times are often uncertain or time-varying due to disturbances, machine conditions, and dynamic scheduling requirements. This makes it impractical to fix Petri net timing parameters a priori. Our approach adapts these parameters directly from data while preserving the interpretability of the Petri net formalism, thereby supporting deployment in realistic production environments. Furthermore, since Petri nets structurally mirror the actual production system, the learned model can be combined with existing simulation and optimization methods. One possible extension is integration with iterative solvers such as reinforcement learning, where Petri nets can serve as a natural simulation environment.

In this paper, we aim to bridge this gap by formally establishing a connection between certain types of Petri nets, their representation in tropical algebra by means of the dater and counter representation, and certain types of neural networks. This connection enables the representation of Petri nets by an equivalent neural network, paving the way for the use of established learning algorithms from the AI community. At the same time, we can use the equivalence to interpret the resulting neural network as a Petri net, which is highly interpretable. Having an interpretable neural network allows humans to supervise, understand, and evaluate the neural network’s decisions. Hence, while neural networks are a learnable black box system, Petri nets are a graphical, mathematical modelling tool that provides an interpretable representation of the discrete event system.

To this end, we introduce a learnable Petri net that can be used by downstream optimization algorithms like heuristic search and reinforcement learning algorithms to solve problems like job shop scheduling. We show that the state space description in the event domain of a Petri net is equivalent to a one-layer perceptron described in the max-plus algebra domain, followed by a hard-max unit. Establishing this allows the Petri net to be learned using supervised learning by a forward-propagation and back-propagation model adapted to the max-plus algebra domain. The main contributions of this paper are as follows:

• We formally establish a connection between Petri nets, their representations via max-plus-algebra, and specifically designed neural network architectures.
• We propose a learnable representation of a Petri net in the max-plus domain, allowing us to derive its parameters from available process data.
• We propose forward- and backward-propagation algorithms for the architecture, thereby enabling learnable Petri nets. Particularly, we propose a parameter-sharing approach between the date and counter representations, allowing us to learn both representations at once.
• We apply the approach to an application example from production flow shop modelling to illustrate the feasibility of the approach.

The paper is organized as follows: Related work is presented in Section 2. Section 3 provides the theoretical background of the concepts used throughout the paper. Section 3.5 establishes the theoretical connection between Petri nets and neural networks, while Section 4 presents the learning algorithms. Section 5 and Section 7 conclude the paper with empirical results and discussion.

2. Related Work

In this section, we discuss the related work on Petri nets, their relation to tropical geometry and neural networks, and applications with a focus on production systems.

2.1. Petri Net

The Petri net has been formulated as a low-level network describing the relation between events and states. It has continuously improved over the last few decades to accommodate the increasing complexity requirements in DES modelling [8]. Notable extensions include incorporating processing time in timed Petri nets (TPNs) [4] as well as environmental variability like in stochastic Petri nets (SPNs) and extended stochastic Petri nets (ESPNs) [9]. Further, the possibility to carry different information or instances in the tokens, as in coloured Petri nets (CPNs) [5] has been incorporated. One or more extensions of Petri nets can also be consolidated together to improve modelling capacity, like the extended stochastic coloured Petri nets (ECSPNs) [10]. In fact, ref. [10] developed a Petri net with unique advantages in simulating production systems in Industry 4.0 systems, like high variability, flexibility, communication, self-control, and self-organization. While Petri nets are an interpretable modelling tool, they are not designed to be learnable nor adaptive. In this work, we draw connections between specific Petri nets and neural networks to make Petri nets learnable using standard machine learning algorithms while simultaneously increasing the interpretability of such neural networks.

2.2. Max-Plus Algebra and Neural Networks

We aim to establish a missing link that combines the interpretability of Petri nets with the learning capacity of neural networks while modelling complex processes. We use max-plus algebra [6] to bridge the gap between learning capability and interpretability. Max-plus algebra has been extensively used to describe discrete event systems (DESs) in the context of production planning [7].

The combination of max-plus algebra and neural networks has been investigated in previous work. Initially introduced by [11], the morphological perceptron (MNN) with competitive learning was proposed by [12], showing the utility of MNN in classification tasks. Ref. [13] further examines the properties of morphological classifiers, such as the effect of incorporating morphological perceptrons in layers of neural networks.

Max-plus algebra was also employed to reduce the size of the neural network without sacrificing accuracy [14]. Unlike previously known structured and unstructured pruning techniques, tropical geometry is employed to approximate a neural network by a simpler one whose Newton polytopes are similar. In practice, this method can be faster than pruning techniques.

Ref. [15] leveraged the Newton polytope technique for tropical polynomials to find upper bounds on linear regions of the neural network with piecewise linear activations, allowing them to analyse the representation power and complexity of learning models. Furthermore, the paper considered neural networks with piecewise activation functions as tropical polynomials, taking into account that rectified linear units (RELU) are tropical polynomials of rank two and Maxout units are a generalization of rank k. Motivated by the fact that a ratio of polynomials has better approximation quality compared to a single polynomial with the same degree, ref. [16] showed that a feed-forward network with rectified linear units is analogous to the family of tropical rational maps.

While the above approaches discuss representation capacity and pruning techniques in neural networks, none of the works address the connection between Petri nets, timed event graphs, and neural networks to derive learnable Petri nets.

2.3. System Identification Using Max-Plus Algebra

Tropical regression, also referred to as Linear regression over the max-plus semiring, is commonly used for forward problems in predicting outcomes. Our focus lies in the inverse problem scenario, i.e., we aim to deduce the system dynamics from observed data.

Ref. [17] recasts the problem of state space identification into an extended linear complementarity problem, which leads to identifying the parameters of the state space from input and output sequences. Moreover, mixed integer programming approaches were implemented to further optimize the efficiency. In the case of stochastic systems, ref. [18] proposed two approaches to infer the dynamical systems model based on an observed noisy orbit for a stochastic max-plus linear dynamical system. The first approach is the gradient-based exact solution, and the second approach is a less computation-intensive approximation method based on the higher-order moments of a random variable. The mentioned paper presents individually designed identification methods, while we focus on the relation between tropical geometry and neural networks to allow for standard learning approaches for neural networks. Further, we provide an integrated approach for date and counter representation identification, offering downstream applications particularly in production systems.

2.4. Neural Networks in Production Scheduling

Recent advances in deep learning (DL) architectures have developed at a rapid pace. Consequently, they are increasingly used in industry for applications like fault diagnosis [19], machine remaining useful life predictions [20], etc. Also, DL is a popular method of choice in production planning and control applications [21], where the use of neural networks in production planning and control is primarily focused on the self-organization of resources and the self-regulation of the production process. In the context of smart planning and scheduling, a large portion of the literature solely relies on supervised learning [22,23]. Other approaches attempted to leverage the power of unsupervised learning to preprocess the data before using supervised learning at bottleneck detection tasks in the production line [24,25]. Other approaches also attempt to harness the synergy of combining reinforcement learning with the supervised or unsupervised approaches for scheduling problems, where the RL excels in the decision-making part [26,27].

Specifically, the idea of an algorithm capable of interacting and directly learning from the production environment to continuously enhance its scheduling capability promises robust and reliable performance. To this end, deep neural networks have been used quite extensively in the context of RL for scheduling problems [28,29]. Further, refs. [30,31,32] propose graph-based RL algorithms where graph neural networks (GNNs) were used to model the interactions in job shop scheduling problems (JSSPs), thereby providing a more interpretable representation. The combination of Petri nets and RL has been introduced in [1], where the Petri net models the product flow in the production environment. However, though providing a very interpretable representation of the production environment, this model is not able to adapt itself to a dynamically changing environment, e.g., dynamically varying processing times. In this paper, we bridge this gap in providing a learnable Petri net representation which, at the same time, has a more interpretable representation than the more generic GNNs.

3. Theoretical Background and Relation Between Petri Nets and NN

In this section, we present the theoretical foundations and key components of our approach. We begin with standard Petri nets, followed by coloured Petri nets, emphasizing their modelling advantages and the need for colour unfolding. This unfolding is crucial for transforming the abstract coloured model into an analyzable form compatible with timed event graphs (TEGs). We then introduce max-plus algebra, which provides a mathematical framework for modelling synchronization and timing in discrete event systems using timers and counters. Finally, we outline the fundamental principles of neural networks, laying the groundwork for transforming TEG state-update equations into a learnable structure via a tropical neural network.

3.1. Petri Nets

Petri nets are formal modelling tools used to describe and analyse the behaviour of dynamic systems exhibiting concurrency, synchronization, and resource sharing. They provide both a graphical and mathematical framework to represent system dynamics, enabling analysis of key behavioural properties such as reachability, liveness, and deadlock freedom [33]. A Petri net is formally defined as a pair $(\mathcal{G},{\mu }_0)$, where $\mathcal{G}$ is a directed bipartite graph composed of places and transitions, and ${\mu }_0$ denotes the initial marking, which assigns a discrete number of tokens to each place.

Unlike conventional graphs, Petri nets consist of two disjoint node sets: places $\mathcal{P}$, representing conditions or states of the system, and transitions $\mathcal{T}$, representing events or operations that can change the state. Arcs define the input/output relationships between places and transitions, modelling token flow. The state of the system is encoded in the marking $\mu$, where $\mu \left(p\right)$ gives the number of tokens at place p. A transition $t\in \mathcal{T}$ is enabled when all its input places contain the required number of tokens; firing it updates the marking as follows:  

$$\tilde{\mu }\left(p\right)=\left\{\begin{array}{cc}\mu \left(p\right)-1\hfill & \mathrm{if}p\in \pi \left(t\right),\hfill \\ \mu \left(p\right)+1\hfill & \mathrm{if}p\in \sigma \left(t\right),\hfill \\ \mu \left(p\right)\hfill & \mathrm{otherwise},\hfill \end{array}\right.$$

(1)

where $\pi \left(t\right)$ and $\sigma \left(t\right)$ denote the sets of input and output places of transition t, respectively. Petri nets effectively model and abstract the general system behaviour [34] and help identify defects or undesirable behaviour such as deadlocks [35].

In real-world systems, parts that share resources but differ in type often require modelling multiple subnetworks, which can cause the Petri net to grow exponentially with increasing variety. To address this, coloured Petri nets (CPNs) were introduced, extending classical Petri nets by allowing tokens to carry data called “colours.” This enhancement enables compact and expressive models of complex systems with structurally similar yet data-distinguished processes, such as job shop scheduling, where multiple jobs compete for common resources [5,36]. Formally, a coloured Petri net is defined as the tuple:

$$\mathrm{CPN}=(\mathcal{P},\mathcal{T},\mathcal{A},\mathrm{\Sigma },\mathit{C},\mathit{N},\mathit{E},\mathit{G},\mathit{I}),$$

(2)

where

• $\mathcal{P}=\{p_1,\dots ,p_m\}$: set of places;
• $\mathcal{T}=\{t_1,\dots ,t_n\}$: set of transitions;
• $\mathcal{A}=\{a_1,\dots ,a_k\}$: set of arcs;
• $\mathrm{\Sigma }=\{c_1,\dots ,c_l\}$: set of colours (data types);
• $\mathit{C}:\mathcal{P}\cup \mathcal{T}\to \mathrm{\Phi }\left(\mathrm{\Sigma }\right)$: colour function assigning a colour set to each place and transition;
• $\mathit{N}:\mathcal{A}\to (\mathcal{P}\times \mathcal{T})\cup (\mathcal{T}\times \mathcal{P})$: node connectivity function defining the source and target of each arc;
• $\mathit{E}:\mathcal{A}\to \mathrm{expressions}$: arc expression function specifying the token expressions for each arc;
• $\mathit{G}:\mathcal{T}\to \{0,1\}$: guard function assigning Boolean expressions controlling transition enabling;
• $\mathit{I}:\mathcal{P}\to \mathrm{initial}\mathrm{markings}$: initialization function specifying the initial coloured token distribution.

Coloured Petri nets facilitate modelling of complex discrete event systems by integrating data values with control flow, enabling compact representations without losing analytical power. This capability is crucial for practical applications such as manufacturing systems, communication protocols, and workflow management, where multiple entities with differing attributes interact concurrently.

Figure 1 illustrates simple examples of different Petri net variants: (a) a basic Petri net showing places and transitions; (b) a coloured Petri net highlighting token differentiation through colours; and (c) a coloured timed Petri net that extends the model by incorporating timing to control transition firing delays.

In Figure 1a, transition $t_1$ is enabled since its sole upstream place contains a token. Conversely, transition $t_2$ remains disabled because one of its input places, $p_2$, is empty. Thus, $t_1$ must fire first to enable $t_2$.

In Figure 1b, although place $p_2$ contains a token, transition $t_2$ is still disabled because the token’s colour does not match the transition’s required colour. Here, “colour” is a simplified representation; in practice, token attributes can be complex data types—such as tuples, vectors, or structured objects—that must satisfy specific conditions to enable transitions.

Finally, Figure 1c introduces timing constraints: a timed transition that cannot fire until the token residing in the upstream place $p_4$ has completed its specified sojourn time. In our model, this sojourn time is encoded as an attribute of the token, capturing processing durations, transport delays, or similar temporal factors.

3.2. Petri Net Colour Unfolding

While coloured Petri nets offer a compact and expressive way to model complex systems with data-carrying tokens, their colour-based abstraction can sometimes complicate analysis and simulation. In particular, many classical Petri net tools and theoretical results apply only to standard Petri nets.

To bridge this gap, when the colour sets $\mathrm{\Sigma }$ of a coloured Petri net are finite, the CPN can be unfolded into an equivalent standard Petri net that explicitly distinguishes each colour as a separate place or transition [36]. This unfolding process produces a classical Petri net with a larger, but colour-free structure, thereby preserving the original system’s behaviour while enabling the use of standard Petri net analysis techniques.

The following formal definition captures this unfolding procedure [37]:

$$N^{*}=({\mathcal{P}}^{*},{\mathcal{T}}^{*},{\mathcal{A}}^{*},{\mathit{f}}^{*},{\mathit{m}}_0^{*}),$$

(3)

where

• ${\mathcal{P}}^{*}=\{p\left(c\right)\mid p\in \mathcal{P},c\in C\left(p\right)\}$: set of unfolded places, one per colour per original place.
• ${\mathcal{T}}^{*}=\{t\left(b\right)\mid t\in \mathcal{T},b\in B\left(t\right)\}$: set of unfolded transitions, one per binding per original transition.
• ${\mathcal{A}}^{*}=\{(p\left(c\right),t\left(b\right))\mid (p,t)\in \mathcal{A},\left(f(p,t)\left[b\right]\right)\left[c\right]>0\}\cup \{(t\left(b\right),p\left(c\right))\mid (t,p)\in \mathcal{A},\left(f(t,p)\left[b\right]\right)\left[c\right]>0\}$: set of unfolded arcs.
• ${\mathit{f}}^{*}:{\mathcal{A}}^{*}\to \mathbb{N}$: arc weight function defined as

  $${\mathit{f}}^{*}(p\left(c\right),t\left(b\right))=\left(f(p,t)\left[b\right]\right)\left[c\right],{\mathit{f}}^{*}(t\left(b\right),p\left(c\right))=\left(f(t,p)\left[b\right]\right)\left[c\right].$$
• ${\mathit{m}}_0^{*}:{\mathcal{P}}^{*}\to \mathbb{N}$: initial marking function given by

  $${\mathit{m}}_0^{*}\left(p\left(c\right)\right)=m_0\left(p\right)\left[c\right].$$

In the unfolded Petri net, each coloured token residing in a place p of the original coloured Petri net (CPN) is represented as a token in a distinct place $p\left(c\right)$, effectively separating tokens by their colours. Similarly, each binding b of variables in a transition t leads to the creation of a specific transition instance $t\left(b\right)$ in the unfolded net. The arcs are instantiated based on the evaluation of colour- and binding-dependent arc expressions, ensuring that the flow of tokens and their multiplicities are preserved according to the semantics of the original CPN. The initial marking is also unfolded, such that each place $p\left(c\right)$ in the unfolded net is initialized with the number of tokens of colour c specified in the initial marking $m_0\left(p\right)$ of the corresponding place p in the CPN.

Now, the Petri net can be unfolded, which represents the crucial first step in transforming any coloured timed Petri net into a choice-free net. This transformation is necessary before we can effectively model the system using max-plus algebra. In the following section, we will further develop this concept by exploring timed event graphs described using max-plus algebra.

3.3. Timed Event Graphs (TEGs)

By definition, a timed event graph is a subclass of Petri nets where every place has exactly one upstream and one downstream transition [38]. TEGs are especially well-suited to model sequential operations and synchronization phenomena. They are further enriched with timing information associated either with transitions or places. Specifically, the duration assigned to transitions is called the firing time ${\beta }_i$, while the duration assigned to places is known as the holding time ${\alpha }_i$. Since transitions represent discrete events, firing times model the elapsed time between the start and completion of these events; conversely, holding times specify the minimum duration a token must remain in a place before enabling downstream transitions.

In a production context, firing time typically corresponds to machining or processing durations, whereas holding time may represent transport delays between production stations or material preprocessing intervals. Another important timing parameter is the lag time $w_i$ in the initial marking, which indicates the delay before a token initially contributes to enabling the downstream transition. At first glance, this lag time resembles the holding time; indeed, if all tokens enter their respective places at $t=0$, then $w_i={\alpha }_i$.

TEGs can be effectively modelled using max-plus algebra, which offers two complementary representations known as the counter and dater forms [7]. Although these representations are mathematically connected, they address distinct questions. The counter representation describes how many events have occurred up to a given time, while the dater representation specifies the time of the kth occurrence of an event.

3.4. Max-Plus Algebra and TEGs

In this section, we formally derive both the dater and counter representations for timed event graphs, starting with the foundational concept of max-plus algebra. Also known as the tropical semiring, max-plus algebra is defined on the set $\mathbb{R}\cup \{-\infty \}$ and is characterized by two fundamental operations [39]:

$$\left\{\begin{array}{c}a\oplus b=max(a,b),\hfill \\ a\otimes b=a+b,\hfill \end{array}\right.$$

(4)

where $-\infty$ and 0 serve as the identity elements for ⊕ and ⊗, respectively. This algebra provides a natural framework for modelling discrete event systems, as it captures the fundamental timing relationships inherent to such systems. In particular, the ⊕ operation models synchronization constraints by representing that an event can only occur after all prerequisite events have completed, while the ⊗ operation models the additive accumulation of delays, so that the occurrence time of an event corresponds to its start time plus its duration.

We assume that both places and transitions operate under a First-In First-Out (FIFO) policy concerning the token flow. Furthermore, the system is assumed to begin from a compatible initial condition, where the initial firing times satisfy $w_i\le {\alpha }_i$, ensuring the timing model’s consistency.

The state of the system is described by a vector of daters, denoted $x^d\left(k\right)=\left(x_1^d\left(k\right),\dots ,x_{\left|\mathcal{Q}\right|}^d\left(k\right)\right)$, where each $x_i^d\left(k\right)$ represents the epoch when the transition $q_i$ fires for the k-th time. External inputs to the system are captured by the input vector $u^d\left(k\right)=\left(u_1^d\left(k\right),\dots ,u_{\left|\mathcal{U}\right|}^d\left(k\right)\right)$, where $\mathcal{U}$ denotes the set of input transitions. Each input sequence $u_j^d\left(k\right)$ is a non-decreasing sequence marking the epochs at which external actions trigger the corresponding transition $q_j$. These input sequences are also assumed compatible with the initial condition, satisfying $u_j^d\left(1\right)\ge 0$, and both $x_j^d\left(k\right)$ and $u_j^d\left(k\right)$ take the neutral element $\epsilon =-\infty$ for all $k\le 0$.

Under these definitions and assumptions, the behaviour of the timed event graph can be compactly described by the max-plus linear dater equation:

$$x^d(k+1)=A\otimes x^d\left(k\right)\oplus B\otimes u^d(k+1),$$

where A and B are max-plus matrices that characterize the system’s internal dynamics and its response to external inputs, respectively. This equation encapsulates the timing dependencies and synchronization constraints governing the system and provides a foundation for connecting timed event graphs with learnable neural network models.

Then, the dater equation of a TEG is given by

$$\begin{array}{c}{x}^d\left(k\right)=A(k,k)x^d\left(k\right)\oplus \dots A(k,k-M)x^d(k-M)\oplus B(k,k)u^d\left(k\right)\hfill \\ \hfill \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\oplus \dots \oplus B(k,k-M)u^d(k-M)\oplus \nu \left(k\right),\forall k>0\end{array}$$

(5)

where M is the maximum number of tokens in all the places:

$$M=\underset{i=1,\dots ,\left|\mathcal{P}\right|}{max}{\mu }_i.$$

(6)

Further, the $\left|\mathcal{Q}\right|\times \left|\mathcal{Q}\right|$ state matrix A($k,k$),..., A($k,k-M$) is given by

$$A_{jl}(k,k-m)\stackrel{\mathrm{def}}{=}\left(\underset{\{i\in {\pi }^q\left(j\right)|{\pi }^p\left(i\right)=l,{\mu }_i=m\}}{⨁}{\alpha }_i\left(k\right)\right)\otimes {\beta }_l(k-m).$$

(7)

The input matrix of dimension $\left|\mathcal{Q}\right|\times \left|\mathcal{U}\right|$, and values B($k,k$),...,B($k,k-M$) is given by

$$B_{il}(k,k-m)\stackrel{\mathrm{def}}{=}\underset{\{i\in {\pi }^q\left(j\right)|{\pi }^p\left(i\right)=l,{\mu }_i=m\}}{⨁}{\alpha }_i^{*}\left(k\right),$$

(8)

where it can be shown that the firing times of the transition can be dissolved into the holding time and assign ${\beta }_j=e$ without a loss of generality, given by the equation below [6]:

$${\alpha }_i^{*}={\alpha }_i\otimes {\beta }_{{\pi }^p\left(i\right)}(k-{\mu }_i).$$

(9)

Equation (7) states that the firing time for a transition consists of the previous place-holding time (${\alpha }_i$) and the firing times of the transition upstream (${\beta }_l$). The $\left|\mathcal{Q}\right|$-dimensional vector representing the maximum initial lag times in the upstream of a transition ${\upsilon }_i\left(k\right), k=1,\dots ,M$ is   

$${\upsilon }_j\left(k\right)\stackrel{\mathrm{def}}{=}\underset{\{i\in {\pi }^q\left(j\right)|{\mu }_i\ge k\}}{⨁}{\omega }_i\left(k\right).$$

(10)

Equation (5) can be formatted into the standard form using an extended state vector as shown below: 

$${\tilde{x}}^d(k+1)=\tilde{A}\left(k\right){\tilde{x}}^d\left(k\right)\oplus \tilde{B}\left(k\right){\tilde{u}}^d\left(k\right)\oplus \tilde{\upsilon }\left(k\right),$$

(11)

where the extended state and input vectors are defined as

$${\tilde{x}}^d\left(k\right)\stackrel{\mathrm{def}}{=}\left(\begin{array}{c}{x}^d\left(k\right)\\ x^d(k-1)\\ ⋮\\ x^d(k+1-M)\end{array}\right),{\tilde{u}}^d\left(k\right)\stackrel{\mathrm{def}}{=}\left(\begin{array}{c}{u}^d\left(k\right)\\ u^d(k-1)\\ ⋮\\ u^d(k+2-M)\end{array}\right)$$

And the extended system matrices are given by

$$\tilde{A}\left(k\right)=\left(\begin{array}{ccccc}{}^d\overline{A}(k+1,k)& \overline{A}(k+1,k-1)& \dots & \dots & \overline{A}(k+1,k+1-M)\\ e& \epsilon & \dots & \epsilon & \epsilon \\ \epsilon & e& ⋮& ⋮& ⋮\\ ⋮& \ddots & e& \epsilon & \epsilon \\ \epsilon & \dots & \epsilon & e& \epsilon \end{array}\right)$$

$$\tilde{B}\left(k\right)=\left(\begin{array}{cccc}\overline{B}(k+1,k+1)& \overline{B}(k+1,k)& \dots & \overline{B}(k+1,k+2-M)\\ \epsilon & \epsilon & \dots & \epsilon \\ ⋮& ⋮& ⋮& ⋮\\ \epsilon & \epsilon & \dots & \epsilon \end{array}\right)$$

Alternatively to the dater representation, the counter representation can be used for modelling. Essentially, under mild conditions, the counter is the dual residual of the dater representation [6]. Hence, both representations share the same parameters. However, for our application domain, parameters in the dater representation appear linearly, making learning much simpler in tropical algebra, while the parameters appear as time shifts in the counter representation. Consequently, learning the dater representation also comes with learning the counter representation indirectly.

At the same time, both representations are meaningful for applications. Taking production scheduling as an example, the data representation provides insights into timing-related information, such as the time it takes to produce a sequence of orders. At the same time, the counter offers insights into the number of goods produced. Consequently, both representations can be used as cost functions for optimization.

3.5. Neural Networks and TEGs

Neural networks are universal approximators, which use multiple layers of neurons and non-linear activation functions to learn and represent complex and non-linear relationships between inputs and outputs. The most common model is the Multi-Layer Perceptron (MLP) [40], where a layer with $i=1\dots N$ inputs $x_i$ and $j=1\dots M$ outputs $y_j$ is represented by

$$y_j=f(b_j+\sum _{i=1}^n{w}_{i,j}{x}_i)$$

(12)

where $f(·)$ denotes the activation function, and $w_{i,j}$ and $b_j$ are the weights and bias of the layer’s neurons, respectively. Sigmoid and Rectified Linear Units (ReLU) are among the most common activation functions [41].

In this section, we aim to establish conditions for the equivalence of a timed event graph in the data representation and a suitably defined neural network. Achieving this enables us to develop a learnable timed event graph using approaches from neural network training. Specifically, this allows us to learn the firing timing from available system data, which can be used by various downstream tasks.

Let a timed event graph (TEG) be given in its dater representation by Equation (11). An equivalent representation can be constructed using a recurrent neural network consisting of two single-layer maxout networks, combined via an element-wise max-pooling operation.

Proof. 

Consider the maxout network of the form

$$h_i\left(x\right)=\underset{j\in [0,n]}{max}{z}_{ij},$$

(13)

with  

$$z_{ij}=W_{ij}{v}_i+s_{ij},$$

(14)

where $v_i$ denotes the inputs while $W_{ij}$ and $s_{ij}$ are the weights and biases, respectively. If we set all the weights in Equation (14) to 1, we get the form

$$z_{ij}=v_i+s_{ij}$$

(15)

where the biases are the only learnable parameters. Hence, Equation (13) yields

$$h_i\left(x\right)=\underset{j\in [0,|Q\left|\right]}{max}(v_i+s_{ij}).$$

(16)

Converting Equation (16) into the max-plus domain and rearranging the variables for consistency, we get   

$$h_i\left(x\right)=\underset{j=0}{\overset{\left|Q\right|}{⨁}}(s_{ij}\otimes v_i)$$

(17)

or in its matrix form using input vector v, bias matrix S and output matrix H:

$$H=S\otimes v.$$

(18)

If we now substitute the matrices A or B for S and x or u for v in Equation (18), respectively, we obtain the first two terms of Equation (11) by means of two single-layer maxout networks.

Applying a subsequent element-wise max-pooling operation on both single-layer maxout network outputs and an additional bias term $\tilde{\upsilon }\left(k\right)$ yields

$$x_i(k+1)=\underset{i=0}{\overset{\left|Q\right|}{⨁}}(A_{ij}\otimes x_i,B_{ij}\otimes u_i,\tilde{\upsilon }\left(k\right)),$$

(19)

where the output $x(k+1)$ is fed back into the system as $x\left(k\right)$ in the next time step, resulting in the network recurrence. Comparing Equation (19) with Equation (11) concludes the proof.    □

The resulting network is shown in Figure 2. Hence, learning the A and B matrix involves using the matrix form of the neural network weights using standard approaches.

4. Learning the TEG Parameters Using Supervised Learning

In this section, we describe the algorithm to learn the parameters of the dater representation, i.e., the state matrix A and the input matrix B. Since the system state equation expressed in the dater domain is equivalent to a neural network, we develop algorithms similar to the feed-forward and back-propagation in MLPs.

4.1. Problem Statement

Before introducing the learning algorithm, we first formally state the learning problem. To this end, we assume that a TEG of the underlying system, i.e., the number of places and transitions along with the corresponding bipartite graph, is given. Also, we assume that a dataset consisting of $\nu =1\dots N$ tuples of $(x^{\nu }\left(k\right),u^{\nu }\left(k\right),x^{\nu }(k+1))$ has been extracted from the system. Then, we define a neural network equivalent to the dater representation, where the components of the matrices A and B are the weights of the neural network. The task of learning is to learn these weights by minimizing the loss function:

$$\begin{array}{cc}\hfill \underset{A,B}{min} {\mathcal{L}}_1 =& \underset{A,B}{min}\sum _{i=1}^N\left|{\widehat{x}}_i(k+1)-x_i(k+1)\right|\hfill \end{array}$$

(20)

4.2. Learning Algorithm

Our proposed learning scheme can be divided into three steps: (1) forward pass through the network to predict the outputs based on inputs and current parameter values, (2) loss function calculation according to (20), and (3) back-propagating the error through the network to update the network’s parameters. The steps are repeated until a target acceptable error is achieved. The overall algorithm is given in Algorithm 1.

Algorithm 1 Petri net supervised learning.

Require:  Dataset $\mathcal{D}=\left\{(X,u,X^{\prime })\right\}$ Ensure:  State matrix A, Input matrix B   1: $A\leftarrow -{\mathbf{1}}^{\left|Q\right|\times \left|Q\right|}$                    ▹ Initialize with −1   2: $B\leftarrow -{\mathbf{1}}^{\left|Q\right|\times \left|U\right|}$   3: for epoch = 1 to N do   4:       for each $(X,u,X^{\prime })$ in $\mathcal{D}$ do   5:          ${\widehat{X}}^{\prime }\leftarrow ForwardPass(X,u)$               ▹ See Algorithm 2   6:          $\mathrm{error}\leftarrow {\mathcal{L}}_1(X^{\prime },{\widehat{X}}^{\prime })$   7:          Backpropagation($A,B$, error)                ▹ See Algorithm 3   8:       end for   9: end for 10: return  $A,B$

4.3. Network Architecture and Tracing

As we deduced in Section 3.5, the Petri net state equation expressed in the data domain is equivalent to two parallel one-layer perceptron networks. Hence, in every network, a transfer function $f\left(x\right)=(-1,x)$ is applied to the neurons’ activation and then, element-wise, fed into a hard-max unit. We define the first state perceptron network $\mathcal{NA}$ with n inputs and m outputs, and $\mathcal{NB}$, and the input perceptron network with u inputs and m outputs.

The above architecture provides the peculiarity that, due to the hard-max operator, only one weight is responsible for the value of the output. Hence, to speed up training, it is advisable to keep track of the history of the path leading to the output value. For example, when computing the hard-max between $Ax$ and $Bu$, we can memorize if the current output results from the multiplication A by x or B by u. Since the max operation is element-wise, we can go back in time and determine which weight, when multiplied by the input, gave the max value and proceeded to the max unit. The trace can be used within the back-propagation as given in Algorithm 2.

4.4. Back-Propagation

Once the error is calculated using Equation (20), the algorithm analyzes the path of every component of the output and adjusts the weight of the source of the error. As we previously stated, with a hard-max, every output component is typically affected by one input. Hence, the trace of the path is essentially employed for the back-propagation. We note that alternative approaches using the Gumbel–Softmax distribution [42] for the back-propagation have been explored without notable improvements. Hence, we resort to Algorithm 3.

Algorithm 2 Forward propagation in max-plus algebra.

Require:  Input vector X, control input u Ensure:  Prediction vector Y   1: Initialize weight matrices A and B   2: for each perceptron $p_i^a$ in ${\mathcal{N}}_A$ do   3:       ${\displaystyle \mathrm{activation}\leftarrow \underset{1\le j\le n}{max}\left(A_{ij}+X_j\right)}$   4:       $y_i^a\leftarrow f\left(\mathrm{activation}\right)$   5:       Store activation path   6: end for   7: for each perceptron $p_i^b$ in ${\mathcal{N}}_B$ do   8:       ${\displaystyle \mathrm{activation}\leftarrow \underset{1\le j\le u}{max}\left(B_{ij}+u_j\right)}$   9:       $y_i^b\leftarrow f\left(\mathrm{activation}\right)$ 10:       Store activation path 11: end for 12: for each index i in output Y do 13:       $Y_i\leftarrow max(y_i^a,y_i^b)$ 14:       Store activation path 15: end for 16: return  Y

Algorithm 3 Back-propagation in max-plus algebra.

Require:  Weight matrices A, B; error vector error; stored activation paths Ensure:  Updated matrices A, B   1: for each index i in error do   2:       if activation path i belongs to ${\mathcal{N}}_A$ then   3:           $A\left[{\mathrm{path}}_i\right]\leftarrow A\left[{\mathrm{path}}_i\right]-\eta ·{\mathrm{error}}_i$   4:       else   5:           $B\left[{\mathrm{path}}_i\right]\leftarrow B\left[{\mathrm{path}}_i\right]-\eta ·{\mathrm{error}}_i$   6:       end if   7: end for   8: return  $A,B$

5. Application to Production Scheduling for a Robot Manufacturing Cell

In this section, we demonstrate the application of the proposed approach to a representative case study involving a robot manufacturing cell. We begin by describing the structure and workflow of the manufacturing cell, followed by modelling its dynamics using a coloured timed Petri net. This Petri net is then unfolded into a timed event graph, enabling a representation of system dynamics using max-plus algebra. Leveraging the dater-based description derived from the TEG, we construct a tropical neural network that learns key processing times by observing transition firing patterns within the Petri net.

5.1. Environment Description: Robot Manufacturing Cell

The robot manufacturing cell used in our experiments is located in our laboratory and has been previously described in detail in [43,44]. As shown in Figure 3, the cell consists of two robots, three processing stations ($S_1,S_2,S_3$), two input stations ($I{B}_1,I{B}_2$), and one output station ($OB$). The two robots operate within a shared workspace, requiring mutual exclusion to prevent collisions and resource conflicts during execution.

The cell handles two types of workpieces, $W{P}_1$ and $W{P}_2$, each with a unique routing through the processing stations. Specifically, the routings are

$$\begin{array}{cc}\hfill W{P}_1& :I{B}_1\to S_1\to S_2\to S_3\to OB,\hfill \\ \hfill W{P}_2& :I{B}_2\to S_2\to S_3\to S_1\to OB.\hfill \end{array}$$

We model this system as a job shop scheduling problem (JSSP) due to its structured sequencing of operations and machine-specific constraints. In the classical formulation, let $J=\{J_1,J_2,\dots ,J_n\}$ denote the set of jobs and $M=\{M_1,M_2,\dots ,M_m\}$ the set of machines. Each job $J_i$ consists of a sequence of operations $O_{i1},O_{i2},\dots ,O_{ik}$, where each operation $O_{ij}$ must be processed on a specific machine $M_l\in M$ for a known duration $p_{ij}\in {\mathbb{R}}^{+}$. The decision variables are the start times $S_{ij}$ of the operations.

The scheduling problem is governed by the following constraints:

$$\begin{array}{ccc}{S}_{ij+1}\ge S_{ij}+p_{ij},\hfill & \hfill & \hspace{1em}\hspace{1em}\hspace{1em}\forall i,j\hfill \end{array}$$

(21)

$$\begin{array}{cccc}\hfill & S_{ij}\ge S_{kl}+p_{kl}\mathrm{or}{S}_{kl}\ge S_{ij}+p_{ij},\hfill & \hfill & \forall (i,j)\ne (k,l)\mathrm{with}M\left(O_{ij}\right)=M\left(O_{kl}\right),\hfill \end{array}$$

(22)

$$\begin{array}{cc}\hfill & C_{max}=\underset{i,j}{max}(S_{ij}+p_{ij})\to min\hfill \end{array}$$

(23)

Equation (21) enforces the sequencing of operations within each job, ensuring that an operation can only start after its predecessor has completed. Equation (22) imposes machine capacity constraints by preventing overlapping operations on the same machine, thus maintaining mutual exclusivity. The objective, expressed in Equation (23), is to minimize the makespan $C_{max}$, defined as the total completion time of all scheduled operations.

This formulation captures the core temporal and resource dependencies of the robot manufacturing cell. While minimizing makespan is a classical and important scheduling objective, it is not the primary focus of this study. Instead, our emphasis lies on extracting and understanding key temporal characteristics of the system based on event observation, which paves the way for model-based reinforcement learning and enhanced state-value estimation.

To reach this goal, we start by representing the system behaviour using a coloured timed Petri net (CTPN). The timing logic—including processing and transport times—is embedded within the simulation environment but remains hidden from the learning algorithm. These theoretical timing values, summarized in

Table 1. Processing times (in seconds) for each workpiece at each station. A dash (–) indicates that the station is not used by the corresponding workpiece.

Station	$W{\mathit{P}}_1$	$W{\mathit{P}}_2$
Input station $\left(I{B}_1\right)$	0	–
Input station $\left(I{B}_2\right)$	–	0
Working station $\left(S_1\right)$	10	30
Working station $\left(S_2\right)$	20	10
Working station $\left(S_3\right)$	30	20
Output station $\left(OB\right)$	0	0

, serve as ground truth for evaluating our approach.

The matrix T represents the robot transport time (in seconds) between working stations $S_1$, $S_2$, and $S_3$, where $T_{ij}$ is the time to move from station $S_i$ to station $S_j$. Diagonal entries are zero since no transport is needed within the same station:

$$T=\left[\begin{array}{cccc}& S_1& S_2& S_3\\ S_1& 0& 2& 4\\ S_2& 2& 0& 3\\ S_3& 4& 3& 0\end{array}\right]$$

To extract temporal patterns from system execution, we monitor the firing behaviour of critical transitions in the CTPN. These events are transformed into a temporal signal using the dater representation, which serves as input to a tropical neural network. The objective is to reconstruct theoretical timing data purely from observed events and infer emergent timing metrics such as waiting durations, inter-event delays, and synchronization latencies caused by resource contention.

The robot manufacturing cell thus presents a rich, real-world scheduling environment characterized by concurrency, sequencing, and transport delays. By capturing its logic with a coloured timed Petri net and analysing its behaviour through tropical learning, we lay the groundwork for future explainable, model-based reinforcement learning approaches.

In the next section, we formally introduce the coloured timed Petri net representation of the manufacturing cell and detail how its structural and temporal properties are encoded for simulation and learning.

5.2. Modelling Using Coloured Petri

We model the robotic manufacturing cell as a coloured timed Petri net (CTPN), extending our previous work [1] where we demonstrated the effectiveness of Petri nets in modelling discrete event systems. The CTPN captures the dynamics of the job shop scheduling problem and also serves as a simulation environment for reinforcement learning. In this setup, the RL agent’s action space corresponds to the controllable transitions, and the observation space is defined by the current marking of the net.

The system’s state evolves through the firing of transitions in the CTPN model, which distinguishes four types: autonomous, controllable, coloured, and timed. All transitions share a fundamental requirement: each upstream place must contain at least one token. Autonomous transitions fire immediately when this condition is satisfied. Controllable transitions additionally require an external trigger, such as a decision from a reinforcement learning agent. Coloured transitions are enabled only when the token’s colour matches the transition’s specified colour, enforcing correct job–machine routing. Timed transitions become eligible to fire only after the token has remained in the upstream place for a predefined sojourn time, capturing the system’s temporal dynamics.

As depicted in Figure 4, the CTPN of the robotic manufacturing cell begins with job places representing workpieces WP1 and WP2. Each workpiece is modelled as a job requiring three sequential operations, represented by coloured tokens encoding a $(\mathrm{job}, \mathrm{machine})$ tuple. The job identifier ensures traceability, while the machine tag directs the operation to the appropriate machine. The process begins with a job-available places, which enforces precedence constraints by ensuring that only one operation per job is active at a time. A job-selection transition fires if the job is idle, a token is present, and an external trigger, such as a reinforcement learning (RL) decision, is provided. If a shared space is available, the robot transfers the selected workpiece to the next stage via a timed transport transition, simulating physical movement delays. Based on the token’s colour, the workpiece is routed to the correct machine buffer. A machine-allocation transition then fires immediately if the machine is available, controlled by a machine-idle place to guarantee exclusive machine access. Once the processing time elapses, an operation-finish timed transition fires, and the token is returned to the job-available place, enabling the selection of the next operation in the job sequence. This temporal progression ensures that precedence, routing, resource availability, and timing constraints are respected throughout the execution of the schedule.

As previously outlined, the goal is to represent the system as a max-plus linear equation, which will later be transformed into a tropical neural network. To achieve this, the Petri net must be a timed event graph (TEG), also known as a choice-free net. As the name suggests, all choices and resource concurrency must be eliminated. This translates to the structural requirement that every place has exactly one input and one output transition [45]. To satisfy this constraint, we apply unfolding techniques, which are detailed in the following paragraph.

5.3. Unfolding Coloured Timed Petri Net into Timed Event Graph

The goal is to transform the CTPN into a choice-free net to be able to describe it with max-plus algebra. To achieve this, all points of resource concurrency must be eliminated. In Figure 4a, we identify three locations where the choice-free net requirement is violated: (i) the selected operation place has two input transitions, (ii) the dispatching place has three output transitions, and (iii) the output buffer (OB) place has three input and two output transitions. These structural conflicts must be resolved to conform to the choice-free constraint, which requires each place to have exactly one input and one output.

We use the unfolding technique introduced in Section 3.2 to unfold the coloured Petri net in two stages: at the job level and at the machine level.

The first stage involves unfolding the net based on the job. For each job—representing a workpiece—we extract an associated timed event graph (TEG). This is feasible because an external trigger, originating from the reinforcement learning agent or another decision-making component, initiates a sequence of events linked to the job, beginning with the job selection action. An illustration of the resulting TEG from this job-level unfolding is shown in Figure 4b.

Although machines introduce additional sources of concurrency at the level of the dispatching places, Figure 4b, demonstrates that at the step-wise level, only a single route is available for each token based on its colour. As a result, the TEG conditions remain satisfied, and the system’s determinism at this level is preserved.

Once all conflicts are resolved, the model is ready for the next stage, which involves extracting the data and control equations that describe the behaviour of the robotic manufacturing cell.

5.4. Dater and Counter Representations of the Manufacturing Cell

We consider a manufacturing cell processing two jobs, each with $n=3$ sequential operations. Our goal is to identify key timing parameters by logging only essential transitions: select (external trigger), dispatch (material transfer), and process (completion). These capture critical timing events.

To model timing modularly and scalably, we adopt a token-centric approach, where each token represents a job operation flowing through the Petri net. Instead of tracking global states, we focus on the local evolution of individual tokens.

This ensures modularity by treating tokens uniformly, scalability by handling varying job lengths and routes, and interpretability by reducing system behaviour to a structured state-space per token, aiding parameter identification and diagnostics.

We start learning at the operation-token level, then aggregate to the job level, and finally to the system level with multiple concurrent jobs. This hierarchical modelling enhances modularity, scalability, and interpretability of the scheduling system.

Consider a single operation represented by a token with the state vector at a discrete time step k defined as

$$\mathit{X}\left(k\right)=\left[\begin{array}{c}{x}_s\left(k\right)\\ x_d\left(k\right)\\ x_p\left(k\right)\end{array}\right],$$

where $x_s\left(k\right)$ is the selection time, $x_d\left(k\right)$ the dispatch time after transport delay $t_{\mathrm{transfer}}$, and $x_p\left(k\right)$ the processing completion time after processing delay $t_p$. The operation evolves according to the max-plus algebraic equations. The dater formulation is

$$\left\{\begin{array}{c}{x}_{s_i}^{\left(j\right)}\left(k\right)=u_{ji}\left(k\right)\oplus \left\{\begin{array}{cc}0,\hfill & i=1\hfill \\ x_{p_{i-1}}^{\left(j\right)}(k-1),\hfill & i>1\hfill \end{array}\right.\hfill \\ x_{d_i}^{\left(j\right)}\left(k\right)=x_{s_i}^{\left(j\right)}(k-1)\otimes t_{\mathrm{transfer}}\hfill \\ x_{p_i}^{\left(j\right)}\left(k\right)=x_{d_i}^{\left(j\right)}(k-1)\otimes t_{p_{ji}}\hfill \end{array}\right.$$

(24)

And the counter formulation is

$$\left\{\begin{array}{c}{n}_{s_i}^{\left(j\right)}\left(t\right)=max\left(u_{ji}\left(t\right),\left\{\begin{array}{cc}0,\hfill & i=1\hfill \\ n_{p_{i-1}}^{\left(j\right)}\left(t\right),\hfill & i>1\hfill \end{array}\right.\right)\hfill \\ n_{d_i}^{\left(j\right)}\left(t\right)=n_{s_i}^{\left(j\right)}(t-t_{\mathrm{transfer}})\hfill \\ n_{p_i}^{\left(j\right)}\left(t\right)=n_{d_i}^{\left(j\right)}(t-t_{p_{ji}})\hfill \end{array}\right.$$

(25)

The dater formulation can be compactly written in state-space form as

$$\mathit{X}(k+1)=A\otimes \mathit{X}\left(k\right)\oplus B\otimes u\left(k\right),$$

with

$$A=\left[\begin{array}{ccc}\epsilon & \epsilon & \epsilon \\ t_{\mathrm{transfer}}& \epsilon & \epsilon \\ \epsilon & t_p& \epsilon \end{array}\right],B=\left[\begin{array}{ccc}0& \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon \end{array}\right],$$

Extending this framework to a job j composed of three sequential operations, the dater is given by Equation (26) and the counter by Equation (27) for the first job:

$$\left\{\begin{array}{c}{x}_{s_1}^{\left(j\right)}\left(k\right)=u_{j1}\left(k\right)\oplus 0\hfill \\ x_{d_1}^{\left(j\right)}\left(k\right)=x_{s_1}^{\left(j\right)}\left(k\right)\otimes t_{\mathrm{transfer}\mathrm{IB}\to \mathrm{S}1}\hfill \\ x_{p_1}^{\left(j\right)}\left(k\right)=x_{d_1}^{\left(j\right)}\left(k\right)\otimes t_{p_{11}}\hfill \\ x_{s_2}^{\left(j\right)}\left(k\right)=u_{j2}\left(k\right)\oplus x_{p_1}^{\left(j\right)}(k-1)\hfill \\ x_{d_2}^{\left(j\right)}\left(k\right)=x_{s_2}^{\left(j\right)}\left(k\right)\otimes t_{\mathrm{transfer}\mathrm{S}1\to \mathrm{S}2}\hfill \\ x_{p_2}^{\left(j\right)}\left(k\right)=x_{d_2}^{\left(j\right)}\left(k\right)\otimes t_{p_{12}}\hfill \\ x_{s_3}^{\left(j\right)}\left(k\right)=u_{j3}\left(k\right)\oplus x_{p_2}^{\left(j\right)}(k-1)\hfill \\ x_{d_3}^{\left(j\right)}\left(k\right)=x_{s_3}^{\left(j\right)}\left(k\right)\otimes t_{\mathrm{transfer}\mathrm{S}2\to \mathrm{S}3}\hfill \\ x_{p_3}^{\left(j\right)}\left(k\right)=x_{d_3}^{\left(j\right)}\left(k\right)\otimes t_{p_{13}}\hfill \end{array}\right.$$

(26)

$$\left\{\begin{array}{c}{n}_{s_1}^{\left(j\right)}\left(t\right)=max\left(u_{j1}\left(t\right),0\right)\hfill \\ n_{d_1}^{\left(j\right)}\left(t\right)=n_{s_1}^{\left(j\right)}\left(t-t_{\mathrm{transfer}\mathrm{IB}\to \mathrm{S}1}\right)\hfill \\ n_{p_1}^{\left(j\right)}\left(t\right)=n_{d_1}^{\left(j\right)}\left(t-t_{p_{j1}}\right)\hfill \\ n_{s_2}^{\left(j\right)}\left(t\right)=max\left(u_{j2}\left(t\right),n_{p_1}^{\left(j\right)}\left(t\right)\right)\hfill \\ n_{d_2}^{\left(j\right)}\left(t\right)=n_{s_2}^{\left(j\right)}\left(t-t_{\mathrm{transfer}\mathrm{S}1\to \mathrm{S}2}\right)\hfill \\ n_{p_2}^{\left(j\right)}\left(t\right)=n_{d_2}^{\left(j\right)}\left(t-t_{p_{j2}}\right)\hfill \\ n_{s_3}^{\left(j\right)}\left(t\right)=max\left(u_{j3}\left(t\right),n_{p_2}^{\left(j\right)}\left(t\right)\right)\hfill \\ n_{d_3}^{\left(j\right)}\left(t\right)=n_{s_3}^{\left(j\right)}\left(t-t_{\mathrm{transfer}\mathrm{S}2\to \mathrm{S}3}\right)\hfill \\ n_{p_3}^{\left(j\right)}\left(t\right)=n_{d_3}^{\left(j\right)}\left(t-t_{p_{j3}}\right)\hfill \end{array}\right.$$

(27)

The job state vector aggregates the individual operation states as

$${\mathit{X}}^{\left(j\right)}\left(k\right)=\left[\begin{array}{c}{\mathit{X}}_1^{\left(j\right)}\left(k\right)\\ {\mathit{X}}_2^{\left(j\right)}\left(k\right)\\ {\mathit{X}}_3^{\left(j\right)}\left(k\right)\end{array}\right]$$

The intra-job dependencies and time delays are captured in a block-structured system matrix, $A_j$, representing the cascaded operation dynamics.

Finally, for multiple jobs $j=1,2$ running concurrently, the overall system state vector concatenates the job vectors:

$$\mathit{X}\left(k\right)=\left[\begin{array}{c}{\mathit{X}}^{\left(1\right)}\left(k\right)\\ {\mathit{X}}^{\left(2\right)}\left(k\right)\end{array}\right]\in {\mathbb{R}}_{max}^{18},$$

with the overall dynamics

$$\mathit{X}(k+1)=A\otimes \mathit{X}\left(k\right)\oplus B\otimes u\left(k\right),$$

where A and B are block matrices composed of the job-specific matrices $A_j$ and $B_j$, capturing both intra-job sequences and inter-job resource constraints.

$$A_j=\left[\begin{array}{ccccccccc}\epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ t_{\mathrm{transfer}}& \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & t_{p_{j1}}& \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & 0& \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & t_{\mathrm{transfer}}& \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & t_{p_{j2}}& \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & 0& \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & t_{\mathrm{transfer}}& \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & t_{p_{j3}}& \epsilon \end{array}\right]B_j=\left[\begin{array}{ccccccccc}0& \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & 0& \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & 0& \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \\ \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon & \epsilon \end{array}\right]$$

This hierarchical modular structure is modular, as each job’s dynamics lie in diagonal blocks enabling independent control; scalable, as additional jobs extend matrices A and B naturally; and interpretable, as the max-plus algebra formulation captures the timing and ordering constraints explicitly in a transparent mathematical model.

6. Results and Discussion

In this section, we employ supervised learning to train the tropical neural network to reconstruct the system matrices A and B. We begin with a general case where all values are randomly generated, and then we validate it with the robot cell case.

6.1. Dataset Generation and Training

In the first step, we begin by randomly generating and freezing the system matrices A and B. With these matrices frozen, we generate random input–state pairs $\left(\mathit{x}\right(k),u(k\left)\right)$, and compute the next states $\mathit{x}(k+1)$ according to the max-plus system dynamics:

$$\mathit{x}(k+1)=A\otimes \mathit{x}\left(k\right)\oplus B\otimes u\left(k\right),$$

After collecting a dataset of triplets $\left(\mathit{x}\right(k),u(k),\mathit{x}(k+1\left)\right)$, the goal is to reconstruct the original matrices A and B from these transitions alone.

In the second step, after validating the approach on randomly generated data, we apply it to a robotic cell modelled by a coloured timed Petri net. Here, the dynamics encoded in the simulation implicitly define the matrices A and B, and we extract triplets $\left(\mathit{x}\right(k),u(k),\mathit{x}(k+1\left)\right)$ from simulation runs.

The state vector $\mathit{x}\left(k\right)$ records the firing times of key transitions select, dispatch, and process at their k-th occurrence. Since each job consists of three operations, we stack three such vectors per job to represent their temporal progression. The control input $\mathbf{u}\left(k\right)$ corresponds to a scheduler’s input, either by a human operator or by a scheduling algorithm, which selects a transition to fire, triggering the next operation.

As the agent explores different policies during training, it generates diverse triplets used to train a tropical neural network via max-plus regression. Data collection is performed in parallel with training; for example, over 1000 simulation steps, the agent may complete 65 episodes, each yielding multiple triplets. This setup ensures wide coverage of the state–action space and enables the network to learn the system’s timing behaviour and structural constraints.

6.2. Results

We begin with the general case to evaluate the foundational behaviour of the proposed approach. First, we analyse the training dynamics of the learning algorithm. Then, we assess its robustness to noise in the dataset and its adaptability to variations in processing times.

The primary hyperparameter in the training dynamics of the learning algorithm is the learning rate $\alpha$. Its value was determined through an empirical investigation where we evaluated a range of values, specifically ${10}^{-1}$, ${10}^{-2}$, and ${10}^{-3}$, and assessed their impact on convergence speed and training stability. Figure 5 shows the supervised training results using a learning rate $\alpha ={10}^{-2}$ on a dataset of 10,000 randomly generated samples. The plot demonstrates rapid convergence of the L1 loss, indicating that the model effectively captures the underlying max-plus structure.

As shown in Figure 5, the loss stabilizes after approximately 1000 samples, reflecting the influence of the learning rate $\alpha$. The loss corresponds to the cumulative element-wise error between the predicted $\mathit{x}(k+1)$ and the ground truth $\mathit{x}(k+1)$ from the dataset. This behaviour illustrates a key trade-off: a higher learning rate leads to faster adaptation, allowing new data to have a stronger impact on model updates. However, it also increases sensitivity to noise, potentially resulting in unstable training. Conversely, a lower learning rate introduces a form of momentum that smooths updates, promoting robustness but at the cost of slower learning and delayed convergence.

Following the general convergence analysis, we further investigate the convergence behaviour of the learned system matrices A and B. To quantitatively evaluate performance, we employ a similarity metric to compare the learned matrices $\tilde{A}$ and $\tilde{B}$ against their reference counterparts $A_{\mathrm{ref}}$ and $B_{\mathrm{ref}}$. Specifically, we use the Minkowski distance of order 2 ($p=2$):

$$D(x,y)={\left(\sum _{i=1}^n{|x_i-y_i|}^p\right)}^{{\displaystyle \frac{1}{p}}},$$

(28)

where x and y denote the vectorized forms of the matrices. This metric provides a rigorous quantitative measure, enabling us to track how closely the learned parameters approximate the ground truth throughout training.

Figure 6 presents the empirical error curves for both matrices. Both distance metrics decrease rapidly, demonstrating the effective learning capability of the proposed approach. Notably, due to the structural properties of the B matrix and its initialization scheme, its error converges faster than that of the A matrix, which includes processing time parameters and exhibits more complexity.

In Figure 7, we present a detailed element-wise analysis of the system’s prediction performance. The process begins by selecting two random vectors: $\mathbf{x}$ representing the current state, and $\mathbf{u}$ representing the control input. These vectors are then multiplied by the reference system matrices A and B to compute the reference next state, denoted as ${\mathbf{x}}_{\mathrm{ref}}^{+}$:

$${\mathbf{x}}_{\mathrm{ref}}^{+}=A\mathbf{x}+B\mathbf{u}.$$

Throughout the training procedure, snapshots are captured by applying the same input and state vectors to the intermediate learned system matrices $\widehat{A}$ and $\widehat{B}$. The resulting predicted next states, ${\widehat{\mathbf{x}}}^{+}$, are logged at each training step to track the evolution of the learned model and its convergence towards the reference dynamics:

$${\widehat{\mathbf{x}}}^{+}=\widehat{A}\mathbf{x}+\widehat{B}\mathbf{u}.$$

The top subplot in Figure 7 illustrates the trajectory of the reference next state vector ${\mathbf{x}}_{k+1}$ alongside the evolving predictions over the course of training. This visualization highlights the overall convergence behaviour across all state elements.

The bottom four subplots provide a focused view on the evolution of specific state components—namely $x_3$, $x_4$, $x_5$, and $x_6$. These graphs clearly demonstrate that as training progresses, the predicted values increasingly align with the reference states, indicating effective learning and improved accuracy of the model.

Next, we evaluate the adaptability of our approach to dynamic changes within the system. To this end, we simulate a scenario where the timing values in the A matrix are altered midway through training. This change represents shifts in processing times due to factors such as tool wear (leading to slower operations) or transportation bottlenecks, causing delays. Specifically, for the first 50% of the training process, the A matrix remains constant. At the 50% mark, all timing values in the A matrix are scaled to 150% of their original values. This sudden change tests the agent’s ability to adapt to evolving temporal parameters in the environment.

Figure 8 illustrates the system’s response to a change in the reference dynamics. The red curve represents the reference date for a given transition, specifically, the expected firing of transition seven in the next time step. Initially, this transition is predicted to fire at time step 39, based on the initial inputs $x_{\mathrm{ref}}$ and $U_{\mathrm{ref}}$, and their multiplication with the reference matrices $A_{\mathrm{ref}}$ and $B_{\mathrm{ref}}$.

During the first half of training (before the 50% training mark), the system learns the matrix A based on observed data, which is generated using the original reference time and input matrices. The blue and green curves show the evolution of the predicted values obtained by multiplying $x_{\mathrm{ref}}$ and $U_{\mathrm{ref}}$ with the intermediate versions of the learned A matrix throughout training. At the 50% training mark, the reference matrix $A_{\mathrm{ref}}$ is modified to be 150% of its original value. This causes a step change in the target value $x_{k+1}$ (red curve), shifting the expected firing time from step 39 to step 51.

In the static case, where the reference matrix A is frozen after the change, the green curve fails to track the new reference and continues along the outdated trajectory. Conversely, in the adaptive case, the system continues updating the matrix A, and the blue curve successfully adapts to the new reference, eventually aligning with the updated target.

Robustness of the model is evaluated by introducing Gaussian noise with zero mean and a variance scaled from 1% to 10% relative to the original label magnitudes.

Table 2. Minkowski distances between learned and reference matrices and states for varying noise levels.

Noise Level	Matrix Distance	State Distance
$\sigma =1\%$	2.05	2.82
$\sigma =5\%$	9.07	9.59
$\sigma =10\%$	12.98	29.78

presents a comprehensive summary of the resulting Minkowski distances calculated between the learned and reference time matrices, as well as between their corresponding predicted next states $\mathit{x}(k+1)$, under these varying noise levels. This analysis provides insight into the sensitivity of the model’s predictions to increasing noise perturbations.

Figure 9 illustrates the learning behaviour under these noisy conditions. Despite the incremental increase in noise variance, the network’s convergence remains stable, demonstrating strong robustness of the proposed approach. As expected, the reconstruction error increases with higher noise levels, particularly evident in the predicted state errors, which amplify the effect of noisy labels. This analysis confirms that while noise degrades absolute accuracy, the model maintains consistent learning dynamics and resilience in the presence of realistic data perturbations.

Finally, we validate the approach by testing it on a robotic cell. Unlike the general case, this setup requires a specialized initialization procedure. In typical production environments, the initial state vector ${\mathbf{x}}_0$ is often initialized with zeros to indicate that all processes start at time zero:

$${\mathbf{x}}_0=\left[\begin{array}{c}0\\ 0\\ ⋮\\ 0\end{array}\right]$$

However, this introduces a critical problem. If all elements of the system matrix $\mathbf{A}$ are initialized with the max-plus identity element $-\infty$, then the max-plus matrix multiplication

$$\mathbf{A}\otimes {\mathbf{x}}_0$$

yields a vector filled entirely with $-\infty$. This occurs because

$$a_{ij}=-\infty \Rightarrow \underset{j}{max}(a_{ij}+x_j)=-\infty$$

This outcome not only prevents any meaningful progression in learning but also blocks gradient flow during back-propagation, as no finite values propagate through the computational graph.

To overcome this limitation, it is essential to initialize the matrix $\mathbf{A}$ with some finite values. These finite entries enable meaningful max-plus algebraic computations and allow gradients to flow during training, thus facilitating learning. Since the production plan’s structure is assumed to be known a priori, we initialize the timing elements of $\mathbf{A}$, corresponding to processing and transport delays, using the max-plus neutral element $e=0$, which acts as the additive identity in max-plus algebra.

An example of the learned matrix $\mathbf{A}$ for Job 1 is presented below. According to the max-plus dater equation in (24), the elements $A_{3,2}$, $A_{6,5}$, and $A_{9,8}$ correspond to the processing times of the operations in Job 1. Specifically,

$$\begin{array}{cc}\hfill A_{3,2}& =p_{11}=10,\hfill \\ \hfill A_{6,5}& =p_{12}=20,\hfill \\ \hfill A_{9,8}& =p_{13}=30,\hfill \end{array}$$

which represent the durations of processing the operations at Station 1, Station 2, and Station 3, respectively.

Additionally, the elements $A_{2,1}$, $A_{5,4}$, and $A_{8,7}$ represent the transport times between successive stages of the job. Specifically,

$$\begin{array}{cc}\hfill A_{2,1}& =t_{\mathrm{IB}\to \mathrm{S}1}=0,\hfill \\ \hfill A_{5,4}& =t_{\mathrm{S}1\to \mathrm{S}2}=2,\hfill \\ \hfill A_{8,7}& =t_{\mathrm{S}2\to \mathrm{S}3}=3,\hfill \end{array}$$

where $t_{\mathrm{IB}\to \mathrm{S}1}$ denotes the transport time from the input buffer (IB) to Station 1, $t_{\mathrm{S}1\to \mathrm{S}2}$ denotes the transport time from Station 1 to Station 2, and $t_{\mathrm{S}2\to \mathrm{S}3}$ denotes the transport time from Station 2 to Station 3.

$$\tilde{A}=\left[\begin{array}{ccccccccc}-1& -1& -1& -1& -1& -1& -1& -1& -1\\ -0.01& -1& -1& -1& -1& -1& -1& -1& -1\\ -1& 9.96& -1& -1& -1& -1& -1& -1& -1\\ -1& -1& -0.01& -1& -1& -1& -1& -1& -1\\ -1& -1& -1& 1.96& -1& -1& -1& -1& -1\\ -1& -1& -1& -1& 19.85& -1& -1& -1& -1\\ -1& -1& -1& -1& -1& -0.01& -1& -1& -1\\ -1& -1& -1& -1& -1& -1& 2.95& -1& -1\\ -1& -1& -1& -1& -1& -1& -1& 29.93& -1\end{array}\right]$$

We highlight that the various timing values embedded in the matrix $\mathbf{A}$ correspond closely to the predefined processing and transport times of the system. This alignment demonstrates that the proposed approach successfully identifies key system timing parameters solely from input–output observations. Such accurate recovery of timing characteristics validates the effectiveness of the model and confirms its potential for reliable scheduling and control in practical industrial settings.

7. Conclusions

The choice of adequate, adjustable modelling tools is a stepping stone in the optimization of various industrial applications. In this work, we proposed a modelling approach based on timed event graphs that can be trained using a standard approach from the machine learning domain. To this end, we establish equivalence relations between timed event graphs, and their dater and counter representation using max-plus algebra and specifically designed neural networks. We propose learning algorithms designed to adjust the network parameters based on datasets obtained from the system at hand. We employ our approach to scheduling operations within a robot manufacturing cell where the results underscore the applicability and performance of the approach.

Future research will be concerned with more efficient methods to utilize the sample in learning the timing matrix A by using the temperature gradient method. Furthermore, we will integrate our learnable TEG into reinforcement learning loops, in which the TEG serves as a model of the environment similar to model-based RL.