Future base stations will steer radio beams with hundreds to thousands of antennas. There are too many to give each antenna its own expensive radio chain, the circuitry that includes amplifiers, mixers and data converters. So designs share a few radio chains across many antennas through phase shifters, switch networks and subarrays. The wiring of these front ends changes constantly. An antenna fails, a switch sticks, firmware reassigns radio chains to a different subarray, or a vendor ships a variant with fewer phase shifters. Each time, an engineer has to answer one question: did this change remove any capability the scheduler relies on, such as "sector 7 can still be served with two simultaneous streams"? Today the answer comes from rerunning large channel simulations, or from comparing configuration files line by line. Simulations are slow and only sample the space of cases. Line-by-line comparison flags harmless reroutes and misses changes whose effects spread far beyond the edited line.
This proposal borrows a tool from ontology engineering to answer that question. The tool is logical difference analysis: comparing two knowledge bases by what they imply rather than by how they are written. We describe an RF front end as a small description-logic knowledge base, a set of machine-checkable facts and rules about which component connects to which and what each connection pattern makes possible. We then compute the logical difference between the "before" and "after" versions, restricted to a vocabulary of capabilities the operator cares about. The output is a list of capabilities gained or lost ("witnesses"), each paired with the hardware facts that cause it. This check runs once per reconfiguration event, not once per channel coherence block. It complements beamforming optimizers rather than replacing them.
Core Claim
The claim has two parts, and both can be tested.
The first part is signature-restricted logical diffing. In the capability vocabulary, this is a diff that reports only changes in what can be concluded about the capabilities of interest. On front-end reconfiguration events, it separates changes that alter capabilities from changes that do not, with higher precision than syntactic or structural comparison. Its recall of real capability losses is comparable to Monte Carlo simulation with a state-of-the-art hybrid precoder, and it runs orders of magnitude faster.
The second part is that the diff reports capability losses nobody wrote a check for. A hand-coded property checker only tests the properties someone thought to list. This is where a general logical engine should earn its place over a custom graph checker.
The analogy to ontology maintenance is direct. Two different switch routings can support exactly the same set of beams, which is the counterpart of a cosmetic refactoring that a text diff falsely flags. Conversely, removing one fixed phase shifter from a shared bank can silently disable dozens of beams elsewhere in the array, which is the counterpart of a one-axiom edit whose consequences cascade.
Why This Pairing and Not the Obvious One
The file shows no prior work applying description-logic diffing or uniform interpolation to hybrid beamforming. The first idea that comes to mind is to run logical diffs between consecutive precoders or switch states every coherence block, to decide when to recompute. We reject it. At millisecond timescales, a Frobenius-norm threshold, or a direct numeric check of per-user gain and interference, is cheaper and says the same thing, because the relevant facts are numbers rather than chains of inference. Logical deduction adds value only when conclusions follow from composing many discrete facts. That describes connectivity through switch fabrics, subarray membership and fault states. It does not describe channel matrices.
We therefore place the method at the configuration and fault-management timescale, from seconds to months. At that timescale, hardware structure really is a symbolic object.
Research Program
Encoding the hardware. We encode an RF front end as a knowledge base in $\mathcal{EL}^{++}$, a lightweight description logic in which reasoning takes polynomial time and which allows role composition. Role composition lets us write rules such as "if a chain connects to a switch and the switch connects to an element, then the chain drives the element." The encoding has four parts:
- Components are atomic concepts: radio chain, switch, fixed phase shifter, antenna element, subarray.
- Signal paths are relations between components.
- Faults are asserted as disjointness facts or by removing edges.
- Capabilities are defined concepts, for example "a sector coverable with $k$ streams."
Geometry and phase-set facts enter as atomic facts computed offline. For instance, the fact "element set $S$ with phase set $P$ can form a beam into sector $j$" is derived once from the array model.
Counting conditions cannot be expressed natively in $\mathcal{EL}$. Two examples are the result of Hybrid Digital and Analog Beamforming Design for Large-Scale Antenna Arrays that $N_{RF} \geq 2N_s$ radio chains suffice to reproduce any fully digital precoder, and the per-bank shifter counts in Hybrid Precoding in Millimeter Wave Systems: How Many Phase Shifters Are Needed?. We handle these by computing them in a preprocessing pass and recording each as an atomic "threshold met" fact. This is a real expressivity limit, and we report how often it forces preprocessing.
Computing the diff. We reuse the forgetting-based $\mathcal{ELH}$ engine of Tracking Semantic Evolutionary Changes in Large-Scale Ontological Knowledge Bases. That engine eliminates all symbols outside the vocabulary of interest $\Sigma$ while keeping every consequence over $\Sigma$, then filters the result against the other version with a standard reasoner. It scales past 600,000 axioms within a 9 GB heap. A 4,096-element array with its switch fabric should need tens of thousands of axioms, so the method supplies ample headroom.
Localizing the check. Before diffing, we run semantic module extraction in the style of Logical Difference and Module Extraction with CEX and MEX. Module extraction cuts the knowledge base down to the smallest part that still determines every conclusion about the chosen vocabulary. For extremely large arrays whose regions see different users, as in Adaptive Subarray Segmentation: A New Paradigm of Spatial Non-Stationary Near-Field Channel Estimation for XL-MIMO Systems, we use a user cluster's visible region as the vocabulary. The diff then touches only the subarrays that can affect that cluster.
Explaining the diff. Current forgetting-based diff engines report which conclusions changed but not why (Tracking Semantic Evolutionary Changes in Large-Scale Ontological Knowledge Bases). We add minimal justification computation for each witness, which is feasible in $\mathcal{EL}$. An engineer then sees, for example, "lost: two-stream coverage of sector 7; because: switch 12 stuck and phase-shifter bank B reduced below threshold." The justification output is a contribution that could be reused in ontology engineering.
Role of each literature thread. Ontology diffing supplies the method. The finding of CEX and MEX: Logical Diff and Logic-based Module Extraction in a Fragment of OWL, that logical diffs found about five times more changes than hierarchy comparison, motivates the claim that structural diffs miss changes. The hybrid-precoding literature supplies the architectures to encode and the simulators that provide ground truth. Its standard assumption of perfect channel knowledge is harmless here, because we evaluate structural capability rather than estimation.
Baselines
The naive reference point is a syntactic diff of the front-end configuration (netlist and switch-state files), in the spirit of git diff. Any changed line counts as a potential capability change. This baseline has recall close to 1 for "something changed" and poor precision for "a capability changed." We report its false-positive rate on reroutes that preserve capabilities.
The strongest competitor is Monte Carlo capability testing with a modern hybrid precoder. For each reconfiguration we rerun the precoder on both versions over 1,000 Saleh-Valenzuela clustered channel realizations, a standard statistical model of millimeter-wave multipath. We use FPS-AltMin from Hybrid Precoding in Millimeter Wave Systems: How Many Phase Shifters Are Needed? for switch-and-fixed-shifter designs, MO-AltMin from Alternating Minimization Algorithms for Hybrid Precoding in Millimeter Wave MIMO Systems for fully connected designs, and the subarray method of Energy-Efficient Transceiver Design for Hybrid Sub-Array Architecture MIMO Systems for subarray designs. A capability counts as lost if per-sector spectral efficiency drops by more than 1 dB relative to the pre-change configuration. The 1 dB margin echoes the gap to fully digital reported by Hybrid Digital and Analog Beamforming Design for Large-Scale Antenna Arrays.
This baseline is strongest because it measures what operators actually care about. In a dense sweep it is also our ground truth, so the question is not whether the logical diff is "more correct" than simulation. The question is whether the diff reaches near-simulation recall at a small fraction of the cost, and whether it separates harmless from harmful changes better than cheap proxies. The FPS paper reports near-optimal spectral efficiency with 10 to 15 fixed phase shifters at 144 antennas, and 30 fixed shifters versus more than 2,300 adaptive shifters in the multi-user case. No reported spectral-efficiency value in bits/s/Hz for FPS-AltMin was found on Lacuna, so we will regenerate that curve ourselves. For fairness, the Monte Carlo baseline gets the same wall-clock budget as the logical diff at each event, and a separate unlimited-budget run serves as the ground truth. Beating it means one of two things: matching its recall within that equal budget, or matching its unlimited-budget recall at least 100 times faster.
The third baseline is a hand-coded structural checker: breadth-first reachability over the switch graph plus a fixed list of capability predicates written by an RF engineer. It shares our preprocessing and differs only in using fixed checks instead of general deduction plus forgetting. It therefore isolates the key ingredient. Beating it means finding Monte-Carlo-confirmed capability losses that the fixed checklist misses.
The ablation removes module extraction, to measure its runtime contribution on arrays of 1,024 elements and more. In SNOMED, module extraction cut a 100-term diff from over 500 s to 3.66 s (CEX and MEX: Logical Diff and Logic-based Module Extraction in a Fragment of OWL).
Why not just…?
Why not just threshold the norm of the precoder change? A norm treats two routings that support the same beams as different. It can also treat a small coordinated phase change that fills an interference null as negligible. More fundamentally, norms apply to precoders computed for particular channels, while our question concerns guarantees across all channels in a sector. We concede that for the per-coherence-block decision of when to recompute, a norm or a direct gain check is the right tool. That is exactly why we do not target that timescale.
Why not just rerun FPS-AltMin or MO-AltMin on sampled channels after every change? This is the real threat. With enough compute it is more faithful than our encoding, because it captures effects the symbolic model leaves out, such as switch insertion loss and phase quantization. The latter can cost up to 5 dB if handled naively (Hybrid Digital and Analog Beamforming Design for Large-Scale Antenna Arrays). Our argument concerns cost and coverage. The number of events grows with array size and fleet size, each simulation covers only sampled channels and sectors, and each result says only that performance dropped, not which hardware fact caused the drop. The equal-budget comparison below settles the matter. If simulation at equal budget matches our recall, the proposal's value shrinks to explanation alone, and we will say so.
Why not just write a graph-reachability checker? For any fixed, known list of properties, a custom checker will be about as accurate and faster. The logical diff has an advantage only when it reports Σ-consequences that nobody enumerated, such as interactions between a fault and a subarray re-segmentation. The hand-coded checker baseline measures this directly. If it catches every confirmed loss we catch, the general engine is unnecessary, and we would redirect the work toward justification generation on top of the simple checker.
Proposed Experiments
We will build a corpus of front-end version pairs from three base designs:
- the 144-antenna switch-and-fixed-phase-shifter base station of Hybrid Precoding in Millimeter Wave Systems: How Many Phase Shifters Are Needed?;
- the 144-transmit, 36-receive fully connected setup of Alternating Minimization Algorithms for Hybrid Precoding in Millimeter Wave MIMO Systems;
- the 16×16 and 64×64 subarray setups of Energy-Efficient Transceiver Design for Hybrid Sub-Array Architecture MIMO Systems, scaled up to 4,096-element arrays with regions that see different users.
Each pair applies one or more events: element failure, radio-chain failure, a stuck switch, fixed-shifter bank reductions (30 to 15 to 10), conversion from fully connected to subarray, and subarray re-segmentation. We will deliberately include reroutes known to preserve capabilities, to test false positives.
Ground truth comes from unlimited-budget Monte Carlo runs over 1,000 Saleh-Valenzuela realizations per sector. We will report precision and recall of capability-loss detection, wall-clock time per event, and witness counts. We will also report the fraction of capabilities that required counting-based preprocessing, and timeouts on cyclic fabrics, since the $\mathcal{ELH}$ engine is known to struggle with cyclic dependencies.
Three results decide the question:
- The logical diff must reach at least 0.9 recall against ground truth while running at least 100 times faster than the Monte Carlo baseline. For scale, the forgetting-based engine of Tracking Logical Difference in Large-Scale Ontologies: A Forgetting-Based Approach reported diffs in as little as 7.6 s on ontologies far larger than ours.
- The logical diff must have substantially higher precision than the syntactic diff on the capability-preserving reroutes.
- The logical diff must find confirmed losses that the hand-coded checker misses.
If the first result fails, the symbolic abstraction is too coarse. If the third fails, general deduction is unnecessary and only the justification layer survives.
References
- Hybrid Digital and Analog Beamforming Design for Large-Scale Antenna Arrays
- Hybrid Precoding in Millimeter Wave Systems: How Many Phase Shifters Are Needed?
- Tracking Semantic Evolutionary Changes in Large-Scale Ontological Knowledge Bases
- Logical Difference and Module Extraction with CEX and MEX
- Adaptive Subarray Segmentation: A New Paradigm of Spatial Non-Stationary Near-Field Channel Estimation for XL-MIMO Systems
- CEX and MEX: Logical Diff and Logic-based Module Extraction in a Fragment of OWL
- Alternating Minimization Algorithms for Hybrid Precoding in Millimeter Wave MIMO Systems
- Energy-Efficient Transceiver Design for Hybrid Sub-Array Architecture MIMO Systems
- Tracking Logical Difference in Large-Scale Ontologies: A Forgetting-Based Approach