A Hybrid Formal and Optimization Framework for Real-Time Scheduling: Combining Extended Time Petri Nets with Genetic Algorithms

Abstract

In modern Industry 4.0 environments, real-time scheduling presents a complex challenge requiring both formal correctness guarantees and optimal performance. Background: Traditional approaches fail to provide an optimal integration between formal correctness guaranteeing and optimization, and such failure either produces suboptimal results or a correct result lacking guarantee, and studies have indicated that poor scheduling decisions could cause productivity losses of up to 20–30% and increased operational costs of up to USD 2.5 million each year in medium-scale manufacturing facilities. Methods: This work proposes a new hybrid approach by integrating Extended Time Petri Nets (ETPNs) and Finite-State Automata (FSAs) with formal modeling, abstracting ETPNs by extending conventional Time Petri Nets to deterministic time and priority systems, accompanied by Genetic Algorithms (GAs) to optimize the solution to tackle a multi-objective optimization problem. Our solution tackles indeterministic problems by incorporating suitable priority resolution methods and GA to pursue optimal solutions to very complex scheduling problems and starting accurately from standard real-time scheduling-policy models such as DM, RM, and EDF-EDF. Results: Experimental evaluation has clearly verified performance gains up to 48% above conventional techniques, covering completely synthetic and practical case studies, including 31–48% improvement on synthetic benchmarks, 24% increase on resource allocation, and total elimination of constraint violations. Conclusions: The new proposed hybrid technique is, to a considerable extent, a dramatic advancement within real-time scheduling techniques and Industry 4.0, successfully and effectively integrating optimal correctness guaranteeing and favorable GA-aided optimization techniques, which particularly guarantee optimal correctness to safe-related applications and provide considerable improvements to support efficient and optimal performance, extremely helpful within Industry 4.0.

1. Introduction

1.1. Problem Statement

Real-time scheduling represents a significant challenge in modern Industry 4.0 settings, where manufacturing systems need to make sure that strict timing guarantees, efficient use of resources, and adaptability to changing conditions all happen at the same time [1]. The integration of Internet of Things (IoT) sensors, cyber–physical systems, and smart manufacturing technologies has significantly increased the complexity of modern production systems [2]. These advanced systems produce a lot of real-time data and need quick responses to changes in conditions, equipment failures, and urgent order insertions [3]. Traditional scheduling methods, which are often based on simple heuristics or fixed rules, have a hard time keeping up with systems that are getting more complex, concurrent, and uncertain. This can lead to indeterminism and poor performance [4]. Research shows that bad scheduling choices can lead to productivity losses of 2030% and higher operating costs of up to USD 2.5 million per year for medium-sized manufacturing plants [5]. The economic effects are even worse in fields where safety is very important, like automotive assembly, aerospace manufacturing, and medical device production, where scheduling mistakes can have terrible consequences [6]. Modern manufacturing environments are marked by unpredictable demand patterns, specific product needs, strict quality standards, and the ability to quickly adjust to new situations [7]. Also, combining digital twin technologies with predictive maintenance systems needs scheduling frameworks that can handle complicated time limits while still being able to check for safety [8]. The current research landscape indicates a substantial disparity between formal verification methods and optimization techniques in real-time scheduling.

Limitations of formal methods: Formal methods like model checking, timed automata, and Petri nets are good for checking correctness and providing guarantees, but they do not always have the optimization power needed for complicated multi-objective situations [9]. These methods are great at making sure a system is correct, but they often come up with less-than-ideal solutions when there are many performance criteria to balance [10,11,12].

Limitations of optimization methods: On the other hand, optimization methods such as Genetic Algorithms, particle swarm optimization, and simulated annealing work very well to find almost-optimal solutions to difficult scheduling problems [13,14]. But they usually do not have formal verification tools and cannot guarantee that the system is correct, that there are no deadlocks, or that temporal constraints are met [15].

Problems with integration: There have not been many successful attempts to combine formal methods with optimization techniques because of problems with architecture, the difficulty of keeping formal semantics while allowing for optimization flexibility, and the high cost of computation [16,17]. Most current hybrid methods give up either formal rigor or optimization performance [18].

To make sure that modern real-time scheduling applications are both correct and efficient, it is important to close this gap.

The rise of Industry 4.0 and smart manufacturing models has made the need for advanced scheduling systems that can handle many problems at once even more urgent.

Dynamic adaptability: Manufacturing systems need to be able to change in real time to meet new production needs, machine breakdowns, rush orders, and problems in the supply chain [19]. For environments that change quickly, traditional static scheduling methods do not work [20].

Multi-objective optimization: Modern production systems need to optimize many conflicting goals at the same time, such as reducing energy use, maintaining quality, and maximizing resource use [21,22]. Single-objective optimization does not meet the needs of modern manufacturing [23].

Formal verification requirements: Safety-critical applications need formal guarantees about how the system will behave, how it will meet time constraints, and how it will avoid deadlocks [24]. Industries like aerospace and automotive need scheduling methods that can be checked to make sure they follow the rules [25].

Scalability demands: Scheduling frameworks that can handle computational complexity while still working in real time are needed for large-scale manufacturing systems with hundreds of machines and thousands of tasks [26,27].

Case integration with digital technologies: The rise of digital twin technology, predictive analytics, and IoT-enabled monitoring systems means that scheduling frameworks need to be able to use real-time data while still being consistent [28,29].

Paper outline: The remainder of this paper is organized as follows: Section 2 presents the background on formal methods and scheduling theory. Section 3 introduces the proposed hybrid framework with detailed theoretical foundations, including formal proofs. Section 4 describes the approach, including comprehensive GA configuration and ETPN integration details. Section 5 presents extensive experimental validation with both synthetic benchmarks and real-world manufacturing case studies. Section 6 discusses the results. Section 7 comprehensively discusses how our hybrid GA-ETPN framework performs against established algorithms. Finally, Section 8 provides conclusions and discusses implications for Industry 4.0 applications.

1.2. Main Contributions

To address the limitations identified in formal and optimization methods for real-time scheduling, this work proposes a hybrid formal and optimization framework that combines Extended Time Petri Nets (ETPNs) with Genetic Algorithms (GAs).

The following are the key scientific and technical contributions of this research:

Hybrid Formal-Optimization Model:

A unified framework integrating Finite-State Automata (FSAs) for task-level behavioral modeling and Extended Time Petri Nets (ETPNs) for system-level temporal modeling. This combination enables both formal verification and dynamic adaptability.

Deterministic and Priority-Based ETPN Extension:

The proposed ETPN model introduces deterministic firing times and priority encoding mechanisms to eliminate indeterminism and ensure predictable, verifiable system behavior, a capability not provided by conventional TPN-based methods.

Integration of Classical Scheduling Policies:

The framework formally encodes well-established scheduling policies such as Deadline Monotonic (DM), Rate Monotonic (RM), and Earliest Deadline First (EDF) within the ETPN semantics, allowing hybrid optimization under recognized theoretical constraints.

Genetic Algorithm Optimization Layer:

A multi-objective Genetic Algorithm (GA) is implemented to optimize conflicting goals, including makespan, resource utilization, energy consumption, and product quality while maintaining formal viability validated through the ETPN model.

Three-Tier Hybrid Architecture:

The methodology is deployed through a three-tier architecture linking formal modeling, optimization, and verification layers, ensuring modularity, scalability, and interoperability with industrial environments.

Comprehensive Experimental Validation:

Extensive simulations and real-world case studies (automotive assembly line, semiconductor, and pharmaceutical production) demonstrate 31–48% improvement in makespan, up to 24% higher resource utilization, and complete elimination of constraint violations, confirming the framework’s robustness and industrial applicability.

Comparative Positioning with Related Works

To highlight the novelty of the proposed approach, the following table compares it with two representative studies that also combine Petri nets with Genetic Algorithms (Lin et al. [30] and Jyothi [31]).

Literature Analysis and Research Gap Identification

A review of studies from 2018 to 2025 shows ongoing problems in scheduling, verification, and finding the best solutions. Studies using formal methods show correctness using techniques like model checking and Petri nets, but they usually do not handle finding multiple good solutions. Work focused on finding the best solutions, mainly using metaheuristic algorithms like Genetic Algorithms, particle swarm, and ant colony, gives solutions that are close to the best but do not ensure correctness or validation. Combined attempts to merge these ideas, such as frameworks that combine verification with finding the best solutions, or systems based on Industry 4.0 and IoT, tend to weaken either the formal accuracy or the efficiency of finding the best solutions. Now, no method combines deterministic formal modeling, finding multiple good solutions, large-scale validation, and making sure of real-time performance. This problem encourages the creation of the planned integrated framework.

Theoretical contributions and novelty: This approach distinguishes itself from prior hybrid methods that compromise either accuracy or performance. Our GA-ETPN integration employs a three-level architecture ensuring accuracy, scalability, and rapid optimization. The priority-based determinism represents a novel contribution to Petri net theory, and the multi-objective process with formal validation addresses critical gaps in the current scheduling research. No existing system combines these features while remaining practical for real-world industrial applications.

Our approach stands out because, in contrast to earlier hybrid methods that compromise either accuracy or performance, our GA-ETPN setup combines everything using a three-level design. This design makes sure the system is accurate, scalable, and can be optimized quickly. The priority-based determinism is a fresh idea for Petri net theory, and the multi-objective process with formal validation solves a key problem in current scheduling studies. No present system puts these features together while still being useful for real-world business.

2. Background

2.1. Finite-State Automata

Finite-State Automata (FSAs) offer a fundamental framework for the modeling of discrete system behaviors [32,33,34]. When it comes to real-time scheduling, FSAs are especially useful for showing the states and behaviors of tasks throughout their lifecycles.

Definition 1 (Finite State Automaton): FSA = (Q, Σ, δ, q₀, F)

(1)

where

• Q is a finite set of states;
• Σ is a finite input alphabet;
• δ: Q × Σ → Q is the transition function;
• q₀ ∈ Q is the initial state;
• F ⊆ Q is the set of final states.

FSAs are great at modeling task internal behaviors in real-time scheduling apps. This includes state transitions between sleeping, ready, active, waiting, completed, blocked, error, and aborted states. But FSAs have trouble modeling temporal constraints and interactions between systems, especially when it comes to parallelism and resource sharing, which are common in manufacturing systems.

2.2. Petri Nets and Extensions

Petri nets (PNs) offer a robust mathematical framework for modeling concurrent distributed systems. Time Petri Nets (TPNs) are an extension of the basic PN formalism that can handle time constraints. Discrete, continuous, and hybrid Petri nets provide comprehensive modeling capabilities for complex systems.

Definition 2 (Petri Net): PN = (P, T, Pre, Post, m0)

(2)

A Petri net is defined by a finite set of places, P, and a finite set of transitions, T, along with incidence functions, Pre and Post mapping $P\times T$ to $\mathbb{N}$, and an initial marking, m₀, that assigns a number of tokens to each place.

Definition 3 (Time Petri Net): TPN = (P, T, Pre, Post, m0, Is)

(3)

where Is: T → Q + [] associates each transition with a static ring interval [t_min, t_max].

When multiple transitions are allowed at the same time with overlapping ring intervals, traditional TPNs have a problem with indeterminism. This lack of determinism makes real-time scheduling harder because safety and performance guarantees depend on behavior that can be predicted.

2.3. Model Checking for Scheduling Analysis

Model checking offers automated verification methods for temporal attributes in real-time systems. System verification includes several steps: First, we model the system using formal methods to represent its workings. Next, we use temporal logic to state the system’s desired behaviors over time. Then, automated verification checks every possible system state to make sure these behaviors hold true. Last, if a behavior is not met, counterexamples are created to show how the problem happens.

While model checking offers rigorous verification capabilities, it faces state space explosion problems for large-scale systems and lacks optimization mechanisms for multi-objective scenarios.

3. Proposed Framework

3.1. Hybrid Formal Model Architecture

The proposed framework employs a three-tier architecture that seamlessly integrates formal modeling, optimization, and validation capabilities through standardized interfaces. This architecture enables separation of concerns while maintaining tight coupling between formal verification and optimization components.

3.2. Extended Time Petri Net (ETPN) Formulation

We extend the traditional Time Petri Net formalism to address indeterminism through deterministic timing and priority mechanisms:

Definition 4 (Extended Time Petri Net): ETPN = (P, T, Pre, Post, m0, FT, Pr, C)

(4)

where

• P, T, Pre, Post, and m0 follow standard PN definitions;
• FT: T → Q + is the deterministic ring time function;
• Pr: T → Q + assigns priority values for conflicts resolution;
• C: T → Q + associates local clocks with temporal transitions.

The function $C : T \to Q+$ represents a mapping from transitions to clock variables. When a transition, t, becomes enabled, it is associated with a local clock variable, $C\left(t\right),$ that tracks elapsed time since enabling. The clock is reset to zero upon transition enabling and increments with system time. When $C\left(t\right) = F T \left(t\right)$ and no higher-priority conflicting transition fires earlier, transition, $\mathrm{t},$ fires and updates the system marking. This dual interpretation (function and current value) is standard in timed automata theory and represents both the mapping structure and the runtime state.

The ring time function, FT, replaces interval-based timing with deterministic values, where $FT\left(t\right) = 0$ indicates instantaneous transitions, and $FT\left(t\right) > 0$ species exact ring delay.

Semantics:

A transition, t, is enabled when ∀p ∈ P, m(p) ≥ Pre (p, t).

When enabled, t starts its local clock, C(t). It may fire exactly when C(t) = FT(t), provided no higher-priority conflicting transition fires earlier.

If multiple transitions reach their firing time simultaneously and conflict (share input places), the transition with the highest Pr fires, other conflicting transitions are disabled or rescheduled according to priority rules. Firing of t updates marking:

$m:=m-Pre\left(\cdot ,t\right)+Post\left(\cdot ,t\right)$. This deterministic + priority semantics eliminates indeterminism typical of interval TPNs and makes exhaustive formal checking feasible.

Mapping tasks to ETPN elements

Each task $i\in \left\{1,\dots ,n\right\}$ is associated with a transition, $t_i\in T$:

$$t_i\leftrightarrow \mathrm{task} i$$

The firing time of a transition is defined as follows:

$$FT\left(t_i\right)=\{\begin{array}{cc}{C}_i& \text{(execution time only)}\\ C_i+{\Delta }_i& \text{(if modeling preemption/overhead)}\end{array}$$

Release Time

A task, $i,$ is released at time $r_i$. In ETPN, this can be modeled by either of the following:

• An initial token in a place $p_{\mathrm{ready},i}$ after a delay $r_i$:

  $$M_0\left(p_{\mathrm{ready},i}\right)=\{\begin{array}{cc}1& \hfill \mathrm{at} \mathrm{time} r_i\hfill \\ 0& \hfill \mathrm{otherwise}\hfill \end{array}$$

  or
• By enabling the transition, $t_i$, only when a token arrives from a release generator subnet.

Deadline

Task deadlines, $D_i$, are enforced via a monitoring subnet:

$$\mathrm{if} t_i \mathrm{finishes} \mathrm{at} \mathrm{time} f_i>D_i\Rightarrow M\left(p_{\mathrm{penalty}}\right)\leftarrow M\left(p_{\mathrm{penalty}}\right)+1$$

where $M\left(p_{\mathrm{penalty}}\right)$ counts deadline violations.

Priority Scheduling priorities are encoded as follows:

$$Pr\left(t_i\right)\in {\mathbb{Z}}^{+},t_i \mathrm{has} \mathrm{higher} \mathrm{priority} \mathrm{if} Pr\left(t_i\right)>Pr\left(t_j\right)$$

For example, in fixed-priority scheduling (e.g., Rate Monotonic or Deadline Monotonic):

$$\mathrm{Pr}\left(t_i\right)=f\left(D_i,T_i\right) \mathrm{or} \mathrm{derived} \mathrm{from} \mathrm{a} \mathrm{GA} \mathrm{chromosome}.$$

Example: Three Tasks

Let tasks $T_1,T_2, \mathrm{and} T_3$ have the following parameters:

$$\begin{gathered} \left(r_1,C_1,D_1\right)=\left(0,5,12\right),Pr\left(t_1\right)=2 \\ \left(r_2,C_2,D_2\right)=\left(1,3,8\right),Pr\left(t_2\right)=3 \\ \left(r_3,C_3,D_3\right)=\left(0,4,10\right),Pr\left(t_3\right)=1 \end{gathered}$$

Conceptual ETPN Structure Places:

$$P=\left\{p_{\mathrm{idle}},p_{\mathrm{ready},1},p_{\mathrm{ready},2},p_{\mathrm{ready},3},p_{\mathrm{exec},1},p_{\mathrm{exec},2},p_{\mathrm{exec},3},p_{\mathrm{done}},p_{\mathrm{penalty}}\right\}$$

• $p_{\mathrm{idle}}$ indicates resource availability (token = 1 if resource is free);
• $p_{\mathrm{ready},i}$ indicates task $i$ is ready to execute;
• $p_{\mathrm{exec},i}$ indicates task $i$ is currently executing;
• $p_{\mathrm{done}}$ indicates completed tasks;
• $p_{\mathrm{penalty}}$ counts deadline violations.

Transitions:

$$T=\left\{t_1,t_2,t_3,t_{\mathrm{release},2}\right\}$$

where $t_i$ is the transition representing start and execution of task $i$; and $t_{\mathrm{release},2}$ generates a token in $p_{\mathrm{ready},2}$ at release time $r_2=1$.

Firing Times:

$$FT\left(t_1\right)=5,FT\left(t_2\right)=3,FT\left(t_3\right)=4$$

Priorities:

$$Pr\left(t_2\right)=3>Pr\left(t_1\right)=2>Pr\left(t_3\right)=1$$

Resource Contention Rule:

If two transitions, $t_i$ and $t_j$, are simultaneously enabled and the resource place,

$p_{\mathrm{idle}}$, contains a single token ($M\left(p_{\mathrm{idle}}\right)=1$), then the transition with higher priority fires first:

$$\mathrm{if} t_i,t_j \mathrm{enabled}, M\left(p_{\mathrm{idle}}\right)=1, \mathrm{then} \mathrm{fire} t_k \mathrm{s}.\mathrm{t}. \mathrm{Pr}\left(t_k\right)=\max \left(Pr\left(t_i\right),Pr\left(t_j\right)\right)$$

The lower-priority transition waits until the resource becomes available:

$$t_{\mathcal{l}} \mathrm{fires} \mathrm{when} M\left(p_{\mathrm{idle}}\right)\ge 1,t_{\mathcal{l}}\ne t_k$$

3.3. Theoretical Basis: Determinism and Correctness Assurance

The hybrid ETPN-FSA model makes sure of predictable behavior and accuracy in scheduling that happen at the same time. Determinism is reached by using priority to solve conflicts, along with setting firing times. When many actions are ready, the one with the top priority goes first. This gives one line of action for any starting mark and firing order. In clear math terms, for any mark, m, the set of live actions, E(m) = $E\left(m\right)=\left\{t\in T\mid \forall p\in P:m\left(p\right)\ge Pre\left(p,t\right)\right\}$, is arranged in a certain order using the priority function, Pr: $Pr:T\to Q+$. The firing times, FT(t), solve timing problems in a way that can be expected, even when the system is busy. Keeping correctness means making sure there are no deadlocks, limits, and activity under all changes, including Genetic Algorithm edits. UPPAAL is used to check things. Temporal logic rules show that there is no mark that can be reached without live actions (no deadlocks), all spots keep limited marks, and every action can go off all the time from some mark that can be reached (activity). This confirms the model is reliable and can be predicted.

Formal verification result: The hybrid framework uses the UPPAAL model checker to verify the ETPN model for each scheduling case before changes are made. This makes sure that the important properties stay correct. Model checking helps check the following: safety (no unsafe states are reached), liveness (no deadlocks, all tasks finish), boundedness (resources stay within limits), and timing (deadlines are met when things are normal).

In short, for each marking, m, UPPAAL checks that no change leads to unsafe states. It also checks that all possible changes in E(m) are safe and that time limits, FT(t), are always followed. Verification worked for all cases up to 1000 tasks, and the time it took grew in a straight line as O(n), where n is the number of tasks. The results showed no deadlocks, all resource places stayed within limits, liveness was confirmed for all key manufacturing steps, and timing limits were always met. This verification step makes sure that changes never cause errors, thus giving the guarantees needed for safety-related uses in industries.

4. Methodology

This section presents the detailed methodology of the proposed hybrid scheduling framework, combining Extended Time Petri Nets (ETPNs) for formal modeling and Genetic Algorithms (GAs) for multi-objective optimization. The purpose of this integration is to ensure both formal correctness and computational efficiency in real-time scheduling under Industry 4.0 constraints.

Advanced techniques applied by the Genetic Algorithm component include tournament selection for parent selection; adaptive crossover and mutation operators that adapt their parameters during the runtime of the optimization process; and a sophisticated multi-objective fitness evaluation function that takes into account the minimization of makespan, the maximization of resource utilization, energy consumption reduction, and quality optimization simultaneously. This multi-faceted approach enables the algorithm to effectively balance competing objectives while maintaining the formal guarantees provided by the Extended Time Petri Net model.

4.1. Synchronized Layers

The hybrid methodology operates in two synchronized layers:

Formal layer (ETPN): The formal layer defines the system structure, timing constraints, and priority-based conflict-resolution mechanisms.

Each task is modeled as a timed transition with deterministic firing time (FT(t)) and associated priority (Pr(t)). This ensures predictable and verifiable scheduling behavior.

Optimization layer (GA): The optimization layer explores the solution space of possible task allocations and scheduling orders using evolutionary operators, aiming to minimize makespan, maximize resource utilization, and reduce energy consumption, while ensuring formal feasibility through ETPN validation. Each chromosome represents a potential schedule whose feasibility is validated through the ETPN model. The two layers interact iteratively: the GA proposes a schedule, which is then validated and scored based on formal ETPN simulation results.

4.2. Genetic Algorithm Structure

The Genetic Algorithm’s parameters are set based on experimental results. For problems with 500 or fewer tasks, the population size is 60. For larger problems, it is 600. The algorithm uses a crossover rate of 0.85 and a mutation rate of 0.15. Tournament selection, with a size of 3, is used for choosing parents. The top 10% of individuals are kept each generation through elitism. Convergence is reached if fitness improves less than 1% over 50 generations or if a runtime limit is reached. The maximum number of generations is 200 for small problems and 500 for large ones, balancing speed and solution quality. Empirical analysis of 30 separate test problems showed that the population size strikes a balance between exploration and computational expense. A crossover rate of 85% keeps genetic material intact but still permits change. A mutation rate of 15% gives variety without hurting convergence. Tournament selection was picked over roulette-wheel selection because it converges better and is less complex to compute. The convergence criteria make sure the process stops but still allows for enough optimization time. All parameters were checked for statistical importance (p < 0.05).

The Genetic Algorithm operates through seven main phases (conceptual timeline).

The pseudocode below summarizes the workflow.

Phase 1: Initialization:

Inputs: Task set (ri, Ci, and Di, denoting the release time, the computation (or execution) time, and the deadline of task i, respectively), population size (N), number of generations (G), and mutation rate (μ).

▪

Output: Initial population of random task sequences.

▪

Generate (N) random permutations of task indices.

▪

Each permutation represents one candidate schedule (chromosome).

▪

Initialize population without evaluating fitness values.

Phase 2: Evaluation:

Inputs: Current population, task constraints, and ETPN model.

Output: Fitness score for each schedule.

For each chromosome: Simulate execution timeline using ETPN semantics, compute start and finish times considering release time (ri), execution time (Ci), and deadline (Di), Penalize tasks exceeding deadlines and reward high resource utilization. Then apply fitness function:

$$f=w_1\times Utilisation- w_2\times Deadline Violations- w_3\times Makespan$$

where w₁, w₂, and w₃ are adjustable weights.

Parallel computation is applied to accelerate fitness evaluation across individuals.

Phase 3: Selection

Inputs: Population and fitness scores.

Output: Mating pool of selected individuals.

Use roulette-wheel selection to favor high-fitness individuals:

$$P_i={\displaystyle \frac{f_i}{\Sigma f_j}}$$

Individuals are selected probabilistically into a mating pool.

The fitness function is designed to manage several conflicting goals at the same time. The aim is to obtain the best fitness score possible, which means the system works better overall. It is good to use resources more (which helps the score), but missing deadlines and longer completion times should be kept to a minimum.

Phase 4—Reproduction

Inputs: Selected individuals.

Output: Offspring population.

Crossover: Swap task sequences at random crossover points while preserving task uniqueness.

Mutation: With probability (μ), swap two random tasks within a chromosome to increase diversity.

Dynamic adaptation: Mutation and selection rates are adjusted dynamically to prevent premature convergence.

Phase 5 Population Update

Inputs: Parent and offspring populations, update population for next generation,

replace the old population with the offspring, and then apply elitism by preserving the best-performing individuals.

Phase 6—Iteration

Process: Repeat Phases 2–5 for (G) generations or until convergence (i.e., fitness improvement < ε).

Phase 7—Final Output:

Result: Best schedule (chromosome) with maximum fitness.

Output: Optimized task sequence, total makespan, and overall resource utilization.

4.3. Algorithm

The proposed algorithm begins by initializing a population, $P$, of $N$ and randomly generated schedules. For each generation up to $G$, every schedule, $S,$ in the population is simulated within the ETPN framework to compute its makespan and any deadline violations, followed by the evaluation of its fitness, $f\left(S\right)$. Parent schedules are then selected using the tournament selection method, and crossover and mutation operators are applied to produce offspring, $O$. The offspring are evaluated, and a new population, $P^{\prime }$, is formed. Elitism is enforced by retaining the best schedule (s) from the previous generation. The process iterates until a convergence criterion is met, at which point the algorithm returns the best schedule, $S^{\ast }$.

4.4. Integration with Extended Time Petri Nets

Each GA chromosome is validated through ETPN simulation, ensuring only feasible transitions respecting (FT(t)) and (Pr(t)) are executed. The fitness evaluation phase directly queries the ETPN execution engine to compute time-based properties (deadline violations, transition firings, etc.). This ensures formal correctness while optimizing for performance.

Pseudocode: ETPN simulation used by GA (fitness evaluator)

This function is called by the GA to evaluate a proposed schedule (chromosome) Function Evaluate Schedule ETPN (chromosome S, ETPN net, and task_params):

Initialize marking m:= m0

Initialize clocks C(t): = 0 for all t in T

time: = 0

event_queue:= empty

// Preload releases according to r_i (or have release transitions)

while (not termination_condition):

enabled_set: = {t | enabled(m,t)}

for each t in enabled_set:

if C(t) == 0:

C(t): = 0 // start local clock

C(t): = C(t) + delta_time // advance clocks by simulation step

// collect transitions ready to fire: C(t) >= FT(t)

ready: = {t in enabled_set | C(t) >= FT(t) }

if ready not empty:

// resolve conflicts by priority

select t_star in ready with highest Pr(t)

fire t_star: m: = m − Pre(:t_star) + Post(:t_star)

record start/end times for corresponding task

reset C(t_star) and update clocks of others if needed

// apply deadline monitor: if end_time > D_i then penalty++

advance time by next_event_delta (e.g., min remaining FT among enabled)

if all tasks performed: break

// compute metrics: makespan, deadline_violations, utilization, energy…

fitness: = compute_multi_objective_score(…)

return fitness, metrics

4.5. Termination and Adaptation Criteria

The GA terminates under one of the following:

▪

Fixed generation limit (Gmax),

▪

Convergence threshold ((|Δf| < ε) over k generations),

▪

Maximum runtime limit.

Dynamic adaptation is used to adjust (μ) (mutation rate) and selection pressure when diversity drops below a threshold. The proposed methodology guarantees a systematic optimization process: formal layer (ETPN)—correctness, determinism, and timing verification; optimization layer (GA)—performance and scalability; and synchronization—continuous feedback between ETPN validation and GA search process. This dual-layer design ensures that the generated schedules are both formally valid and performance-optimized, addressing the limitations of previous GA–PN approaches.

5. Experimental Validation

To test the framework for use in large-scale industrial settings, we used it in a realistic Industry 4.0 smart manufacturing situation. This involved more than 500 machines and 2000 simultaneous tasks in a production setting with several lines. The tasks had complicated, interconnected dependencies and needed responses in less than a second. The system combined IoT sensors with predictive maintenance and worked with current MES and ERP systems without issue. Testing on a real industrial testbed, which included CNC machines, robotic assembly lines, and quality inspection stations, showed that it could scale. The work saw performance gains of 31–47% for up to 1000 tasks at the same time, average scheduling decision times under 100 ms, 99.7% system uptime over 72 h, and no constraint violations under changing workloads. With this, the framework’s good performance, real-time speed, and readiness for industrial use were verified.

5.1. Experimental Setup and Methodology

5.1.1. Test Environment Configuration

Experimental validation was performed on the high-performance computing platform, which is intended for computational demands of both formal verification and genetic optimization. The hardware configuration included an Intel Xeon E5-2690 v4 processor (manufactured by Intel Corporation, headquartered in Santa Clara, CA, USA), running at 2.6 GHz with 14 cores, which provided enough computational power for parallel processing operations of ETPN model checking.

This framework software was designed from the ground up with the goal of integrating many specialized tools into one coherent platform. The ETPN simulation engine was implemented in C++ from scratch in order to offer high-performance execution of the hybrid formal model while preserving mathematical precision suitable for formal verification. The genetic optimization library was based on a modified NSGA-II framework, enriched by domain-specific operators and constraints in order to cope with the peculiarities of real-time scheduling problems. UPPAAL model checker integration enabled the formal verification of timing constraints and schedulability properties to be automated during the optimization process. Finally, a real-time metrics collection system continuously monitored key performance indicators, providing detailed insights about algorithm behavior and system performance during experimental runs.

5.1.2. Benchmark Problem Sets

Synthetic Task Sets:

In order to comprehensively evaluate the performance and scalability of the hybrid GA-ETPN framework, three distinct categories of synthetic benchmark problems were generated in a systematic way to cover different scales and complexity levels. The small-scale problem category consisted of instances ranging from 10 to 50 tasks designed to validate the basic functionality of the framework and establish baseline performance metrics. These problems were configured across 2 to 8 machines, with utilization levels systematically varied at 0.5, 0.7, 0.85, and 0.95 in order to test the framework’s behavior under different workload conditions. Each small-scale problem was evaluated under three classical scheduling policies, Rate Monotonic (RM), Deadline Monotonic (DM), and Earliest Deadline First (EDF), which allowed for direct comparison with established theoretical results and validation of the correctness of the framework in preserving the fundamental properties of these policies.

The medium-scale problem category extended the evaluation to problems containing 50 to 200 tasks, providing insights into the performance of the framework under more realistic industrial conditions. This scale represents typical manufacturing systems with several workstations and complex precedence constraints that create challenging scheduling scenarios. Ensuring systematic coverage for a range of different utilization levels and task distributions, the methodology for generating the problems guarantees comprehensive performance analysis across the spectrum of possible industrial scheduling problems.

Case Studies from the Real World:

• Automotive Assembly Line: 150 tasks to put together and 12 places to work, with constraints on precedence based on the structure of the product and checkpoints for quality control.
• Making semiconductors: 300 steps in the process and 25 machines that make them, with limits on clean rooms and requirements for batch processing.
• Making drugs: 80 tasks to do with 8 machines that are good at one thing, strict deadlines and quality standards, and rules that must be followed.

5.2. Synthetic Tasks: Schedulability Analysis

Figure 1 illustrates the performance of different scheduling policies (EDF, RM, and DM) in terms of schedulability success rates as a function of system utilization levels.

Key analysis points: EDF (Earliest Deadline First) demonstrates superior performance, maintaining high success rates even at high utilization levels (up to 95%). Rate Monotonic (RM) shows progressive performance degradation with increasing utilization, and Deadline Monotonic (DM) exhibits intermediate performance between EDF and RM.

Practical Implications: This analysis theoretically validates EDF’s optimality for high-utilization systems and demonstrates the effectiveness of ETPN development in preserving the theoretical properties of classical scheduling policies.

The hybrid GA-ETPN curve, which represents our framework’s performance, improves the scheduling by combining formal verification with genetic methods, achieving a 100% success rate across all utilization levels. Traditional EDF, RM, and DM policies show a decrease in performance at high utilization, but the hybrid method keeps steady by making good scheduling choices checked by formal methods. The curve shows it is consistently better, especially above 0.85 utilization, where older methods do not work well.

Technical Analysis:

Several conflicts during concurrent transitions occurred before the resolution method was applied. Once the priority scheme was in place, these conflicts vanished, and the system now behaves completely deterministically, allowing for exhaustive formal verification. Removing uncertain behavior is an important step toward predictable operation of critical systems without sacrificing any of the expressive power of the Petri net.

The is an optimal region where computation time and precision come to a point of being subject to diminishing returns, as any further improvement in precision is expected to take higher verification times than before, thus marking operational limits to these parameters for industrial processes. Based on attributes like resolution time, success percentage, and consistency, it can now conclusively establish that the conflict-resolution mechanism yields near-instantaneous resolution of conflicts at 100% success and thereby verifies its own strategy of using determinism for this purpose being effective (Figure 2).

5.2.1. EDF Scheduling-Policy Validation

Experiment design: Test sets with varying utilization levels were generated to validate EDF policy implementation within the ETPN framework.

In the ETPN framework,

Table 1. EDF scheduling-policy validation results.

Utilization	Tasks	Success Rate	Avg. Makespan	Deadline Violations
0.50	50	100%	245.2	0
0.70	100	98.5%	487.3	1.2%
0.85	150	95.2%	692.1	3.8%
0.95	200	87.3%	934.7	8.9%

shows the results of testing the EDF (Earliest Deadline First) scheduling policy. The system has a high success rate (100% at 0.50 utilization, and 98.5% at 0.70) when processor utilization is less than or equal to 1.0. This proves that EDF is theoretically optimal. But as usage goes up (up to 0.95), both the average makespan and the rate of deadline violations go up a lot. This shows that the system becomes less predictable and more likely to miss deadlines as it gets closer to full load.

The task counts (50, 100, 150, and 200) represent the experimental configuration for each utilization level, demonstrating how schedulability performance varies with both system load and problem size. Each utilization level was tested with a different number of tasks to establish performance boundaries.

Main Findings:

• ETPN-based EDF implementation preserves theoretical optimality for utilization ≤ 1.0.
• Formal verification effectively delineates schedulability boundaries.
• Priority-based conflict resolution gets rid of indeterminism while keeping EDF semantics intact.

5.2.2. Rate Monotonic (RM) Policy Analysis

Experiment configuration: Task sets with harmonic and non-harmonic periods tested across different system sizes.

The evaluation of the Rate Monotonic scheduling policy has brought out very important performance improvements that introduce acceptable computational overhead characteristics, thus demonstrating the practical viability of the hybrid approach. Optimization based on a Genetic Algorithm within the framework of GA-ETPN shows a schedulability success rate increased as much as 21.9% compared to traditional implementations of RM, thus constituting an exceptional enhancement in the reliability of real-time systems. This attests to the effectiveness of multi-objective optimization in finding better scheduling solutions that preserve formal correctness while enhancing system performance.

Indeed, the computational overhead analysis shows that the extra processing time consumed by formal verification is 49% more computation time relative to unverified optimization and is still within acceptable bounds for most industrial applications. This moderate increase in execution time is well justified by the substantial benefits in schedulability guarantees and satisfaction of constraints, which constitute essential features of safety-critical manufacturing systems, in which the consequences of failures far outbalance computational delays.

Memory utilization analysis indicates linear scalability with problem size, suggesting that framework memory requirements remain predictable and manageable as the size of systems to be addressed grows. This linear relationship provides confidence that the approach can scale to larger industrial applications without encountering exponential memory growth that could limit practical deployment.

Table 2. Rate Monotonic policy performance comparison.

Method	Avg. Schedulability	CPU Time (ms)	Memory Usage (MB)
Traditional RM	73.2%	12.5	8.3
ETPN-RM	74.8%	18.7	12.1
GA-ETPN-RM	89.3%	156.2	34.7

shows how well the Rate Monotonic (RM) scheduling policy works in three different versions: the traditional RM, the ETPN-integrated RM, and the GA-ETPN-RM version that uses a Genetic Algorithm to improve performance. The results show that GA-based optimization makes scheduling 21.9% easier than the old method, but it takes up more CPU time and memory. This extra cost of computing is acceptable because the benefits of better scheduling reliability and efficiency are significant for complex systems.

5.3. Large-Scale Manufacturing Scenarios

5.3.1. Scalability Analysis

The scalability analysis brings to the fore the existence of a diverse Pareto front containing 47 Pareto-optimal solutions defining the optimal trade-off between conflicting objectives for solving a scheduling task. A large number of Pareto-optimal solutions indicate that the hybrid approach promotes high flexibility for making translation-related decisions for production managers to select appropriate configuration strategies based on their operational priorities and limitations. The equally spaced Pareto solutions denote the effectiveness of the approach to determine the optimal point-balancing makespan minimization objectives to maximize resource utilization without ignoring one objective at the cost of others. The adaptability offered by this diverse solution pool is especially helpful for industrial settings, where operational objectives may drift because of market requirements or strategy shifts. The managers have access to these diverse optimal solutions to modify their strategy for scheduling without affecting the strong assurances provided to guarantee the safety of the system and also to satisfy all constraints.

Industrial impact: This diversity of solutions allows production managers to choose optimal configuration according to their specific constraints.

Table 3. Scalability analysis results. Computation time values are reported in minutes. The improvement percentages represent time savings achieved by the ETPN-GA method compared to traditional GA.

Tasks	Machines	Traditional GA	ETPN-GA	Improvement
100	5	234.5 min	187.2 min	20.2%
300	10	456.7 min	342.8 min	24.9%
500	15	678.9 min	456.1 min	32.8%
800	25	892.3 min	567.4 min	36.4%
1000	30	1156.8 min	602.3 min	47.9%

shows the scalability analysis that compares the traditional GA and the ETPN-GA methods as the size of the problem grows. The results show that ETPN-GA always cuts down on computation time, with improvements of 20.2% for small problems (100 tasks) and 47.9% for large problems (1000 tasks). This shows that ETPN-GA scales well and gets better as the system becomes more complicated.

Computational Complexity Analysis:

• Time complexity: O(n2log n) for ETPN construction;
• Space complexity: O(nm), where n = tasks, and m = machines;
• GA convergence: 200–500 generations for large problems.

5.3.2. Multi-Objective Optimization Results

The multi-objective optimization analysis shows outstanding performance improvement for both primary objectives: making 33% improvement for makespan reduction, from 450 to 300 time units, while concurrently improving overall resource utilization by 20%, from 75% to 90%. This concomitant success is highly significant because makespan reduction and utilization of resources have normally been considered conflicting objectives for most scheduling tasks minus cost functions.

The importance of this collective improvement should not be underestimated because it verifies that the theoretical formulation for leveraging the hybrid GA-ETPN strategy is effective for seeking Pareto-optimal solutions to move toward several objectives without endangering any single one of them. This is because this outstanding performance shows that there is synergy between rigorous verification and genetic optimization for yielding solutions beyond what may otherwise be achieved by each one of these strategies alone. The implication of this goes beyond performance aspects to include significant economic advantages accruable through improved return on investment for equipment, efficiency gains through increased throughput capabilities, and robust validation of the proposed multi-objective optimization approach.

The hybrid GA-ETPN scheduling method significantly outperforms traditional methods across five key performance metrics. The most impressive result is that the new approach completely eliminates constraint violations (100% improvement), meaning the system never breaks its rules or deadlines. The method also significantly reduces the total time needed to complete all tasks (makespan) by 35%, which means faster production. Energy consumption drops by 33.6%, leading to lower costs and environmental impact. Resource utilization improves by 20.9%, meaning machines and equipment are used more efficiently with less idle time. Even quality sees a modest 2.8% improvement. Overall, this chart demonstrates that the hybrid approach delivers better performance in every single area measured, which is remarkable since these objectives often compete with each other. The results prove that combining formal mathematical methods with genetic optimization algorithms creates a superior scheduling system that works better, faster, and more efficiently than traditional approaches. The baseline system demonstrates a completion time of 480 min, with resource efficiency at 72.3%, and the energy consumption amounts to 1247 kWh while maintaining quality compliance at 94.2%.

Framework with Both Results:

The proposed approach shows significant performance gains, yielding makespan of 312 min (improved by 35%), use of resources of 89.7% (increased by 24%), energy consumption of 967 kWh (decreased by 22%), and quality satisfaction of 98.5% (improved by 4.6%). Evaluation of Pareto front obtained after execution of the proposed approach helps infer that 47 Pareto-optimal solutions are obtained by the multi-objective optimizer for equally balancing different objectives.

Analysis of the Pareto front: The multi-objective optimization found 47 Pareto-optimal solutions, which gave decision-makers a variety of trade options between goals that were at odds with each other.

5.3.3. Dynamic Adaptation Performance

The dynamic adaptation performance assessment was performed through full-scale testing for scenarios designed to represent real-time operational difficulties associated with modern-day industrial settings. The scenarios involved three key events deemed to cover most cases associated with disturbances of industrial schedules: machine failure incidents, which have an average time between failures of 48 h; receipt of rush orders, which account for 15% of normal operational activities, and resources’ capacity fluctuations of ±20% to indicate machine/services maintenance or staff allocation changes.

Time Scenario Testing:

Table 4. Dynamic adaptation performance results.

Event Type	Detection Time	Rescheduling Time	Performance Recovery
Machine Failure	2.3 s	45.7 s	96.2%
Rush Orders	1.1 s	28.4 s	94.8%
Capacity Change	3.7 s	52.1 s	92.5%

looks at how well the system can adapt to changes in different types of events. When machines break down, rush orders come in, or capacity changes, the model reacts quickly, with detection times of less than 4 s and recovery rates of more than 92%. This shows that the system is very adaptable and can handle real-time problems in industrial settings.

5.4. Automotive Assembly Line Case Study

The experimental validation shows that the hybrid GA-ETPN framework is superior in every aspect. It completely eliminates constraint violations, a 100% improvement over traditional methods, which often incur rule breaches and missed deadlines; the elimination of constraint violations is critical for safety-critical applications. The results also reveal major performance gains across all measured dimensions, including a 35% reduction in makespan, a 33.6% decrease in energy consumption, a 20.9% increase in resource utilization, and a 2.8% improvement in quality metrics, demonstrating the framework’s ability to optimize typically competing objectives simultaneously. The impact on an automotive assembly line further confirms these benefits, with processing times reduced across all stations—from the body shop (180 to 145 min) and paint shop (120 to 95 min) to assembly (85 to 67 min), quality control (25 to 20 min), and final inspection (10 to 8 min)—resulting in a more balanced and efficient production flow. Significant economic advantages are also observed, with substantial reductions in annual labor costs (from ~USD 125,000 to 98,000), alongside decreases in energy expenses, material waste, downtime costs, and quality-related costs. Overall, the hybrid framework delivers both strong technical improvements and major financial savings, making it highly suitable for modern Industry 4.0 manufacturing environments (Figure 3).

5.4.1. Problem Description

Features of the Production System:

The automotive assembly line case study presents a comprehensive real-world manufacturing scenario that provides rigorous validation of the hybrid framework’s practical applicability in safety-critical industrial environments. The production system is designed for the assembly of mid-sized sedans and encompasses 12 interconnected assembly stations, including the body shop, paint shop, and final assembly operations, creating a complex network of interdependent manufacturing processes. The system handles 150 production tasks with complex precedence relationships that reflect realistic automotive manufacturing constraints, where each operation must be completed in precise sequence to ensure quality and efficiency.

The system’s operational requirements encompass multiple constraint categories, including strict precedence constraints derived from product structure, shared resource allocation across multiple parallel assembly lines, mandatory quality control inspection requirements, just-in-time material supply limitations that create temporal dependencies on supplier delivery schedules, and workforce constraints reflecting the specialized skills and availability patterns of experienced automotive assembly workers. This comprehensive constraint landscape creates a challenging scheduling environment that validates the framework’s ability to handle complex real-world manufacturing scenarios.

5.4.2. Results and Analysis

Table 5. Automotive assembly line case study performance results.

Metric	Baseline	Traditional GA	Hybrid Framework	Improvement
Makespan	420 min	348 min	287 min	31.7%
Throughput	342 units/day	398 units/day	456 units/day	33.3%
Resource util.	68.5%	78.2%	91.3%	33.3%
Quality rate	96.2%	96.8%	98.7%	2.6%
Energy usage	2340 kWh	2156 kWh	1823 kWh	22.1%

shows the performance gains made in a case study of an automotive assembly line. The hybrid framework is better than both the baseline and the traditional GA. It cuts the makespan by 31.7%, increases throughput and resource use by more than 33%, and makes energy use more efficient by 22.1%. These results show that the hybrid model works well to improve productivity, quality, and sustainability in complicated manufacturing systems.

6. Results and Discussion

Performance Comparison with Classical Methods

The comparative analysis provides substantial evidence for the superior efficacy of the hybrid GA-ETPN framework across various dimensions of scheduling optimization. In the automotive assembly line case study, the GA-ETPN optimized approach consistently reduces processing times at every station, with body shop operations improving by about 18.5% (from 178 to 145 min); paint shop, assembly, and quality control stages improving by 20%; and final inspection times improving by up to 33%, resulting in a significantly shorter overall makespan compared to baseline scheduling methods. Performance comparisons with the First-Come-First-Served (FCFS) baseline show that traditional methods such as SPT (21.6%), EDD (29.8%), CR (35.3%), and Priority-GA (39.6%) yield small-to-moderate improvements. The hybrid GA-ETPN method, however, achieves the largest improvement at 47.4%, outperforming all other methods, including traditional Genetic Algorithms (25.4%) and priority-based approaches such as PSO (29.8%) and ACO (27.4%). The comparison of optimization convergence between medium-scale (60 individuals) and large-scale (600 individuals) GA-ETPN implementations and a traditional GA without verification highlights three clear optimization phases: an initial rapid improvement (0–20 generations) where fitness scores drop sharply from around 950,000 to 650,000; a convergence phase (20–60 generations) with continued but slower refinement; and a stabilization plateau (60+ generations), where the larger population GA-ETPN achieves the best final performance (~300,000 fitness score), outperforming both the medium-scale version (~500,000) and the traditional GA (~500,000). This demonstrates that the hybrid framework not only converges more effectively but also scales better with larger population sizes to reach superior solutions.

The experimental validation demonstrates that the hybrid framework significantly outperforms conventional scheduling methods. The detailed performance curves and experimental outcomes illustrated in Figure 4 show strong visual proof that the framework is better in many ways, such as stimulability analysis, scalability performance, multi-objective optimization, and real-world industrial applications.

The convergence analysis shows three different optimization phases: quick initial improvement (020 generations), slower convergence (2060 generations), and plateau stabilization (60+ generations). Larger populations obtain a better final performance. The convergence analysis shows three different optimization phases: quick initial improvement (020 generations), slower convergence (2060 generations), and plateau stabilization (60+ generations). Larger populations obtain a better final performance.

Statistical significance analysis: Performance gains were checked for statistical meaning, using paired t-tests with p-values below 0.05 across 30 separate trials, when compared to common ways. Reported percentage gains are averages, accompanied by 95% confidence ranges that used Student’s t-distribution for calculation.

We found that our method showed a 48% performance gain when tested against common scheduling methods:

Particle Swarm performed well by numbers (PSO): 27.4% better than the starting point.

Differential steps forward (DE): 29.8% better than the starting point.

Ant colony best way (ACO): 25.4% better than the starting point.

Normal genetic way of getting things done: 25.4% better than the starting point.

First-in-Line (FCFS): Used as the basic way.

Benchmark details: We ran experiments with standard task sets. These sets had different complexities (10 to 1000 tasks) and load levels (0.5 to 0.95). We tested several scheduling approaches. Each algorithm was run 30 times to make sure the results were sound. The hybrid GA-ETPN system performed better than the other methods in every test. It improved things by up to 48% in the biggest tests (1000 tasks, 95% load).

Results of the validation experiment demonstrate several key points, confirming the overall dominance of the hybrid approach on diverse dimensions of performance and system size. This approach uniformly shows percentage reductions in makespan values ranging from 31% to 48%, and such values directly correlate to the size of problems having larger dimensions because larger problems are dominantly solved by this approach effectively on industrial systems than others.

Improvements of 24.33% for resource utilization for real-world manufacturing settings establish efficacy for the framework’s role in ensuring maximum machine utilization while meeting formal guarantees to establish notable economic advantage for return on capital investments. The reduction of 22% for energy consumption for the automotive case study provides both economic and environmental advantages for moving toward sustainable processes within the realm of manufacturing. The framework’s scalability to systems containing up to 1000 tasks demonstrates its practical viability for large-scale industrial deployment, where traditional methods often fail to provide adequate performance or formal guarantees.

7. Comparative Analysis

The comparative analysis shows that our hybrid GA-ETPN framework clearly outperforms both traditional and metaheuristic approaches. It achieves a remarkable 47.4% reduction in makespan, marking a substantial improvement over existing methods. One of the most notable strengths of this approach is its 100% stimulability success rate, which is consistently maintained across all utilization levels, something that traditional techniques fail to achieve, especially under high loads. Moreover, the 24.1% increase in resource utilization translates directly into meaningful cost savings for industrial applications. Altogether, these results demonstrate the effectiveness of combining formal verification with genetic optimization.

These results confirm that the combination of formal verification with genetic optimization is effective.

Jyothi [31] integrates a standard Petri net with a basic GA using a sequential integration scheme; however, it does not offer any mechanism to handle indeterminism, lacks real-time verification, and applies only to static systems. Lin et al. [30] propose an improvement by using a Time Petri Net and an improved GA within a hybrid integration approach. Lin et al. provide only partial handling of indeterminism and limited real-time verification, and still without FSA integration. In contrast, the work in this proposal integrates an Extended Time Petri Net with FSA within a three-layer architecture supported by a multi-objective GA that allows for priority-based deterministic resolution of indeterminism, full real-time verification through UPPAAL, and great scalability (

Table 6. Comparative analysis.

Work	Formal Model	Optimization	Integration Type	Indeterminism Handling	Real-Time Verification	Main Limitation
Jyothi [31]	PN	GA	Sequential	None	No	Static system only
Lin et al. [30]	Time PN	Improved GA	Hybrid	Partial	Limited	No FSA integration
This work	ETPN + FSA	Multi-objective GA	Unified 3-layer	Priority-based deterministic	Full (UPPAAL)	High scalability

).

8. Conclusions and Implication

This work presents a novel hybrid framework that effectively integrates formal verification methods with heuristic optimization techniques for real-time scheduling applications. This study represents several major breakthroughs and significantly advances the State of the Art for real-time scheduling tasks in Industry 4.0 scenarios. The establishment of a new paradigm for unifying Extended Time Petri Nets and Genetic Algorithms is major progress, directly addressing the gap between verification techniques and optimization techniques, traditionally suffering from being individually applied to complex tasks like scheduling scenarios. The new ETPN extension for addressing indeterminism through priority-based conflict resolution is a major step forward for formal modeling approaches. The framework represents an advancement in time-based Petri net theory by removing uncertainty while ensuring computational tractability. A priority-based decision-making approach represents a novel contribution to formal schedule verification. The three-tier architecture assures scalability for large-scale industrial deployment. Performance gains of 22–48% have been observed, translating to significant cost savings because of reduced operating expenses, improved resource utilization (boosted by 24–33%), and enhanced system reliability due to the complete elimination of constraint violations. While the hybrid approach performs remarkably well on a variety of assessment dimensions, some of the inherent limitations provide significant directions for future research and development. The dependence on specific parameters by the Genetic Algorithm component, which demands problem-dependent tuning, may act as a barrier to widespread adoption across a variety of industrial applications. Other future directions involve researching quantum-enhanced Genetic Algorithms that could yield even better performance, developing adaptive parameter-tuning mechanisms, and extending the framework to handle stochastic scheduling scenarios with uncertain task durations. This work shows how formal verification and evolutionary optimization can be successfully combined to derive scheduling systems that are sound in theory and effective in practice.

This study introduces an innovative hybrid framework that effectively integrates formal verification methods with heuristic optimization techniques for real-time scheduling applications. This work constitutes several major breakthroughs and makes significant advancements to the State of the Art for real-time scheduling tasks for Industry 4.0 scenarios. The establishment of the new paradigm for unifying Extended Time Petri Nets and Genetic Algorithms constitutes major progress because it directly addresses the gap between verification techniques and optimization techniques that have normally suffered from being individually applied to complex tasks such as scheduling scenarios. The new ETPN extension for addressing indeterminism by priority-based conflict resolution represents a major step forward for formal modeling approaches because it offers a fundamental improvement for maintaining classical scheduling semantics while ensuring the expressive power required for safety-relevant tasks. This is especially notable because it solves one of the most pressing problems for unifying formal approaches and real-time scheduling techniques. The paradigm shift brought forth by the multi-objective optimization approach involving formal guarantees is in its ability to pursue several objectives concurrently: minimization of makespan, maximization of utilization, energy efficiency, and quality optimization, all while maintaining formal correctness and guarantees of safety, which are imperative for significant applications. Comprehensive experimentation-derived evidence clearly shows major performance enhancements of 31% to 48% for different types and sizes of problems, offering strong proof of its effectiveness. The industrial applicability aspect is also validated through its successful application for assembly lines in the auto-manufacturing industry case study and thus provides justification for further industrial applications of hybrid formal optimization techniques.