Symmetric Phase Urgency Function

• The symmetric phase urgency function is a method that computes a phase’s priority by summing two identical turn-movement urgencies, ensuring order invariance.
• It simplifies feature processing and stabilizes signal decisions by treating shared traffic measurements uniformly across movement pairs.
• CityFlow simulations show that this approach reduces average travel time and enhances generalization across diverse real-world intersection datasets.

A symmetric phase urgency function is a traffic signal control representation in which the urgency of a signal phase is computed as an aggregation of two shared turn-movement urgency subtrees, each subtree producing the urgency of one turn movement in the phase, so that the resulting phase score is invariant to the order of the two turn movements. In GPLight+, this representation was introduced for genetic-programming-based traffic signal control to remove order dependence, treat common traffic features consistently across phases, reduce input-space complexity, stabilize decisions, and improve performance and generalization on CityFlow simulations over multiple public real-world datasets (Liao et al., 22 Aug 2025).

1. Origin and motivation

The immediate predecessor of the symmetric formulation is the phase-urgency framework of GPLight, in which each feasible signal phase is assigned an explicit real-time priority score and the controller activates the phase with the highest urgency at each decision point. In GPLight, the urgency function is a tree-shaped symbolic function evolved by genetic programming, evaluated on a phase-specific feature vector constructed from lane-level measurements (Liao et al., 2024).

GPLight+ identifies a specific limitation in traditional GP-based phase urgency functions: the two turn movements of a phase are treated as an ordered concatenation of features, even though the two turn movements in a phase are unordered in reality. This ordering introduces inconsistency and instability. The same turn movement can contribute differently to different phases that share it, and simply swapping the order of the two turn movements can yield a different urgency value for the same phase. The formulation is therefore counterintuitive under symmetric traffic changes such as morning versus evening peaks, where directional demand swaps but the underlying control logic is expected to remain invariant (Liao et al., 22 Aug 2025).

The symmetric phase urgency function addresses this by enforcing invariance to the order of the turn-movement inputs and by ensuring that common features, such as queue length on shared lanes, are treated consistently across phases. This suggests a representation-level bias toward physically meaningful equivalence classes of phase states rather than toward arbitrary feature orderings. In the GPLight+ account, the practical consequences are reduced input-space complexity, more stable decisions, and better performance and generalization (Liao et al., 22 Aug 2025).

2. Formal structure

GPLight+ assumes the standard 8-phase intersection. Let the set of phases be $S$ with $|S|=8$, where each phase $p \in S$ consists of two non-conflicting turn movements, denoted $T_{p,1}$ and $T_{p,2}$. A turn movement refers to movement across the intersection from an inbound approach to an outbound approach with a specific maneuver: left turn, straight, or right turn. Right turns are assumed always permitted and therefore are not controlled by signal phases, but their downstream lanes remain relevant as features because occupancy can indicate downstream congestion (Liao et al., 22 Aug 2025).

For a turn movement $T$, the involved lanes are

$L^{TM}(T) = L^{in}(T) \cup R^{out}(T),$

where $L^{in}(T)$ are the lanes on the incoming road relevant to the movement and $R^{out}(T)$ are all lanes on the outgoing road. Two lane-level features are used: waiting vehicle count $w(l)$ and total vehicle count $|S|=8$0 for lane $|S|=8$1. The movement feature vector $|S|=8$2 is constructed as a fixed permutation over lanes and feature types to ensure consistency. For each feature type $|S|=8$3, where $|S|=8$4 and $|S|=8$5, lanes are ordered as $|S|=8$6, and within each class from left to right spatially. This produces a fixed-length ordered vector $|S|=8$7 (Liao et al., 22 Aug 2025).

The core construction introduces two shared subtrees $|S|=8$8 and $|S|=8$9 that are identical in structure and parameters:

$p \in S$0

Each subtree maps movement features to a turn-movement urgency score:

$p \in S$1

The phase urgency is then the aggregation of the two turn-movement urgencies with a symmetric aggregation operator $p \in S$2. GPLight+ uses simple addition:

$p \in S$3

The symmetry constraint is

$p \in S$4

which holds because $p \in S$5 is shared and the aggregator is symmetric (Liao et al., 22 Aug 2025).

This formulation is narrower and more explicit than the symmetry discussed in GPLight. GPLight uses a single shared $p \in S$6 across phases and a role-consistent phase mapping $p \in S$7, which yields equal urgency for mirrored phases under equal measured features and equal capacities. GPLight+, by contrast, imposes invariance directly at the intra-phase level by sharing the turn-movement subtree and summing its outputs, thereby removing order dependence between the two turn movements that constitute a phase (Liao et al., 2024).

3. Genetic-programming representation and optimization

GPLight+ evolves only the turn-movement urgency subtree $p \in S$8. The phase-urgency tree is then constructed by placing two identical copies of $p \in S$9 under the sum aggregator. Sharing is enforced by evolving a single turn-movement urgency tree and instantiating two identical copies beneath the aggregator for any phase computation. Thus, the phase-urgency trees across all phases reuse the same $T_{p,1}$0 and differ only in their movement-feature inputs $T_{p,1}$1 and $T_{p,1}$2 (Liao et al., 22 Aug 2025).

The terminal set for a single turn movement is

$T_{p,1}$3

where W0, W1, W2, W3 denote waiting counts on $T_{p,1}$4 lanes, C0, C1, C2, C3 denote total counts on the same lane classes, and $T_{p,1}$5 is an ephemeral constant. The function set is

$T_{p,1}$6

where protected division returns 1 on division by zero to avoid numerical errors. GPLight+ does not require feature normalization in the CityFlow setup; inputs are raw lane counts. The tree depth is bounded, and ephemeral constants are constrained to $T_{p,1}$7 (Liao et al., 22 Aug 2025).

The GP setup is specified as follows. Initialization uses ramped half-and-half with initial minimum depth $T_{p,1}$8 and maximum depth $T_{p,1}$9. Parent selection uses tournament selection of size $T_{p,2}$0. Variation uses $T_{p,2}$1 subtree crossover and $T_{p,2}$2 subtree mutation, with 1 elitist individual preserved per generation. To maintain subtree sharing, variation operators act on $T_{p,2}$3 only, and phase trees are re-instantiated with two copies of the updated $T_{p,2}$4 under the sum aggregator (Liao et al., 22 Aug 2025).

The optimization objective is the average travel time (ATT) of all vehicles over a 60-minute CityFlow simulation, where lower ATT is better. Control is decentralized: the same $T_{p,2}$5 is used at every intersection, with parameter sharing across intersections. This differs from the original GPLight formulation, which evolved a phase-urgency tree $T_{p,2}$6 over a phase-specific 16-dimensional feature vector with terminals $T_{p,2}$7 and primitive operators $T_{p,2}$8, also under CityFlow-based simulation fitness (Liao et al., 2024).

4. Runtime control policy and computational profile

At each decision epoch, GPLight+ computes the turn-movement urgency for each turn movement in each phase, sums the two values to obtain the phase urgency, and selects the phase with maximal urgency. For an intersection with 8 phases, this requires evaluating $T_{p,2}$9 twice per phase, for a total of 16 evaluations of the same small symbolic tree per decision step (Liao et al., 22 Aug 2025).

The runtime policy can be expressed as

$T$0

with

$T$1

Signal timing constraints are explicit. The minimum green duration is 10 seconds, yellow is 3 seconds, and all-red is 2 seconds between phase changes per CityFlow convention. If the selected phase differs from the current phase, yellow and all-red are enforced before activation; otherwise, the current phase is extended subject to the minimum-green condition. Ties can be broken deterministically, for example by preferring the current phase, to avoid oscillation (Liao et al., 22 Aug 2025).

The computational overhead is intentionally small. Each $T$2 is a small tree with depth at most 6 over 9 terminals and 4 binary operators, so the per-step computation is $T$3, described as tiny and deterministic. The memory footprint is a single small expression tree plus a fixed aggregator, with parameter sizes orders of magnitude smaller than neural networks. The controller is a symbolic expression composed of simple arithmetic and can run on resource-constrained microcontrollers such as ATmega328P and MSP430G2553 without quantization or specialized runtime. In the reported experiments, GP-based strategies fit comfortably within microcontroller RAM and response-time constraints, unlike deep RL baselines (Liao et al., 22 Aug 2025).

A common misunderstanding is to treat symmetry here as a purely abstract invariance property disconnected from deployment. In GPLight+, symmetry is implemented as a concrete architectural restriction on the symbolic controller: two identical movement-level subtrees and a symmetric aggregator. The resulting execution path is therefore not only invariant to turn-movement order, but also compact and operationally simple (Liao et al., 22 Aug 2025).

5. Empirical behavior and interpretability

GPLight+ is evaluated on CityFlow using multiple public real-world datasets. The datasets are Jinan with 12 intersections and three 1-hour instances (Jinan_1, Jinan_2, Jinan_3), Hangzhou with 16 intersections and two instances (Hangzhou_1, Hangzhou_2), and Manhattan with 196 intersections and one 1-hour instance. Baselines include traditional methods Random, Fixed-time, and Max-Pressure (MP); reinforcement-learning methods IDQN, FRAP, PressLight, and MPLight; and the non-symmetric GP baseline GPLight. The reported metrics are average travel time (ATT; lower is better), average queue length (AQL; lower is better), and network throughput (NT; higher is better) (Liao et al., 22 Aug 2025).

On ATT, GPLight+ significantly improves over GPLight in 5/6 datasets on averages across 30 runs. The reported examples are Jinan_2: 278.94 versus 280.69, Jinan_3: 287.10 versus 293.20, Manhattan: 1181.42 versus 1231.23, Hangzhou_1: 312.99 versus 314.94, Jinan_1: 329.14 versus 337.88, and Hangzhou_2: 410.19 versus 404.63, where Hangzhou_2 is a minor regression. In most scenarios, GPLight+ achieves the smallest AQL and highest NT among learning-based methods or is statistically comparable, and it reduces ATT without sacrificing throughput or increasing queues. Compared to Random, Fixed-time, and MP, learning-based methods including GPLight+ are consistently superior on all metrics, especially in large-scale settings (Liao et al., 22 Aug 2025).

Convergence analysis further attributes the gain to the symmetric representation. GPLight+ produces better initial individuals and converges faster in 5/6 scenarios. The stated explanation is that symmetry compresses the search space and filters low-quality asymmetric trees. Cross-validation within the Jinan datasets shows that GPLight+ has smaller ATT variance than MPLight and GPLight, suggesting that symbolic symmetric policies generalize better across related scenarios (Liao et al., 22 Aug 2025).

Interpretability is central to the method’s positioning. A representative learned turn-movement urgency tree on Hangzhou_1 is

$T$4

where W0 and C0 are, respectively, waiting and total vehicle counts on the incoming lane. The corresponding phase urgency is

$T$5

The reported interpretation is that such a controller prioritizes phases with high upstream queue length and, to a lesser extent, upstream volume. Across six datasets, W0 and C0 occur most frequently in the best individuals, indicating that upstream conditions dominate effective control. Among downstream lanes, C3 occurs relatively often; because right turns are always permitted, high C3 can correlate with downstream congestion, discouraging service of the phase (Liao et al., 22 Aug 2025).

6. Limitations, trade-offs, and relation to adjacent formulations

The principal trade-off of the symmetric phase urgency function is that the symmetry constraint may exclude beneficial asymmetric structures in some traffic distributions. Hangzhou_2 is the explicit counterexample reported in GPLight+, where ATT is slightly worse than GPLight. The aggregation operator is also deliberately simple: GPLight+ uses a sum, which is symmetric and effective broadly, but may limit expressiveness relative to alternatives such as max or a learned weighted sum. The authors identify richer symmetric aggregators as a future direction (Liao et al., 22 Aug 2025).

The formulation also assumes two turn movements per phase and is tailored to intersections with dedicated lanes. Generalization to more than two movements per phase or to multi-ring phasing would require extending the construction to $T$6-ary symmetric aggregations. Shared-lane intersections require feature engineering and turn-movement-to-lane mapping adaptations. The current method is decentralized, so corridor coordination and communication across intersections are outside the basic design. The current fitness is ATT; multi-objective optimization involving emissions, stops, fairness, or adaptive cycle management is presented as a possible extension (Liao et al., 22 Aug 2025).

Relative to GPLight, the symmetric phase urgency function should not be conflated with an explicit fairness penalty or with detector normalization. GPLight does not add explicit symmetry constraints or fairness penalties; symmetry there is largely achieved through a single shared $T$7 and a role-consistent terminal mapping $T$8. GPLight also notes that when lane capacities differ or detectors have unequal coverage, symmetry and fairness can be strengthened by normalizing features with saturation flow, restricting the grammar to terminal pairs that mirror roles across approaches, or adding an invariance penalty to the fitness (Liao et al., 2024). GPLight+ instead hard-codes turn-movement order invariance into the representation itself.

Taken together, these results place the symmetric phase urgency function within a specific trajectory of explainable traffic signal control: from a shared symbolic phase-urgency function over phase-specific features to a stricter decomposition into shared turn-movement urgency subtrees with symmetric aggregation. A plausible implication is that the main contribution is not merely improved ATT on the reported benchmarks, but a representation that aligns the algebra of the controller with the combinatorial symmetry of the signal phase itself (Liao et al., 22 Aug 2025).