⚡ electrical engineering

Data-based control of Logical Networks

This paper addresses the limited application of data-driven techniques to Boolean control networks by proposing a model-free approach that evaluates fundamental features like reachability and equilibria, and solves safe control and output regulation problems using only limited network-generated data.

Original authors: Giorgia Disarò, Maria Elena Valcher

Published 2026-02-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Giorgia Disarò, Maria Elena Valcher

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a robot to navigate a maze, but you have a major problem: you don't have the map.

In the world of engineering, this is the challenge of controlling Boolean Control Networks (BCNs). These are systems made of simple "on/off" switches (like genes turning on or off, or traffic lights changing colors) that interact with each other. Usually, to control them, engineers need a perfect mathematical model (the map) of how every switch affects every other switch. But in real life—like in biology or complex computer systems—getting that perfect map is often impossible, too expensive, or takes too long.

This paper proposes a clever workaround: Don't build the map; just learn from the footprints.

Here is a simple breakdown of what the authors did, using everyday analogies.

1. The Problem: The "Black Box" Maze

Think of a BCN as a giant, complex maze where every intersection is a light switch.

The Old Way: To guide a traveler through the maze, you first need to draw the entire map, labeling every dead end and every shortcut.
The Reality: The maze is too big and changes too fast to draw the map. You only have a notebook containing a few pages of notes from a traveler who walked through it once or twice.
The Question: Can we design a set of instructions (a controller) that guarantees the traveler stays safe and reaches the goal, using only those few pages of notes, without ever seeing the full map?

2. The Solution: The "Safe Bet" Strategy

The authors use a concept called Data Informativity. Instead of trying to guess the exact rules of the maze, they ask: "What is the worst-case scenario that fits the notes we have?"

They look at the data and say: "Okay, based on these footprints, the maze could be arranged in 1,000 different ways. But if we design a strategy that works for all 1,000 possibilities, it will definitely work for the real maze."

It's like packing for a trip. You don't know if it will rain or shine, so you pack an umbrella and sunglasses. If you prepare for every possible weather scenario consistent with your forecast, you are guaranteed to be prepared.

3. The Two Big Challenges

The paper tackles two specific goals using this "footprint-only" method:

A. Safe Control (The "No-Fire" Rule)

Imagine the maze has a "Danger Zone" (like a pit of lava).

The Goal: Keep the traveler out of the lava forever. If they accidentally step in, get them out quickly and keep them out.
The Data Trick: The authors look at the notes to see: "Did we ever see the traveler step from a safe spot into lava?"
- If the notes show a safe spot always leads to another safe spot (or a path that leads back to safety), they can create a rule: "Whenever you are in a safe spot, do X."
- They prove that if this rule works for every possible maze that fits the notes, it works for the real one. They even provide a step-by-step recipe (an algorithm) to write down these rules.

B. Output Regulation (The "Destination" Rule)

Imagine the goal is to make the traveler stop at a specific landmark (like a blue house) and stay there.

The Goal: No matter where the traveler starts, guide them to the blue house and make sure they stay there.
The Data Trick: The authors look for "loops" in the notes.
- "Did we ever see the traveler go from the blue house back to the blue house?"
- "Can we get from everywhere in the maze to the blue house based on the notes?"
- If the notes show a path exists to the blue house for every possible version of the maze, they can design a steering wheel (a feedback matrix) that forces the traveler to the blue house and keeps them there.

4. The "Magic" Recipe (Algorithms)

The paper isn't just theory; it gives you the actual recipe.

Algorithm 1: A way to find the "Basin of Attraction." Think of this as drawing a circle around the destination. The algorithm checks if every spot outside the circle has a path leading into the circle.
Algorithm 2 & 4: These are the chefs. They take the raw data (the footprints), check if a solution is possible, and if it is, they spit out the exact instructions (the control matrix) needed to run the system.

5. Why This Matters

No "Model" Needed: You don't need to understand the deep biology or physics of the system. You just need data.
Robustness: Because the solution works for all possible systems that fit the data, it is incredibly robust. Even if the system behaves slightly differently than expected, the controller still works.
Efficiency: The authors show that while the math is complex, the computer doesn't have to work harder than it would if it had the full map. It just uses the data it has.

Summary Analogy

Imagine you are a coach for a soccer team, but you've never seen the stadium. You only have a video of the team playing in the rain.

Old Coach: "I need to see the whole stadium, the grass type, and the wind patterns to make a game plan."
This Paper's Coach: "I don't need the stadium. I watched the video. I know that in the rain, the ball slides left. So, I will tell the team: 'If the ball slides left, kick right.' I will make a plan that works whether the stadium is big or small, grass or dirt, as long as the ball slides left like it did in the video."

The Bottom Line: This paper proves that you can control complex, "on/off" systems safely and effectively using only limited data, without ever needing to know the full, underlying rules of the game.

1. Problem Statement

The paper addresses the control of Boolean Control Networks (BCNs) using a data-driven approach.

Context: BCNs are discrete-time dynamical systems where states, inputs, and outputs are Boolean variables. They are widely used to model gene regulatory networks, systems biology, and other logical systems.
Challenge: Traditional control design for BCNs relies on the algebraic state-space representation (using Semi-Tensor Product) which requires an exact, known model. However, deriving an accurate model from biological or complex systems is often difficult or impossible due to system complexity and lack of identification data.
Gap: While data-driven control is prevalent in linear systems, its application to logical networks is limited. Existing attempts often rely on output prediction matrices (which can be non-deterministic) or assume full system identification.
Objective: The authors aim to solve two fundamental control problems for BCNs without knowing the system model, using only a limited amount of collected data (state, input, and output sequences). The goal is to design controllers that guarantee the desired behavior for all BCNs compatible with the collected data.

2. Methodology

The paper adopts the Informativity Framework (originally proposed by van Waarde et al. for linear systems and adapted for logical networks by Li et al.).

A. Data Collection and Compatibility

Data Structure: The authors collect $r$ $r$ offline experiments consisting of state ( $x$ $x$ ), input ( $u$ $u$ ), and output ( $y$ $y$ ) sequences over finite time intervals. These are organized into logical matrices:
- $X_p, U_p, Y_p$ : Past data (states/inputs/outputs at time $t$ ).
- $X_f$ : Future data (states at time $t+1$ ).
Compatible Set ( $B_d$ ): Since the data may not uniquely identify the system matrices $(L, H)$ , the authors define a set $B_d$ containing all BCN models consistent with the observed data.
Informativity: A property or control problem is deemed "informative" if it holds true for every system in the set $B_d$ . This ensures that a solution derived from data is valid for the actual (unknown) system.

B. Key Theoretical Tools

Data-Driven Reachability:
- Instead of the model-based transition matrix $L_{tot}$ , the authors construct a data-based matrix $L^d_{tot} = X_f \odot_B X_p^T$ (where $\odot_B$ is the Boolean product).
- This matrix represents the "best possible under-approximation" of the true transition graph. If a state is reachable in $L^d_{tot}$ , it is reachable in all compatible BCNs.
- Algorithm 1 is proposed to compute the basin of attraction for a target set of states directly from data.
Equilibrium and Cycles:
- The authors characterize equilibrium points and limit cycles compatible with the data by analyzing self-loops and cycles in the graph derived from $L^d_{tot}$ .
Control Synthesis:
- The approach involves checking necessary and sufficient conditions on the data matrices. If conditions are met, a state feedback matrix $K$ is constructed explicitly.

3. Key Contributions and Results

The paper provides solutions to two specific control problems:

A. Data-Driven Safe Control

Problem: Design a state feedback $u(t) = Kx(t)$ such that all trajectories starting in a "safe set" ( $X_s$ ) remain in $X_s$ forever, and all trajectories starting in an "unsafe set" ( $X_u$ ) eventually enter $X_s$ and stay there.
Main Result (Theorem 12): The problem is solvable if and only if:
1. Invariance: For every state in $X_s$ , there exists a data-observed transition leading to another state in $X_s$ .
2. Reachability: The set $X_s$ is globally reachable from all states in $X_u$ within the data-derived graph.
Solution: Algorithm 2 verifies these conditions and constructs the feedback matrix $K$ . If the conditions fail, the algorithm reports that the data is not informative for safe control.

B. Data-Driven Output Regulation

Problem: Design a state feedback $u(t) = Kx(t)$ such that the system output converges to a desired constant value $y^*$ in finite time and stays there.
Main Result (Theorem 16): The problem is solvable if and only if:
1. Existence of Valid Cycles: There exists at least one cycle in the data-derived graph where all states produce the desired output $y^*$ .
2. Global Reachability: The union of the basins of attraction of these valid cycles covers the entire state space.
Solution: Algorithm 3 identifies states producing $y^*$ . Algorithm 4 (using Johnson's algorithm) finds cycles within these states. The feedback matrix $K$ is then constructed by selecting inputs that drive the system into these cycles.

4. Significance and Impact

Bypassing Identification: The work demonstrates that exact system identification is not strictly necessary for solving complex logical control problems. One can guarantee safety and regulation by ensuring the solution works for the entire class of models compatible with the data.
Rigorous Guarantees: Unlike heuristic data-driven methods, this approach provides necessary and sufficient conditions. If the conditions are met, the controller is guaranteed to work for the true system, even if the true system is not uniquely identified.
Computational Complexity: The authors note that while BCN problems are generally NP-hard with respect to state dimensions ( $N=2^n$ ), the data-driven approach does not significantly increase computational complexity compared to model-based approaches. In fact, because the data provides a "sparse" view of the system (fewer transitions observed than in the full model), the computational burden for enumerating transitions can be lower.
Practical Applicability: The paper includes numerical examples (Example 13 and 18) demonstrating the application of the algorithms on small-scale networks, validating the theoretical results.

5. Conclusion

This paper fills a critical gap in the control of logical networks by extending the informativity framework to BCNs. It establishes a rigorous methodology to solve safe control and output regulation problems using only finite data sequences. By constructing controllers that are robust to model uncertainty (specifically, uncertainty regarding the exact system dynamics), the authors provide a viable path for controlling complex logical systems where accurate modeling is infeasible.