Operator-Based Supervision in Complex Systems

• Operator-based supervision is a formal framework using algebraic and language-based operators to monitor and control complex systems with both discrete-event and human supervisory elements.
• It integrates process algebra, data-driven synthesis, and observability operators to ensure scalability, safety, and efficient supervisory control in applications like industrial automation and autonomous fleets.
• Recent advancements such as event forcing, opacity enforcement, and embodied supervision enhance system reliability and improve human-robot collaboration in real-time operational environments.

Operator-based supervision encompasses a spectrum of principles, frameworks, and methodologies for controlling, coordinating, and monitoring complex systems through formal operators—ranging from algebraic and language-based constructs in discrete-event supervisory control to real-time human-in-the-loop frameworks in industrial, robotics, and autonomous vehicle contexts. The operator can refer to supervisory control logic, symbolic operators (e.g., language maps, communication constructs), or human supervisors interacting with automated agents. The following sections provide a comprehensive treatment of operator-based supervision as demonstrated in foundational and contemporary research, with emphasis on process-theoretic foundations, data-driven extensions, language-theoretic operators, practical system implementations, and emerging applications.

1. Process Algebraic Formalization of Operator-Based Supervision

A central paradigm in operator-based supervision is the process algebraic modeling of coordination between supervisory controllers and plants, as articulated in "A Process Algebra for Supervisory Coordination" (Baeten et al., 2011). The process algebra captures:

• Action prefixing, composition, and encapsulation: To describe both component behaviors and their interaction protocols.
• Event-based observations: The supervisor monitors plant events (sensor or actuator signals), then selectively permits controllable actions via synchronization operators. For instance, $\mathbf{S \triangleq (s!make. s!move2N. 1)^*}$ repeatedly transmits control permissions, synchronized with the plant process via encapsulation.
• State-based observations: Plant emits uniquely identifying signals reflecting its state, enabling the supervisor to enforce control via guards and signal emission constructs (e.g., $\mathrm{rse}\{\varphi\}{p}$ for root signal emission, $\#_1\{\varphi\}{p}$ for guarded command).
• Semantic correctness by bisimulation: Supervisory coordination enforces partial bisimulation—the supervised system must remain indistinguishable with respect to uncontrollable actions ($B$) when compared to the original plant. Formally, for a relation $R \subseteq \mathcal{P} \times \mathcal{P}$:

  $$\begin{cases} p \downarrow \implies q \downarrow \ (p \xrightarrow{a} p') \implies (\exists q'.\, q \xrightarrow{a} q',\, (p', q') \in R)\ (q \xrightarrow{b} q',\, b \in B) \implies (\exists p'.\, p \xrightarrow{b} p',\, (p', q') \in R) \end{cases}$$

• Applications in manufacturing and industrial printing: Examples include AGV scheduling with event-based control and maintenance scheduling in printers using state signals, guarded commands, and invariant processes.

The algebraic operators provide a formal foundation for scalable synthesis and deployment of supervisors in distributed systems.

2. Operator-Based Supervisory Control with Data and Model-Based Engineering

Process-theoretic supervision is extended to communicating processes with data in "Communicating Processes with Data for Supervisory Coordination" (Markovski, 2012). Key contributions:

• Process theory augmentation with explicit data elements: Events are supplemented by state variables and guarded commands. Plant and supervisor are expressed as:
  • Plant: $$P ::= 0 \mid 1 \mid c?_n[f].P \mid u!_m?_n[f].P \mid \#_1:\{\varphi\}P$$
  • Supervisor: $$S ::= 1 \mid c![\emptyset].S \mid S+S \mid \#_1:\{\varphi\}S \mid S^*$$
• Coordination through data predicates: Supervisor transitions are permitted only if Boolean evaluators (guards) over plant data are satisfied (e.g., maintenance operation can only start when indicated by the current power mode and page counter values).
• Automatic synthesis and code generation: Formal models are used for direct supervisor synthesis, allowing software or PLC implementation.
• Partial bisimulation for correctness: Supervisory control is correct (nonblocking, no uncontrollable event is disabled) whenever $\#_1\{H\}(p \parallel s)~U~\xi(p)$ holds, with $U$ representing partial bisimulation w.r.t uncontrollable actions.
• Case paper (high-tech printer): Complex requirements, such as production standby, deadline-triggered scheduling, and operation start conditions are realized via logical formulas and supervisor synthesis.

The process theory with data supports modular, upgradable architectures and efficient hardware implementations, ensuring compliance with safety and scheduling constraints in practice.

3. Language Operators for Supervisory Control Under Partial Observation

In many discrete-event systems, operator-based supervision is implemented via symbolic operators on languages as formalized in "Characterizations and Effective Computation of Supremal Relatively Observable Sublanguages" (Cai et al., 2016):

• Relative observability operator $\Omega$: For a specification language $C$ and plant $M$, the operator $\Omega$ defines the fixpoint iteration to extract the supremal relatively observable sublanguage $\sup_{\mathcal{O}}(C)$:

  $$\Omega(K) := \sup_{\mathcal{N}}(K \cap F(K),\, \overline{C} \cap M)$$

  with $F(K)$ involving support operations over projected observations.

• Monotonic sequence and finite convergence: Iterative application $(K_j = \Omega(K_{j-1}))$ yields a finitely convergent sequence supported by Nerode equivalence and congruence kernels.
• Effective computability: For regular languages, all necessary operations (prefix closure, normal form computation, projection) can be enacted via automata algorithms, supporting practical supervisor synthesis.
• Combined controllability and observability: Operator $\Gamma$ computes the supremal sublanguage that is both controllable and relatively observable.

This operator-theoretic approach enables efficient computation and analysis of supervisors in complex settings involving partial observation.

4. Practical System Implementations and Human Operator Supervision

Operator-based supervision extends beyond symbolic logic to real-time systems which integrate human operators with automated agents:

• Industrial monitoring and allocation (Omams) (Chavhan et al., 2014): RFID and wireless comms automate real-time tracking of operator presence and machine utilization. Machine allocation is performed centrally, ensuring fair and efficient distribution. Continuous operator monitoring, dynamic reallocation, and automated efficiency calculations (e.g., $$\eta = (T_{\text{used}} / T_{\text{total}}) \times 100\%$$) provide transparency and optimize industrial workflows.
• Human-in-the-loop multi-robot exploration (iHERO) (Tian et al., 21 May 2024): Autonomous robots relay sensory data via ad-hoc networks with intermittent connectivity. Operator-based supervision is enforced by:
  • Latency constraint: $\bigcup_i M_i(t) \subseteq M_h(t+T_h)$ ensures the operator receives all updates within fixed time.
  • Region prioritization and dynamic operator movement are encoded as cost and feasibility constraints.
  • Performance metrics (coverage percentage, update timeliness, exploration efficiency) demonstrate the practical benefits of embedding the human operator into the supervisory loop.

These practical systems highlight the diversity of operator-based supervision in industrial and robotics applications, integrating algorithmic, communication, and human factors.

5. Extensions: Event Forcing, Opacity, and Embodied Supervision

Recent works have further expanded operator-based supervision:

• Event forcing in supervisory control (Reniers et al., 12 Apr 2024): Supervisor is empowered to force specific events (forcible events, $\Sigma_f$), preempting uncontrollable occurrences. Forcible controllability is defined:

  $$\forall s \in \overline{F}:\ \bigg[ \forall u \in \Sigma_u,\, (u \in E_P(s) \implies su \in \overline{F})\, \vee\, (\exists f \in \Sigma_f: sf \in \overline{F}\,\wedge\, \forall \sigma \in \Sigma\setminus \Sigma_f: s\sigma \notin \overline{F}) \bigg]$$

Algorithmic synthesis ensures maximally permissive supervision under the new interaction paradigm.

• Opacity-enforcing supervision via subobserver operators (Moulton et al., 2021): Refined observer structures (subobservers) allow efficient updating of adversary estimates and supervisor synthesis for security properties.
• Embodied and haptic supervision (Gilbert et al., 28 Feb 2024): Supervisors achieve heightened performance when provided with haptic access to operator command signals, leveraging sensorimotor integration and internal model mechanisms for rapid and accurate intervention in automation.

These developments reveal a trend toward increasingly expressive, adaptive, and secure forms of operator-based supervision in both theory and practice.

6. Operator-Based Monitoring of Learning Systems and Safety Filters

Operator-based supervision also supports monitoring and adaptation of machine learning and safety-critical control systems:

• Operator-based monitoring of classifiers (Banf et al., 2022): Supervisory frameworks use deep feature embeddings and unsupervised anomaly detection (Isolation Forests, MAD thresholding) to detect data drift in deployed models, issuing alerts for type II errors (e.g., undiscovered surface defects).
• Domain-adaptive safety filters with operator learning (Manda et al., 18 Oct 2024): Instead of training Control Barrier Functions (CBFs) for every instance, a deep operator $\mathcal{G}$ learns the mapping from environmental parameters to valid barrier functions, using residuals of Hamilton–Jacobi (HJ) PDEs:

  $$\mathcal{N}_\gamma(c, B_\gamma) := \min \big\{ c(x) - B_\gamma(x),\, \max_{u \in \mathcal{U}} [\nabla_x B_\gamma^\top (f(x) + g(x) u) + \gamma B_\gamma(x)] \big\} = 0$$

This paradigm adapts to unseen environments and can enforce complex constraints and actuation limits efficiently in dynamic navigation tasks.

Such operator-based approaches support scalable, robust, and adaptive safety and model assurance in learning-enabled control architectures.

7. Scalability and Teleoperation in Autonomous Fleets

Operator-based supervision is foundational to scalable remote supervision of autonomous fleets, especially in safety-critical scenarios:

• DISCES framework for AV fleet supervision (Hickert et al., 14 Sep 2024): Traffic reconstruction and reachability-based event extraction isolate safety-critical events (e.g., merge conflicts) for targeted remote operator intervention. A queuing theoretic model quantifies required operator resources:

  $$P_k = \frac{(\lambda/\mu)^k / k!}{\sum_{i=0}^k (\lambda/\mu)^i / i!}$$

Implementation of cooperative connected AVs (CCAVs) and pooling supervision across regions further enhances reliability and reduces operator requirements by >99%.

• Teleoperation support frameworks (Wolf et al., 31 Mar 2025): Control centers differentiate roles (Remote Operator, Fleet Manager) and formalize interaction protocols. State diagrams encode sequences of monitoring, remote intervention, minimal risk maneuver execution, and legislative adaptation. Legal compliance is enforced by modifying permissible supervisor actions in accordance with regulatory requirements.

These frameworks illustrate how operator-based supervision enables both efficient resource allocation and compliance in autonomous systems deployment.

---

Operator-based supervision thus constitutes an essential discipline linking formal logic, computational operators, system engineering, human factors, and real-time control, supporting safe, adaptive, and scalable operation across a broad array of complex systems. Whether instantiated through algebraic synchronization, data-driven policy synthesis, handcrafted monitoring protocols, or deep operator networks, supervisory operators provide the mathematical and practical link between requirements and reliable system behavior.