Justness in Concurrent Systems

• Justness is a completeness criterion for concurrent systems that requires enabled non-blocking transitions to eventually execute unless an interfering action occurs.
• It is formalized through diverse methods such as process algebra and Petri nets, emphasizing resource sensitivity and concurrency-aware liveness reasoning.
• Applications of justness span mutual exclusion, session types, and verification practices, highlighting its role in refining execution paths for reliable system behavior.

Searching arXiv for recent and foundational papers on justness, progress, fairness, and related semantic equivalences. arXiv search: query="justness progress fairness process algebra mutual exclusion" max_results=10 Justness is a completeness criterion for concurrent and distributed systems that is stronger than progress and weaker than the usual fairness assumptions. In the literature surveyed here, it is used to determine which paths of a transition system count as realistic complete runs for liveness reasoning. Its core intuition is that once a non-blocking transition is enabled by some parallel component structure, the execution may not postpone that transition forever by taking only unrelated concurrent steps; some interfering step must eventually occur, possibly the transition itself. This places justness between deadlock-oriented progress assumptions and recurrence-oriented fairness assumptions, and makes it central to recent work on process algebra, Petri nets, testing semantics, modal logic, session types, and mutual exclusion verification (Glabbeek et al., 2018, Glabbeek, 2019, Spronck et al., 2024).

1. Position in the hierarchy of completeness criteria

The justness literature treats liveness as a property quantified over complete executions rather than over arbitrary paths. A transition system therefore requires, in addition to its operational semantics, a completeness criterion specifying which executions are to be admitted as complete runs. Progress is the weakest criterion in this hierarchy: a path is complete when it is infinite, or when it ends in a state where no relevant non-blocking transition remains possible. Fairness assumptions are stronger: weak fairness requires execution of perpetually enabled tasks, and strong fairness requires execution of relentlessly enabled tasks. Justness occupies the intermediate layer: it excludes starvation caused solely by unrelated concurrent activity, without requiring that every enabled choice eventually be taken (Glabbeek et al., 2018, Glabbeek, 2019, Spronck et al., 2024).

Criterion	Informal requirement	Typical target
Progress	the system does not stop while non-blocking activity is possible	finite deadlock-like incompleteness
Justness	enabled non-blocking activity cannot be ignored forever unless interference occurs	starvation by unrelated concurrency
Weak/strong fairness	perpetually or relentlessly enabled tasks must occur	scheduler-level fairness

A persistent theme is that fairness is often criticized as too strong or unrealistic for open and reactive systems. The point is not merely that fairness excludes some executions, but that it may exclude executions that are still possible in the intended model of the environment or scheduler. Justness avoids the blanket principle that “if you keep trying forever, success eventually happens.” Instead, it only rules out executions in which independent components are starved forever by other components that never interfere with the delayed activity (Glabbeek, 2017, Glabbeek et al., 2018).

This distinction is visible in the recurrent contrast between two kinds of systems: genuine parallel compositions, where one component should not be starved forever by another, and single-component nondeterministic loops, where repeatedly choosing one branch forever may remain a valid execution. This suggests that justness is fundamentally a structural condition on concurrency, not a generic scheduling postulate.

2. Formal definitions and semantic mechanisms

One common formulation uses a concurrency or interference relation on transitions or actions. In the action-based presentation, a relation $\smile \subseteq \mathcal{A} \times \mathcal{A}$ is a concurrency relation when it is irreflexive and satisfies persistence: if an action $a$ is enabled in a state $s$, and a path from $s$ to $s'$ contains only actions concurrent with $a$, then $a$ remains enabled in $s'$. With a blocking set $B \subseteq \mathcal{A}$ fixed, a path $\pi$ satisfies $a$0-justness of actions iff, for each enabled non-blocking action on a suffix of $a$1, some later action occurs that interferes with it, i.e. some $a$2 with $a$3 (Spronck et al., 2024, Glabbeek et al., 17 Jul 2025).

A transition-based formulation appears in labelled transition systems with concurrency or successor structure. In LTSS form, justness is stated in terms of enabled non-blocking transitions and their successors: a path is $a$4-just if every enabled non-blocking transition is eventually interfered with by the path. The successor relation

$a$5

records when a transition survives another transition as an enabled future variant. Concurrency is then recovered by

$a$6

This replaces direct reference to syntactic components by a semantic notion of unaffectedness, allowing the theory to apply beyond process calculi (Glabbeek et al., 2021).

A Petri-net formulation makes the resource intuition explicit. For a path

$a$7

one writes $a$8 iff $a$9 becomes enabled at some point and no later transition consumes any token needed by $s$0, including read dependencies. Formally,

$s$1

A path $s$2 is then $s$3-just iff every transition $s$4 such that $s$5 has label in $s$6 (Glabbeek, 2022).

Across these variants, the invariant semantic idea is the same: an enabled transition may remain unexecuted only if later behavior actually interferes with the resources, components, or enabling structure it needs. This explains why justness is repeatedly described as resource-sensitive, component-sensitive, or concurrency-aware rather than recurrence-based.

3. Process-algebraic and Petri-net realizations

In process algebra, justness is tied to the internal structure of parallel composition. A concise formulation from the process-algebraic line of work states: $s$7 This principle is developed for CCS, ABC, CCSS, and later ABCdE, with non-blocking actions typically including $s$8 and, in broadcast settings, output actions (Glabbeek et al., 2015, Glabbeek, 2019).

The operational machinery becomes more refined when concurrency must be preserved through semantics. In one CCS-style account, transitions have the form

$s$9

where $s$0 records participating parallel components. Concurrency is then given extensionally at the LTS level: $s$1 This makes justness depend on which components participate in a step, not merely on source-label-target triples. The same concern appears in ABCdE, where LTSS transitions are derivations rather than plain triples, because distinct derivations of the same labelled transition may have different concurrency properties (Glabbeek, 2021, Glabbeek et al., 2021).

Signals and broadcast further sharpen the point. Broadcast yields asymmetric concurrency: a broadcaster need not be affected by the readiness of a receiver, whereas the receiver may be affected by the broadcast. Signals require non-consuming observation, and this is one reason Petri nets with read arcs become semantically natural. In the read-arc setting, signalling can be represented without destroying the token encoding the signal, and the literature explicitly states that signalling cannot be adequately modeled by standard Petri nets; read arcs are necessary (Glabbeek, 2019, Glabbeek, 2022).

This body of work also emphasizes that plain interleaving LTS semantics is not enough. The distinction between two systems may depend on whether an infinite run postpones a transition by internal choice within one component or by activity in a different parallel component. That distinction is invisible in standard strong bisimulation but central to justness.

4. Equivalences, testing semantics, and logical specification

A major consequence of justness is that classical semantic equivalences become too coarse. Strong bisimilarity identifies systems by their ordinary labelled transition structure, but justness depends on enabledness, concurrency origin, and successor preservation. The standard counterexamples compare a single-component loop with internal nondeterministic choice against a parallel composition of independent components; both can induce the same ordinary LTS, while differing in liveness under justness. This is why the research agenda states that contemporary process algebras and temporal logics fail to distinguish systems of which one has a crucial liveness property and the other does not, at least when assuming justness but not fairness (Glabbeek, 2017, Glabbeek, 2019, Glabbeek et al., 2021).

The proposed repair is enabling preserving bisimilarity, or ep-bisimilarity. An ep-bisimulation relates not only states but also their enabled transitions and the way those enabled transitions evolve under successors. It preserves concurrency information and satisfies the theorem that ep-bisimilarity preserves justness. It is also a congruence for all standard ABCdE operators, including parallel composition: $s$2 This makes justness-compatible abstraction compositional rather than ad hoc (Glabbeek et al., 2021).

Testing semantics has been reworked along analogous lines. When must testing is parameterized by the completeness criterion $s$3, one obtains the preorder

$s$4

Replacing progress by justness yields a different preorder, and the central theorem is

$s$5

The same work identifies $s$6 with Vogler’s fair failure preorder and shows that it is the coarsest precongruence preserving linear-time properties under justness (Glabbeek, 2022).

Logical specification has likewise been adapted. Template formulae in the modal $s$7-calculus encode liveness under progress, justness, weak fairness, strong fairness, and hyperfairness. For justness, the generic template is instantiated by

$s$8

so that enabledness creates an obligation discharged only by an interfering action. The correctness of these template formulae has been proven (Spronck et al., 2024).

An earlier strand also proves that fairness of events coincides with justness. This does not collapse justness into ordinary fairness; rather, it shows that justness can be represented as a fairness-like property in an event semantics while remaining conceptually a progress-style condition (Glabbeek et al., 2018).

5. Mutual exclusion, lock-freedom, and verification practice

Mutual exclusion has been one of the main drivers of justness research. In speed-independent models of Peterson’s protocol, progress alone is too weak to establish starvation-freedom, and whether justness suffices depends on the adopted concurrency relation for reads and writes. A later time-out-based model changes the picture: starvation-freedom is obtained with only the weaker assumption of progress, without fairness or justness, even when memory accesses are atomic, but only by dropping speed independence. The result explicitly weakens the idea that justness is inherently necessary for mutual exclusion in every semantic setting (Glabbeek, 2021).

More recent model checking work uses justness directly as the completeness criterion for liveness verification of mutual exclusion algorithms with shared read/write registers. In this setting, justness is parameterized by concurrency relations representing different blocking assumptions on register operations. Four relations are considered: $s$9 corresponding respectively to blocking reads and writes, a blocking model with concurrent reads, blocking writes and non-blocking reads, and non-blocking reads and writes. The liveness properties checked include mutual exclusion, deadlock freedom, and starvation freedom, with justness used to eliminate spurious counterexamples arising from unrealistic infinite interleavings (Glabbeek et al., 17 Jul 2025, Glabbeek et al., 1 Apr 2026).

The same verification line provides explicit characterizations of just paths under these relations. For example, under $s'$0 a path is just iff it thread-enables no actions, while under $s'$1, $s'$2, and $s'$3 the characterizations refer to thread-enabled register start actions and the existence of infinitely many interfering register operations. This makes the dependence of justness on the memory model and blocking policy fully explicit (Glabbeek et al., 17 Jul 2025, Glabbeek et al., 1 Apr 2026).

Session-typed concurrency provides a different application. A fairness-parameterized notion of lock-freedom is defined by requiring that along any $s'$4-fair path, each non-terminated component eventually does something. For the session calculus considered there are precisely three semantically distinct lock-freedom notions with sound type systems, and the hierarchy includes

$s'$5

The strongest completeness result is for justness: $s'$6 On race-free networks, justness coincides with strong fairness of components,

$s'$7

yielding soundness in that restricted setting (Glabbeek et al., 2021).

These applications show that justness is neither a purely foundational notion nor merely a workaround for fairness. It is a verification assumption that can be instantiated differently across process algebra, shared-memory algorithms, and type-theoretic liveness analyses.

6. Conceptual significance and open problems

The research agenda around justness argues that adopting it seriously requires changes to core concurrency theory. Strong bisimilarity can no longer serve as the default observational abstraction, because strongly bisimilar systems may differ in liveness under justness. The agenda therefore calls for new equivalences and preorders, new induction principles, new congruence formats for structural operational semantics, and matching treatments of time and probability (Glabbeek, 2017, Glabbeek, 2019).

Expressiveness is another recurring issue. Standard process algebras and ordinary Petri nets are said to be insufficient for accurately specifying systems such as fair schedulers and mutual exclusion protocols without fairness assumptions. This motivates language extensions involving signals, broadcast communication, priorities, non-blocking reading, and time-outs, as well as systematic study of their expressive power (Glabbeek, 2017, Glabbeek, 2019, Glabbeek, 2021).

A further implication is that justness is not universal in a model-independent sense. In speed-independent process-algebraic treatments of mutual exclusion, it may be essential; in richer timed formalisms with time-outs, its role may disappear for a given property, but only because the language now encodes timing-dependent recovery. This suggests that impossibility and necessity results about justness are often results about the compatibility of modeling assumptions—such as atomicity, speed independence, and the expressive resources of the semantic formalism—rather than about concurrent liveness in the abstract (Glabbeek, 2021).

Taken together, these works present justness as the canonical intermediate criterion between progress and fairness for concurrency-sensitive liveness reasoning. It is a structural account of why certain infinite executions should be discarded, one that preserves genuine interference while rejecting starvation by unrelated activity, and it has become a unifying concept across process semantics, temporal logic, testing theory, session types, and verification of shared-memory algorithms (Glabbeek et al., 2018, Glabbeek, 2019, Glabbeek, 2022).