Linearization of CIF Through SOS

Linearization is the procedure of rewriting a process term into a linear form, which consist only of basic operators of the process language. This procedure is interesting both from a theoretical and a practical point of view. In particular, a linearization algorithm is needed for the Compositional Interchange Format (CIF), an automaton based modeling language. The problem of devising efficient linearization algorithms is not trivial, and has been already addressed in literature. However, the linearization algorithms obtained are the result of an inventive process, and the proof of correctness comes as an afterthought. Furthermore, the semantic specification of the language does not play an important role on the design of the algorithm. In this work we present a method for obtaining an efficient linearization algorithm, through a step-wise refinement of the SOS rules of CIF. As a result, we show how the semantic specification of the language can guide the implementation of such a procedure, yielding a simple proof of correctness.

💡 Research Summary

The paper addresses the problem of linearizing models written in the Compositional Interchange Format (CIF), an automaton‑based language used as an interchange format for real‑time, hybrid, and embedded system models. Linearization means rewriting a process term into a form that contains only a small, fixed set of basic operators; this is valuable both for theoretical investigations (e.g., proving expressiveness results) and for practical tool integration, because many target languages cannot handle CIF‑specific operators such as urgency or hierarchical constructs.

Existing linearization techniques for process‑algebraic languages are typically obtained through ad‑hoc algorithmic design, with correctness proofs added afterwards. Moreover, the formal semantics of the source language (given as Structured Operational Semantics, SOS, rules) plays little role in guiding the algorithmic construction. The authors propose a fundamentally different approach: derive the linearization algorithm directly from the SOS specification of CIF by means of a step‑wise refinement of the rules.

The paper proceeds in three main stages:

1. Explicit SOS Rules – The authors first recall the original SOS rules for CIF, which operate on states of the form (p, σ) where p is a CIF composition and σ is a concrete valuation of all variables. These rules describe action transitions (including synchronisation flags) and environment transitions (which enforce invariants and initialise components). While mathematically precise, the explicit rules are unsuitable for implementation because they may generate infinitely branching transition systems and require manipulation of dense trajectories and infinite valuation sets.

2. Symbolic SOS Rules – To overcome the implementation barrier, the authors transform the explicit rules into a symbolic version. In the symbolic rules, concrete valuations are replaced by predicates (u, n) that capture the necessary constraints on variables, and reset predicates (r) that describe how variables are updated. Transitions are now labelled with triples ⟨action, predicate, reset⟩, making the effect of each step visible on the transition arrow. The authors prove soundness and completeness (Theorems 1‑4) showing a bijective correspondence between symbolic and explicit transition systems. Importantly, the symbolic transition system induced by a CIF model is finite, because predicates abstract away the infinite concrete state space.

3. Deriving a Linearization Procedure – The symbolic rules are then refined into an algorithm that builds a finite automaton representing the linearized model. The algorithm proceeds by exploring the symbolic transition system, constructing a new automaton whose locations correspond to symbolic states (i.e., pairs of a CIF composition and its predicate), and whose edges correspond to symbolic action transitions. Special attention is given to the two CIF operators:

   • Parallel composition (k): the algorithm distinguishes interleaving (non‑synchronising) actions from synchronising actions, ensuring that only actions in the synchronisation set A are forced to occur jointly.
   • Synchronising‑action operator (γ_A): this operator is handled by augmenting the synchronisation set of the enclosed process, as dictated by the symbolic rule for γ_A.

The authors illustrate the method with a small, untimed fragment of CIF consisting of a gate automaton and two train automata. The gate synchronises on actions rq, go, and out. By applying the symbolic rules, they obtain a transition system with only 16 symbolic states, despite the combinatorial interleaving that would be present in a naïve explicit construction. They also point out two practical issues in the raw symbolic system: exponential blow‑up caused by interleaving of many independent components, and redundant duplication of invariants and initialisation predicates across both environment and action transitions. Their refined algorithm eliminates these redundancies, yielding a more compact automaton.

Key contributions:

• A methodology that treats the SOS specification as a design blueprint, allowing the linearization algorithm to be derived mechanically rather than invented.
• Introduction of symbolic SOS rules that abstract away concrete valuations while preserving exact behavioural semantics, proved sound and complete.
• An efficient linearization algorithm that directly builds a finite automaton from the symbolic transition system, handling parallel composition and synchronisation in a principled way.
• Demonstration that the approach dramatically reduces the size of the intermediate transition system compared with naïve explicit semantics, and that the proof of correctness follows almost automatically from the SOS‑to‑symbolic transformation theorems.

The paper focuses on a simplified, untimed subset of CIF (automata, parallel composition, synchronising‑action operator) to keep the exposition clear, but the authors argue that the same refinement technique can be extended to the full timed and hybrid CIF language, where invariants, time‑can‑progress conditions, and continuous dynamics would be treated symbolically in the same fashion.

In summary, the work shows that semantic specifications can guide algorithmic implementation, turning the SOS rules of CIF into a concrete, provably correct linearization procedure. This bridges the gap between formal language theory and practical model‑transformation tools, and opens the door for systematic, semantics‑driven generation of other model‑processing algorithms (e.g., simulation, verification) for CIF and related languages.