Abstract
This paper presents an automated framework for bridging the gap between high-level, declarative goal models and executable behavior models in software engineering. A significant challenge in this translation is the emergence of "zeno" behaviors—scenarios where a system executes an infinite sequence of events without time ever progressing. By integrating model checking with Inductive Logic Programming (ILP), the proposed method iteratively identifies and eliminates these behaviors. The approach is validated through safety-critical case studies, demonstrating its ability to derive sound, non-zeno behavior models with minimal manual intervention.
Introduction
In Goal-Oriented Requirements Engineering (GORE), architects define system objectives using declarative logic to specify what a system should achieve. However, for simulation, testing, or formal verification, an executable behavior model describing how the system acts is required.
A major hurdle arises when translating these goals into asynchronous behavior models: the resulting models often exhibit "zeno" behavior. A zeno model contains execution traces where an infinite number of events occur within a single moment, effectively stopping the system clock. This typically happens because high-level goals are too abstract and lack the specific operational preconditions needed to prevent components from firing actions unnecessarily. Manually defining these preconditions is labor-intensive and error-prone. This research aims to automate this "operationalization" process using a counterexample-guided synthesis approach.
Methodology
The authors propose an iterative three-phase cycle to refine goal models until they produce non-zeno behavior. This process, illustrated in Figure 1, combines formal verification with machine learning.
- Analysis Phase (Model Checking): The system translates Linear Temporal Logic (LTL) goals into a Labelled Transition System (LTS). It then utilizes the LTSA tool to verify a "time progress" property, ensuring a
tickevent always eventually occurs. If time stops, the tool generates a counterexample in the form of a zeno trace. - Scenario Elaboration Phase (Human-in-the-loop): A requirements engineer reviews the zeno trace to identify the specific event that should not have occurred in that context. This is marked as a "negative scenario." The engineer also provides a "positive scenario" (desired behavior) to ensure the subsequent learning phase does not over-constrain the model.
- Learning Phase (ILP): The goals, fluent definitions, and scenarios are converted into Event Calculus, a logic programming formalism. An Inductive Logic Programming system called XHAIL then searches for a new precondition (a logical rule) that blocks the negative scenario while permitting the positive one.
This new precondition is integrated back into the goal model, and the cycle repeats until the model checker confirms that the time progress property holds for all possible traces.
Evaluation and Results
The framework was evaluated using two classic safety-critical benchmarks in the formal methods community:
- Mine Pump Control System: A system designed to manage water levels in a mine while preventing explosions by monitoring methane levels.
- Safety Injection System: A simplified model of a nuclear power plant safety component.
Key Results
- Successful Derivation: The approach successfully generated non-zeno models for both systems.
- Efficiency: The iterative process converged quickly. In the Mine Pump case, the system only needed to learn three preconditions to achieve a non-zeno model. The Safety Injection case required only two.
- Soundness: The paper provides a formal proof (Theorem 1) stating that the preconditions learned via ILP are "correct extensions." This ensures they fix the identified zeno traces without violating the original high-level goals.
Discussion and Future Work
The core insight of this work is that zeno behavior is often a symptom of missing operational details. High-level goals specify what must happen eventually, but often omit what should be inhibited in the present. By using counterexample-guided synthesis, the authors focus specifically on fixing observed failures rather than attempting to generate a perfect model from scratch. This minimalist approach produces valid behavior models with significantly fewer manual constraints than traditional methods.
However, limitations remain. The "Scenario Elaboration" phase still requires a human expert to distinguish between good and bad events. Future research aims to use abduction to automate this step. Additionally, the authors plan to expand the system's capabilities to learn "trigger conditions" (events that must initiate an action) and to handle more complex temporal operators.
Summary updated