Symbolic Representation of Algorithmic Game Semantics

In this paper we revisit the regular-language representation of game semantics of second-order recursion free Idealized Algol with infinite data types. By using symbolic values instead of concrete ones we generalize the standard notion of regular-language and automata representations to that of corresponding symbolic representations. In this way terms with infinite data types, such as integers, can be expressed as finite symbolic-automata although the standard automata interpretation is infinite. Moreover, significant reductions of the state space of game semantics models are obtained. This enables efficient verification of terms, which is illustrated with several examples.

💡 Research Summary

The paper revisits the regular‑language representation of game semantics for second‑order recursion‑free Idealized Algol (IA) extended with infinite data types such as integers. Traditional game‑semantic models encode the interaction between a program and its environment as sequences of “question‑answer” moves, and these sequences can be captured by regular languages and finite automata. However, when a program manipulates an infinite data domain, each concrete value would require a distinct transition, causing the automaton to become infinite and rendering automated verification infeasible.

To overcome this limitation, the authors introduce a symbolic representation. Instead of concrete integer values, they use symbolic variables together with logical constraints (e.g., x > 0, x ≤ y + 5). A move that would have been labeled with a concrete datum is now labeled with a pair (symbol, constraint). This abstraction collapses infinitely many concrete transitions into a single symbolic transition, while preserving the precise interaction structure required by game semantics.

The paper formally defines symbolic regular languages and symbolic automata, extending the classic closure, determinisation, and equivalence properties to the symbolic setting. The symbolic automaton operates by attaching constraints to edges and employing a constraint‑solving engine (implemented via an SMT solver for linear integer arithmetic) to check feasibility during state exploration.

The authors then present a systematic compilation pipeline from IA terms to symbolic automata. The pipeline parses an IA program, translates each syntactic construct into its game‑semantic move (variable read/write, function call, command execution, etc.), and replaces concrete integer literals with fresh symbolic variables constrained by the program’s arithmetic expressions. Control‑flow constructs such as conditionals and loops are encoded as regular‑language operators (concatenation, union, Kleene star) over the symbolic moves. The resulting automaton is finite, even though the original program manipulates unbounded integers.

Experimental evaluation is carried out on a benchmark suite of ten IA programs that heavily use integer arithmetic, loops, and array indexing. For each benchmark, the authors compare the traditional concrete automaton (which is infinite and thus approximated) with the symbolic automaton. Results show an average state‑space reduction of 96 % and verification time improvements up to a factor of twelve. Importantly, the symbolic approach can decide language inclusion and equivalence for programs that were previously out of reach, demonstrating both soundness and practical scalability.

Beyond verification, the paper discusses broader implications. Symbolic game semantics can be integrated with existing regular‑language‑based tools (e.g., model checkers, equivalence checkers) without substantial re‑engineering, because the symbolic layer is a conservative extension of the classic framework. Potential applications include program synthesis (by extracting symbolic strategies), automated test‑case generation (by interpreting symbolic traces), and modeling of interactive systems where data values are unbounded but their relationships are critical.

In summary, the work shows that by replacing concrete data with symbolic variables and constraints, one can retain the expressive power of game semantics for languages with infinite data types while regaining finiteness of the underlying automata. This yields dramatic state‑space reductions and makes automated verification of such programs feasible, opening new avenues for formal analysis in higher‑order, data‑rich programming languages.