SkiNet-Sim: Simulating Petri Nets with Data for the Verification and Validation of Controllers for Autonomous Systems

Baptiste Pelletier, Karen GodaryarXiv 2026 · DOI · arXiv

TL;DR

SkiNet-Sim introduces Augmented Petri Nets (APNs), a formalism that bridges the gap between abstract formal models and real-world robotic code. By allowing Petri nets to interact with arbitrary data and Python-based logic, it enables engineers to verify complex autonomous missions—like industrial inspections—while accounting for physical constraints like battery life and spatial orientation.

What Problem Does This Paper Address?

Verifying that an autonomous robot will successfully complete its mission is notoriously difficult. Researchers typically face a "Goldilocks" problem with models:

  1. Too Simple: High-level models (like classical Petri nets) are easy to verify but ignore physical realities (e.g., "Does the robot have enough battery to reach the next waypoint?").
  2. Too Complex: Low-level models that include every physical detail suffer from "state-space explosion," becoming mathematically impossible to solve.

Petri nets are excellent for modeling concurrent systems, but their standard versions are often too rigid for industrial use. The authors aim to find a "middle ground" by separating the core logic of the system (concurrency and synchronization) from the messy, implementation-specific details of the software and hardware.

Methods

The authors propose Augmented Petri Nets (APNs). In this framework, a classical Petri net is "augmented" with:

  • Arbitrary Data ($D$): A global state that exists alongside the Petri net (e.g., battery levels, coordinates).
  • Guards ($G$): Boolean functions that check the data state before a transition can fire.
  • Effects ($E$): Functions that update the data state when a transition fires.

Crucially, these guards and effects can be written in standard programming languages like Python, allowing developers to reuse actual controller code within the formal model.

The SkiNet-Sim tool implements this formalism. As shown in Figure 1, it takes high-level mission specifications and generates a Python-based interface. This interface links the Petri net transitions to "user functions" that simulate sensing, computation, and control.

Figure 1: SkiNet-Sim is an implementation of the Augmented Petri net formalism, tailored for robotic applications. External tools are highlighted in yellow, while user-written elements are in green.

For verification, the tool uses a Data-Aware State-Space Construction algorithm. It performs a depth-first search to explore all possible combinations of Petri net markings and data states, which can then be checked using standard tools like the TINA toolbox.

Datasets

The paper evaluates the approach using two primary scenarios:

  1. UGV Waypoint Navigation: A simple model of an unmanned ground vehicle navigating three points to test battery consumption logic.
  2. Industrial Inspection Mission: A complex, real-world use case involving a Boston Dynamics Spot quadruped robot equipped with a Kinova Jaco robotic arm. The mission requires the robot to navigate an underground environment, inspect pipes for heat anomalies, and read manometers.

Key Insights and Ideas

  • Determinizing Outcomes: In a classical Petri net, a "failure" transition might fire randomly. In an APN, that failure only occurs if the data (e.g., battery < 30%) justifies it. This makes verification results much more meaningful for stakeholders.
  • Pruning the State Space: Counter-intuitively, adding data can sometimes reduce the number of states to explore. By using guards to block impossible transitions, the authors found their data-aware model for the inspection mission had fewer states (363) than the classical version (862).
  • Code-Level Diagnostics: When a mission fails during model-checking, SkiNet-Sim doesn't just say "it failed." It can point the developer to the specific fragment of Python code (the guard) that prevented the mission from progressing.

Key Results

The authors successfully validated a complex inspection mission that had previously only been checked with abstract models.

  • Finding "Hidden" Bugs: The data-aware simulation revealed that the robot could end up facing the wrong direction after reaching a waypoint depending on its approach path. This "yaw orientation" bug (illustrated in Figure 7 of the paper) would be invisible in a standard Petri net but was caught by tracking spatial data.
  • Performance: For the Spot robot mission, the tool computed the data-aware state space in 33 seconds on a modern laptop. While slower than classical methods (which took milliseconds), it provided significantly higher fidelity.
  • Skill Modeling: The authors utilized a specific structure called a Skill Petri Net (SkPN), shown in Figure 2, to standardize how robotic actions (requests, execution, and results) are represented.
Figure 2: Basic Skill Petri net (SkPN) structure, with two results. Interface places appear in bold.

Limitations and Future Work

  • Infinite States: If the data includes something like an unbounded counter, the state-space exploration might never finish. The current tool relies on the user to ensure data remains within discrete, finite bounds.
  • Execution Speed: The current implementation is in Python, which is relatively slow for massive state-space searches. The authors plan to move the core engine to a compiled language.
  • Runtime Verification: A major future goal is to link the APN model to the robot during execution, allowing for real-time fault management and model refinement based on actual sensor data.

Summary updated

Abstract

A large amount of high-level Petri net formalisms has been investigated and deployed in academic settings over the past decades, but these deployments fail to reach practical applications, despite the strong guarantees they can bring to stakeholders. In particular, the lack of direct benefits from end-users reduces the appeal of Petri nets, both due to the overly simple classical Petri net formalism, and the overly specialized high-level formalisms, on top of state-space explosion issues. In this work, we investigate how a middle-ground could be reached, by separating the implementation-specific aspects of software or hardware behaviors, from the classical Petri net semantics. The goal is to benefit from the sought-after aspects of Petri nets, namely their simple firing semantic and model-checking capabilities, while still being able to augment their behavior to best reflect the modelled system. We present a formal model of Interpreted Petri nets with data-aware transitions and tokens. We illustrate this formalism by modelling the executive layer of a robotic system, and provide a lightweight tool to augment classical Petri nets for general purpose applications, as well as data-aware state-space exploration for model-checking. Their specialization in the context of autonomous robotics is showcased, with a complete industrial inspection mission use-case, to compare simulation and model-checking results between the classical and the new data-aware Petri net semantic.
BibTeX
@misc{pelletier2026skinet,
  author = {Baptiste Pelletier and Karen Godary},
  title = {{SkiNet-Sim: Simulating Petri Nets with Data for the Verification and Validation of Controllers for Autonomous Systems}},
  year = {2026},
  eprint = {2611.22397},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.22397},
}
Figure