Recent from talks
Nothing was collected or created yet.
Transition system
View on WikipediaIn theoretical computer science, a transition system is a concept used in the study of computation. It is used to describe the potential behavior of discrete systems. It consists of states and transitions between states, which may be labeled with labels chosen from a set; the same label may appear on more than one transition. If the label set is a singleton, the system is essentially unlabeled, and a simpler definition that omits the labels is possible.
Transition systems coincide mathematically with abstract rewriting systems (as explained further in this article) and directed graphs. They differ from finite-state automata in several ways:
- The set of states is not necessarily finite, or even countable.
- The set of transitions is not necessarily finite, or even countable.
- No "start" state or "final" states are given.
Transition systems can be represented as directed graphs.
Formal definition
[edit]Formally, a transition system is a pair where is a set of states and , the transition relation, is a subset of . We say that there is a transition from state to state if , and denote it .
A labelled transition system is a tuple where is a set of states, is a set of labels, and , the labelled transition relation, is a subset of . We say that there is a transition from state to state with label iff and denote it
Labels can represent different things depending on the language of interest. Typical uses of labels include representing input expected, conditions that must be true to trigger the transition, or actions performed during the transition. Labelled transitions systems were originally introduced as named transition systems.[1]
Special cases
[edit]- If, for any given and , there exists only a single tuple in , then one says that is deterministic (for ).
- If, for any given and , there exists at least one tuple in , then one says that is executable (for ).
Coalgebra formulation
[edit]The formal definition can be rephrased as follows. Labelled state transition systems on with labels from correspond one-to-one with functions , where is the (covariant) powerset functor. Under this bijection is sent to , defined by
- .
In other words, a labelled state transition system is a coalgebra for the functor .
Relation between labelled and unlabelled transition system
[edit]There are many relations between these concepts. Some are simple, such as observing that a labelled transition system where the set of labels consists of only one element is equivalent to an unlabelled transition system. However, not all these relations are equally trivial.
Comparison with abstract rewriting systems
[edit]As a mathematical object, an unlabeled transition system is identical with an (unindexed) abstract rewriting system. If we consider the rewriting relation as an indexed set of relations, as some authors do, then a labeled transition system is equivalent to an abstract rewriting system with the indices being the labels. The focus of the study and the terminology are different, however. In a transition system one is interested in interpreting the labels as actions, whereas in an abstract rewriting system the focus is on how objects may be transformed (rewritten) into others.[2]
Extensions
[edit]In model checking, a transition system is sometimes defined to include an additional labeling function for the states as well, resulting in a notion that encompasses that of Kripke structure.[3]
Action languages are extensions of transition systems, adding a set of fluents F, a set of values V, and a function that maps F × S to V.[4]
See also
[edit]References
[edit]- ^ Robert M. Keller (July 1976) "Formal Verification of Parallel Programs", Communications of the ACM, vol. 19, nr. 7, pp. 371–384.
- ^ Marc Bezem, J. W. Klop, Roel de Vrijer ("Terese"), Term rewriting systems, Cambridge University Press, 2003, ISBN 0-521-39115-6. pp. 7–8.
- ^ Christel Baier; Joost-Pieter Katoen (2008). Principles of Model Checking. The MIT Press. p. 20. ISBN 978-0-262-02649-9.
- ^ Micheal Gelfond, Vladimir Lifschitz (1998) "Action Languages", Linköping Electronic Articles in Computer and Information Science, vol. 3, nr. 16.
Transition system
View on GrokipediaIntroduction
Overview
A transition system is an abstract model used in computer science to represent the potential behaviors of discrete systems, consisting of a set of states and transitions that capture how the system evolves over time. These models provide a high-level abstraction for describing the dynamics of reactive, concurrent, or distributed systems, such as software protocols or hardware circuits, without delving into low-level implementation details like specific algorithms or data structures. By focusing on possible evolutions rather than concrete executions, transition systems enable formal analysis techniques, including verification of properties like safety and liveness, which are essential for ensuring system reliability in complex environments. Key terminology in transition systems includes states, which represent configurations or snapshots of the system at a particular moment, such as the values of variables or the status of components. Transitions denote the possible changes between states, modeling events or actions that drive the system's progression. Finally, paths or traces refer to sequences of states connected by transitions, illustrating finite or infinite executions that trace the system's behavior from an initial state onward. Transition systems can be unlabelled, focusing solely on state changes, or labelled, where transitions are annotated with actions or events to distinguish different types of evolutions; the latter variant is common in modeling concurrent processes. A simple illustrative example is a traffic light controller, with states red, green, and yellow, where transitions occur between them based on timer triggers—such as red to green after a fixed duration, green to yellow, and yellow back to red—forming cyclic paths that repeat indefinitely.Historical development
The concept of transition systems originated in automata theory during the 1950s and 1960s, building on early models of computation like finite state machines to represent discrete behaviors through states and transitions. Stephen Kleene's 1956 work formalized finite automata as representations of regular events, establishing a mathematical basis for state-based transitions in computational processes. Similarly, Edward Moore's 1956 Gedanken-experiments explored sequential machines, introducing state transition diagrams as visual tools for analyzing digital systems. These developments laid the groundwork for modeling dynamic systems in theoretical computer science. Transition systems were formalized in the context of operational semantics in the late 1970s and early 1980s, particularly for describing concurrent processes. Robin Milner's 1980 book A Calculus of Communicating Systems introduced labeled transition systems as a semantic framework for CCS, enabling precise definitions of process interactions and synchronization. Building on this, Gordon Plotkin's 1981 technical report A Structural Approach to Operational Semantics proposed SOS, using transition rules to specify programming language behaviors in a compositional manner. During the 1980s and 1990s, transition systems evolved through integration with concurrency models and verification techniques. C. A. R. Hoare's 1985 book Communicating Sequential Processes incorporated transition-based traces to model parallel interactions in CSP, influencing distributed system design.[5] Concurrently, modal logics for verification advanced, with Hennessy-Milner logic from 1980 characterizing observational equivalences on transition systems via modal formulas. In the post-2000 period, transition systems found a unified coalgebraic perspective, as Jan Rutten's 2000 paper framed them as coalgebras over endofunctors to study behavioral semantics categorically.[6] This formulation briefly references coalgebraic methods for system specification, detailed elsewhere. Transition systems remain integral to software engineering and AI planning, with ongoing applications in areas like transition function prediction using large language models as recently as 2024; no major conceptual updates have emerged post-2020.[7]Core Definitions
Unlabelled transition systems
An unlabelled transition system consists of a set of states and a binary transition relation over those states, representing possible evolutions without distinguishing the nature of transitions via labels. Formally, it is a pair , where is a set of states and is the transition relation.[8] A transition from state to state is denoted if , with .[8] The relation supports paths as finite or infinite sequences of states linked by successive transitions. Reachability between states is captured by the reflexive transitive closure of , which includes the identity relation (reflexivity for zero-step paths) and compositions of transitions (transitivity for multi-step paths). Thus, a state is reachable from if .[9] For instance, a simple counter can be modeled with states (non-negative integers) and transitions , where each step increments the value by 1; starting from 0, the reflexive transitive closure reaches all natural numbers.[2]Labelled transition systems
A labelled transition system extends the basic notion of a transition system by associating labels, representing observable actions or events, with each transition, thereby enabling the modeling of behavioral aspects such as communication or operations in concurrent processes.[10] Formally, a labelled transition system is defined as a triple , where is a nonempty set of states, is a nonempty set of labels (often denoting actions), and is the labelled transition relation.[11] The transition relation specifies that for states and label , a transition holds if .[11] This structure captures the dynamics of systems where transitions are not merely structural changes but are distinguished by specific actions, as introduced in the operational semantics of process calculi like CCS.[12] Labelled paths in such a system consist of finite or infinite sequences alternating between states and labels, such as , where each consecutive pair satisfies the transition relation.[13] A key property for comparing behaviours is bisimulation equivalence, which relates two states and if, whenever , there exists such that and is bisimilar to , and vice versa for all transitions from .[14] This equivalence, central to verifying system refinements, ensures that bisimilar states exhibit indistinguishable observable behaviour under matching labelled transitions.[14] As an illustrative example, consider a simplified vending machine modelled as a labelled transition system with states , labels , and transitions including (upon inserting a coin) and (upon selection, returning to idle after dispensing).[15] This captures the machine's reactive behaviour to user actions via labelled steps.Properties and Variants
Deterministic and nondeterministic systems
In transition systems, determinism refers to the property where the behavior from any given state under a specific action or transition is uniquely predictable. A deterministic transition system is defined such that for every state and label (in labelled variants), there exists at most one state satisfying .[16] This ensures that each possible transition leads to a single successor state, eliminating ambiguity in the system's evolution and facilitating straightforward simulation and analysis. In unlabelled transition systems, the absence of labels implies that determinism manifests as at most one outgoing transition per state, though labelled systems more commonly incorporate actions to specify the transition's nature.[16] In contrast, nondeterministic transition systems permit multiple successor states for a given state and label , allowing , , and so on for distinct .[16] This multiplicity models scenarios involving choice, concurrency, abstraction of complex behaviors, or environmental uncertainties, where the system may resolve to any one of the possible outcomes without specifying a unique path. Nondeterminism is a core feature in modelling concurrent processes, as it captures interleaving of actions or conflicts in shared resources, making it essential for verifying properties under all possible resolutions.[16] While every deterministic system is inherently nondeterministic (as a special case with singleton successor sets), the reverse does not hold, and nondeterministic systems often require additional techniques, such as powerset constructions, to analyze or convert to deterministic equivalents.[16] A related variant concerns executability of transitions, where a transition system is considered deadlock-free if every state admits at least one outgoing transition, ensuring no state is terminal or "stuck" without progress.[16] This property, often termed having executable transitions, prevents deadlocks in practical models and is crucial for liveness analyses in concurrent systems. In deterministic systems, executability guarantees a unique but always available next step, whereas in nondeterministic ones, it ensures multiple options but no complete halt.[16] Transition systems' deterministic and nondeterministic flavors are exemplified by finite automata, which are restricted transition systems over finite state sets and input alphabets as labels. A deterministic finite automaton (DFA) enforces a unique transition for each state and input symbol, as shown in the transition diagram below for a simple acceptor of strings ending in '1' over {0,1}:Start -> q0
q0 --0--> q0
q0 --1--> q1
q1 --0--> q0
q1 --1--> q1
Accept: q1
Start -> q0
q0 --0--> q0
q0 --1--> q1
q1 --0--> q0
q1 --1--> q1
Accept: q1
