Modern cellular base stations are increasingly run by software: independent apps from different vendors each tune one knob, such as transmit power, handover thresholds, or how radio resources are split among service classes. These apps share one radio environment, so they collide. Raising power in one cell can hurt users at the edge of the next cell, and that can trigger a handover app to move them. Existing conflict managers learn to flag such collisions from logs after the fact. Our hypothesis is that these learned managers can be right about whether a key performance indicator (KPI, such as throughput or delay) will degrade while wrong about which app caused it. This is the "reasoning shortcut" failure identified in neuro-symbolic AI. We expect it to be common in networks for a specific reason: apps react to the same load and mobility triggers, so their actions are correlated in the logs, and logs alone cannot tell them apart.
The proposal has two parts. First, a conflict manager that reasons before acting. It uses a small symbolic model of how control parameters couple to KPIs, a neural network that reads continuous radio telemetry and estimates which couplings are currently active, and a forward simulation that predicts the result of the apps' joint proposed action before any command reaches the radio. Second, a way to ground that manager that vision and language settings do not offer: the network controller can run cheap, targeted experiments. It can briefly hold back one app's action and observe the outcome, which breaks the correlation that produces shortcuts. The claim to test is that these targeted holdbacks remove reasoning shortcuts at a small KPI cost. The resulting manager should then attribute blame correctly and generalize to combinations of apps it has never seen together, where purely neural predictors do not.
Background and where this sits
In the Open Radio Access Network (O-RAN) architecture, the base station is split into radio, distributed, and centralized units. A near-real-time controller hosts third-party apps called xApps on 10 ms to 1 s control loops, as surveyed by Alam et al.. The closest prior work is GRAPHICA (O-RAN xApps Conflict Management using Graph Convolutional Networks). It turns logs into a graph linking xApps, parameters, and KPIs, classifies direct, indirect, and implicit conflicts with a two-layer graph network, and traces graph edges to name the offending xApp. It reports F1 above 98% on synthetic binary-state logs. Our proposal differs from it in three ways. GRAPHICA is reactive, while our manager predicts outcomes before commit. GRAPHICA binarizes telemetry, while we keep continuous radio features. Most importantly, GRAPHICA never checks whether its root-cause attributions are grounded: a model can reach near-perfect conflict detection while blaming the wrong app. Other AI-native control work, such as the evolutionary reinforcement learning slicer of EDRL and the greedy semantic slicer of SEM-O-RAN, optimizes one controller's objective and does not address arbitration among many.
Three neuro-symbolic results shape the design, each in a different role. Marconato, Teso and Passerini supply the motivation. They show that when intermediate concepts are supervised only through the final output, many wrong concept mappings satisfy the objective equally well, and that reconstruction losses and light supervision do not reliably remove them. We carry this diagnosis into networks and add a remedy their setting lacks: interventions. PrAE supplies the method. It uses neural perception that outputs probability distributions, symbolic abduction of which rule explains the observations, and symbolic forward execution. It reached 77.02% on I-RAVEN under cross-configuration transfer versus 22.84% for the monolithic CoPINet, and that gap is the kind of compositional generalization we expect from structured coupling models. He et al. supply a constraint. On Warcraft shortest paths, feeding neural point estimates into a classical solver (0.967 for neural execution versus 0.867 for NAR+Dijkstra) lost accuracy. So we pass full distributions into the symbolic executor rather than hard labels, and we test that choice as an ablation. Their "neuralization test" also requires us to show where symbolic execution beats a neural forward model, not merely assert it. Finally, Kontes et al. note that labeled radio telemetry is expensive and that multi-vendor components are opaque. This is why ground-truth coupling labels will not exist in deployment, and why interventions are the practical source of supervision.
Core Claim
Conflict attribution learned from observational controller logs is systematically ungrounded when xApps respond to shared triggers. A small number of targeted action holdbacks, chosen to split the remaining hypotheses about which couplings are active, restores correct attribution. A manager built from a symbolic coupling model with neural activation estimates, and grounded this way, predicts and prevents conflicts among unseen xApp combinations better than a neural world model given the same interventional data.
Research Program
The symbolic layer is a typed coupling graph. Its nodes are xApps, the control parameters they write (transmit power, handover offsets, per-slice resource-block shares, antenna tilt), and per-cell KPIs (throughput, cell-edge signal-to-interference-plus-noise ratio, low-latency slice delay). Edges come from a short library of domain templates with a sign and a parametric magnitude, for example "a power increase at cell i lowers edge SINR at neighbor j when the two share a carrier and j has edge load." Each template instance has a latent on/off state, written $z$, that depends on the continuous radio situation.
The neural layer is a graph network over continuous telemetry: per-cell load, SINR histograms, mobility statistics, and channel summaries. It outputs a probability for each coupling's activation, $q_\theta(z \mid s)$, where $s$ is the telemetry snapshot and $\theta$ the network weights. Given the joint action $a$ proposed by the xApps in one control interval, a symbolic executor propagates signed effects along the active edges and returns a distribution over KPI changes, marginalized over $q_\theta$. Because only a handful of xApps act per interval, the arbiter can enumerate accept, reject, or merge options for each proposal. It picks the one with the best predicted utility that also meets service-level constraints, before any command is issued. In PrAE's terms, abduction updates beliefs about $z$ from observed KPI outcomes, and execution imagines the outcome of candidate joint actions.
The grounding mechanism is where most of the research lies. When several coupling hypotheses explain the logged KPIs equally well, the arbiter may delay one xApp's action by one control interval and observe what happens. It chooses the holdback $h$ that trades information about $z$ against KPI cost:
$$h^\star = \arg\max_h \; \mathbb{E}\big[H(z \mid \mathcal{D}) - H(z \mid \mathcal{D}, h, y_h)\big] - \lambda\, C(h),$$
where $\mathcal{D}$ is the data so far, $y_h$ the KPIs observed after holdback $h$, $H$ entropy under the model's posterior, $C(h)$ the predicted KPI loss from delaying that action, and $\lambda$ an operator-set price. We will also measure a direct shortcut count: the number of coupling assignments consistent with the data, in the spirit of Marconato et al.'s deterministic-optima count. This measures grounding without relying on the model's own confidence.
Baselines
The naive reference point is no coordination: every xApp's command is applied as issued. This bounds how much any arbiter can help and tells us whether conflicts in our scenarios matter at all. Next is a static priority table, where the low-latency slice preempts broadband, power control overrides tilt, and later writes to a parameter lose. This is the rule-based practice operators would default to.
The strongest existing method is GRAPHICA, which reports precision 0.9960, recall 0.9956, and F1 above 98% on its synthetic binary logs with 10% conflict frequency (Al Shami et al.). We will reimplement it twice, once on binarized state changes as published and once with our continuous telemetry as node features, so that input information is not what separates the methods. Its detections will drive blocking of the xApp its root-cause tracer names. Beating it means matching its detection F1 in-distribution while achieving clearly higher attribution accuracy and lower service-level violation rates on the correlated-trigger and unseen-combination splits. No reported result was found on Lacuna for continuous-telemetry conflict prediction or for attribution accuracy, so GRAPHICA's 98% F1 is the only anchor.
The strongest skeptic's baseline is a neural world model. It is a graph network or transformer that maps telemetry plus a joint action to predicted KPI changes, and the same enumeration arbiter uses it. It gets the same logs, the same holdback budget and interventional data, the same hyperparameter search budget (equal trials, same validation split), and the same inference hardware. Beating it requires a statistically clear advantage on unseen xApp combinations and on a new xApp with different aggressiveness; parity in-distribution is expected.
Four ablations isolate the ingredients. The first passes argmax couplings into the executor instead of distributions, testing the He et al. lesson. The second uses no holdbacks. The third uses random holdbacks at an equal budget. The fourth supervises couplings with simulator ground-truth labels, which is an upper bound unavailable in the field.
Why not just…?
Why not just use GRAPHICA with a priority rule? On seen configurations it may be good enough, and we will report that honestly. Its weakness is structural. It observes binarized logs after commands are applied, and its root-cause tracing inherits whatever attribution the graph network learned from correlated observational data. Experiment 1 tests directly whether it names the wrong xApp when two xApps share a trigger. If its attribution stays accurate there, our central diagnosis is wrong.
Why not just train a neural world model and search over joint actions? This is the real threat. With enough interventional data, a flexible predictor could learn the couplings implicitly, and the He et al. results show neural execution can beat hybrids on in-distribution inputs. Our bet is compositional: the symbolic executor reuses coupling templates for xApp combinations it has never seen, the regime where PrAE beat monolithic models by a wide margin. Experiment 3 decides this. If the world model, given identical holdback data, matches us on unseen combinations, then the holdbacks are the contribution and the symbolic layer is not justified. We would say so.
Why not just supervise the coupling concepts with simulator labels? In emulation this works, and it serves as our upper-bound ablation. In deployment, multi-vendor xApps are opaque and labeled telemetry is costly (Kontes et al.). Marconato et al. also report that light concept supervision does not reliably remove shortcuts. We will test whether simulator-labeled models keep their attribution accuracy after transfer to hardware-in-the-loop channels, and whether a small holdback budget closes the gap.
Why not just run random A/B holdbacks? Random holdbacks remove confounding, but they may cost more KPI per unit of information. The equal-budget random-holdback ablation measures exactly this, as attribution accuracy against cumulative KPI loss.
Proposed Experiments
All experiments run on the Colosseum hardware-in-the-loop emulator, which is also where SEM-O-RAN was validated. They use a multi-cell scenario with broadband, massive-IoT, and low-latency slices modeled on the EDRL setup (50 resource blocks, 10 MHz, 30 users per cell). Four xApps act on it: power control, handover offset, slice resource sharing (an EDRL-style agent), and tilt. Colosseum's controlled scenarios give ground-truth coupling for evaluation only. A binarized export of the logs also lets us run GRAPHICA on its native input format.
Experiment 1 measures shortcut prevalence. We generate logs where xApp triggers are correlated at controlled strengths and train each method on KPI outcomes only. We report conflict-detection F1, attribution accuracy against ground truth, the consistent-hypothesis count, and the fraction of training seeds that converge to swapped attributions. The prediction is high F1 alongside low attribution accuracy that worsens as trigger correlation rises.
Experiment 2 measures grounding by holdback. We plot attribution accuracy against holdback budget and cumulative KPI loss for targeted holdbacks, random holdbacks, no holdbacks, and simulator labels.
Experiment 3 tests composition. We train on xApp pairs and test on unseen triples, and on a replacement power-control xApp with a different step size, comparing against the neural world model with matched data.
Experiment 4 is closed-loop deployment. We run each arbiter live and report low-latency slice deadline-violation rate, broadband throughput, and arbitration latency, checked against the 10 ms to 1 s near-real-time budget.
Three results would decide the proposal. First, attribution by learned managers must actually fail under correlated triggers; if it does not, the problem is not real. Second, targeted holdbacks must restore attribution at lower KPI cost than random ones; if they do not, the selection rule adds nothing. Third, the structured manager must beat the equally informed neural world model on unseen combinations; if it does not, the result reduces to "run experiments on your network" and the symbolic layer should be dropped.
References
- A Comprehensive Tutorial and Survey of O-RAN: Exploring Slicing-Aware Architecture, Deployment Options, Use Cases, and Challenges
- O-RAN xApps Conflict Management using Graph Convolutional Networks
- Evolutionary Deep Reinforcement Learning for Dynamic Slice Management in O-RAN
- SEM-O-RAN: Semantic and Flexible O-RAN Slicing for NextG Edge-Assisted Mobile Systems
- Neuro-Symbolic Reasoning Shortcuts: Mitigation Strategies and their Limitations
- Abstract Spatial-Temporal Reasoning via Probabilistic Abduction and Execution
- Neural Algorithmic Reasoning Must Explain When Neuralization Adds Value
- Position Paper: Rethinking AI/ML for Air Interface in Wireless Networks
- Colosseum: Large-Scale Wireless Experimentation Through Hardware-in-the-Loop Network Emulation