Policy-Based Spectrum Sharing

Spectrum is shared by rules, and the rules change. In VIStology’s Cognitive Radio Engine a policy change is a data change, not a software change — the new policy loads as OWL data, inference runs automatically, and no line of the radio’s procedural code is recompiled, retested, or redeployed.

Policy as Data: The Rule Changed, and Nothing Was Rebuilt

The flagship of this work is Towards Collaborative and Dynamic Spectrum Sharing via Interpretation of Spectrum Access Policies (Applied Sciences, 2021), and its premise is the one operational fact everybody designing a radio would rather forget: “rules for spectrum sharing can change after the deployment of radio networks and … the whole system must be able to adapt to them.”

Consider what the alternatives cost. Policy written in imperative code is the worst case, and the paper says why in a sentence any program manager will recognize: “The most difficult requirement to satisfy is the ability to modify the policies after deployment because the code developed in an imperative language, once modified, must be compiled, tested and deployed.” Wrapping the policy in XML does not fix it — it “still requires re-coding of the XML-specified testing of the pre-conditions as well as the procedures implementing the post-conditions.” And a fixed vocabulary fails for a deeper reason: a rule that arrives after deployment may use a term the radio was never shipped with.

“The above requirements cannot be achieved via static definitions of vocabularies (e.g., in XML or a relational database) since adding new terms to such vocabularies would require developing new software”

So the requirement is stated as an absolute, and the whole architecture is downstream of it: the radio software “must be capable of interpreting and executing dynamically added policies, without any modification of the procedural code.” Definitions expressed in a formal language “are then interpreted by generic inference engines that are bound to the same language (such as OWL), thus avoiding the need to rewrite the underlying software.” That is the entire thesis of this page, and it is the flagship's, not our marketing department's.

The rule changed. Nothing was rebuilt. A spectrum access policy in VIStology's Cognitive Radio Engine is data, not code, so a change in the rules is a change in the data rather than a change in the software. The figure contrasts two paths for absorbing a new spectrum rule. On the conventional path, shown in muted gray, a new rule forces an engineer to change the procedural code, recompile it, re-test it and re-deploy it to every radio in the fleet — the paper's own words are that code developed in an imperative language, once modified, must be compiled, tested and deployed. On VIStology's path, shown in accent blue, the new rule arrives from the Policy Authority and is simply loaded into the Inference Store as OWL triples; the very next query is answered differently, with no rebuild and no re-deployment, because the cognitive radio software interprets and executes dynamically added policies without any modification of the procedural code. The middle of the figure shows how a policy is actually represented. A SpectrumAccessPolicy — exactly one of which is active at any time — has SpectrumAccessRules through the hasRule property; each rule is either an Allowed rule, which may carry a maximum transmit power, or a Denied restrictive rule; and each rule governs a SAPHyperspace, a spatio-spectro-temporal region. That space is six-dimensional: longitude, latitude, time interval, frequency range, transmit power and further conditions, mapped to allow or deny. The dimensions are imported rather than invented: the OntoDSA ontology builds on VIStology's SpectralSPARQL, which builds on the OGC GeoSPARQL standard, all grounded on the NuVio foundational ontology. The engine is the Inference Store — an in-memory triple store with a SPARQL 1.1 interface — and every change to it, whether a policy activation or a rule modification, automatically invokes BaseVISor, VIStology's OWL 2 RL reasoner with procedural attachments, which injects the implicit facts back into the store, so the store is deductively closed at query time. The output is the punchline: the Policy Engine does not answer allow or deny. It answers with a list of transmission opportunities, computed by treating rules and requests alike as hyper-rectangles and carving the deny hyper-rectangles out of the allow list, so that a single allowed input hyperspace can yield several output opportunities; intersection lookups are indexed with an augmented AVL interval tree. No radio negotiates with another in this system: each runs the same algorithm over the same shared policy and reaches the same answer. The paper reports no evaluation of the system — no timing, no throughput, no scale, no rule counts, no radio counts — and its O(log n) is an analytic worst-case bound on the interval tree, asserted and never measured. The Rule Changed. Nothing Was Rebuilt. A spectrum access policy is data in a triple store — not a branch in the radio’s source code. Two ways to absorb a new spectrum rule the rule is the same — what the radio has to do about it is not THE CONVENTIONAL PATH what this replaces New spectrum rule Change the procedural code Recompile Re-test Re-deploy to the fleet “…the code developed in an imperative language, once modified, must be compiled, tested and deployed.” VISTOLOGY’S PATH the Cognitive Radio Engine New spectrum rule from the Policy Authority Loaded as data into the Inference Store the active policy is OWL triples in a triple store — not code The next query answers differently No rebuild. No re-deployment. “…the cognitive radio software must be capable of interpreting and executing dynamically added policies, without any modification of the procedural code.” What a policy actually is — a schema, and the space it governs A policy is data, with a schema SpectrumAccessPolicy exactly one policy is active at any given time SpectrumAccessRule Allowed · max transmit power Denied · restrictive SAPHyperspace a spatio-spectro-temporal region — the rule governs it hasRule governs The space it governs is 6-dimensional P : X × Y × T × F × W × C → { allow, deny } X — longitude Y — latitude T — time interval F — frequency range W — transmit power C — further conditions “In 6D, we refer to them as hypercubes or D-rectangles (in this case, D = 6).” OntoDSA → SpectralSPARQL → OGC GeoSPARQL on the NuVio foundational ontology — the dimensions are imported, not invented The Inference Store in-memory triple store · SPARQL 1.1 Every change to the store — a policy activated, a rule modified — automatically invokes BaseVISor, VIStology’s OWL 2 RL reasoner (extended with procedural attachments), which injects the implicit facts back into the store. So at query time the store is deductively closed — every fact the policy entails is already in it. the active policy, as OWL triples the vocabulary it is written in The Policy Engine does not answer allow / deny. It answers with a list of transmission opportunities. a 2-D projection (frequency × time) of the 6-D policy space allow deny one allow rule · one deny rule 1 2 3 three transmission opportunities carve The Policy Engine exposes an API for querying transmission opportunities for any combination of location, time, frequency and power, under the currently active policy — instead of forcing the radio into guess-and-retry. Policy rules and transmission requests are both hyper-rectangles. Deny hyper-rectangles are carved out of the allow list. One allowed input hyperspace may yield several output hyperspaces. Intersection lookups are indexed with an augmented AVL interval tree. a transmission request — where, when, what frequency, what power No radio negotiates with another here: each runs the same algorithm over the same shared policy, and reaches the same answer. The paper reports no evaluation of this system: no timing, no throughput, no scale, no rule counts, no radio counts. The O(log n) above is an analytic worst-case bound on the interval tree — asserted, never measured. Moskal, Choi, Kokar, Um & Choi, “Towards Collaborative and Dynamic Spectrum Sharing via Interpretation of Spectrum Access Policies,” Applied Sciences 11(15):7056, 2021.
Figure 1. The rule changed. Nothing was rebuilt. A new spectrum access policy arrives from the policy authority as OWL data and is loaded into the Inference Store — BaseVISor plus an in-memory triple store with a SPARQL 1.1 interface. Asserting it triggers forward-chaining OWL 2 RL inference automatically, so the store is deductively closed by the time anyone queries it. The Policy Engine then answers the radio’s transmit request not with a bare allow/deny but with transmission opportunities: it intersects the request with every rule of the active policy, carves the deny hyper-rectangles out of the allow hyper-rectangles, and returns the regions of location, time, frequency and power in which this radio may actually transmit. No line of the radio’s procedural code is recompiled, retested or redeployed. Architecture from Moskal, Choi, Kokar, Um & Choi, Applied Sciences 11(15):7056, 2021 — a prototype; the paper reports no system evaluation, and we do not imply one.

A policy has a schema, and the schema is an ontology

A spectrum access policy is not a config file. It is an OWL individual with a class, related to its rules by hasRule, each rule governs-ing a SAPHyperspace — a spatio-spectro-temporal region — and typed as either an allowed or a denied rule, with a maximum transmit power on the allowed ones. The Policy Manager guarantees that exactly one policy is active at any moment. Two kinds of policy are supported, and the second is the one that separates this from a lookup table:

  • Quantitative policies are hyper-rectangles in six dimensions — longitude, latitude, elevation, time interval, frequency interval and maximum transmit power — mapped to allow or deny.
  • Higher-level logical policies cannot be drawn as boxes at all: “allow this transmitter if it is at least 2 km from Node X, below power P1, and using QPSK; or at least 3 km away, below P2, and using 16QAM.” Those are represented as SPARQL Update expressions augmented with our SpectralSPARQL extension, and the paper prints the English rule and its machine-executable form side by side, noting that the two branches of the WHERE clause “directly correspond to the different conditions in the natural text.”

A note on rule languages, because precision matters here: BVR is the rule language of the 2011 radio. The 2021 system's higher-level policies are SPARQL Update expressions, and its inference is OWL 2 RL entailment executed by BaseVISor with procedural attachments. We do not backdate one onto the other.

The ontology underneath is OntoDSA, and its import graph is the standards-reuse story in one line: OntoDSA imports SpectralSPARQL, which imports the Open Geospatial Consortium's GeoSPARQL standard, plus ontologies for lists and uncertainty — and those, in turn, import the NuVio foundational ontology. Nothing here is a silo, and nothing here is invented where a standard already exists.

The engine returns opportunities, not verdicts

Inside the radio, all data is OWL and the reasoner lives in VIStology's Inference Store — “a component that combines the power of BaseVISor's OWL inference capability with an in-memory triple store that exposes a SPARQL 1.1 interface.” It is not invoked on demand and it is not asked politely: “Upon changes to the triple store (assertion of new facts), BaseVISor is automatically triggered and injects implicit facts into the store. Thus, at query time, all facts (explicitly asserted and inferred) are immediately available.” Load a new policy and the consequences of that policy are already computed before anyone asks a question about it.

A deny, by itself, is useless — it sends the radio into guess-and-retry. So the policy engine does something better:

“the PE provides the Controller with an API for querying about transmission opportunities for any combination of location, time, frequency and power, under the currently active policy.”

Mechanically: retrieve the rules of the active policy, discard those whose hyperspaces cannot intersect the request, intersect the rest, bucket them into an allow list and a deny list, and then carve the denies out of the allows — one allowed region in can yield several allowed regions out. The candidates are indexed in an augmented AVL interval tree, which the authors state guarantees worst-case O(log n) insertions and intersection lookups. That bound is analytic. It was never benchmarked, and we will not present it as speed.

The same machinery picks rendezvous channels — and here is where this system differs, fundamentally, from the 2011 negotiating radio (see Cognitive Radio Systems). It does not negotiate. There is no bargaining, no proposal, no counter-offer. Every radio knows the policies, knows only its own location, and runs the identical algorithm: “The rendezvous algorithm will be executed on all the radios with the same input data (i.e., the same set of policies), and thus, the result should be the same for all the radios.” Consensus by shared policy, not by protocol. It is a different system from the 2011 one, a decade apart, and merging the two into a single story would be a fabrication.

What this paper does not contain

It contains no system evaluation. None: no reasoning time, no latency, no throughput, no memory figures, no policy sizes, no radio counts, no scalability curve, no hardware, no over-the-air run, and no baseline comparison. The only thing that was executed for measurement is a MATLAB implementation of the knob-selection loop — “In order to analyze the performance of the PE, we implemented the initialization and the main loop of the algorithm in Matlab” — and the authors' own closing words about the system are “One of our primary goals was to develop a prototype of such a system” and “due to the space limitations, the details of the implementation have not been presented.”

We say this out loud for two reasons. The first is that it is true. The second is that the same paper says what should be done about it — “we argue that such research should provide quantitative metrics for system performance” — and VIStology then went and produced them. That work is the Capability Matching use case.

Funding, stated precisely: this work was supported by a grant-in-aid of Hanwha Systems and the Agency for Defense Development (ADD), Republic of Korea. It is a South Korean program, not U.S. Government work: the paper names no U.S. sponsor, and we claim none.

Bridging the Two Standards Families: Spectrum Consumption Models into the Ontology

Model-Based Spectrum Management represents spectrum use as Spectrum Consumption Models — data structures that can serve as policy specifications, as representations of current spectrum consumption, or as requests and authorizations of spectrum use. They are written in SCMML, which is an XML schema, and that is precisely the problem: “these representations cannot be processed by automatic inference engines due to the lack of formal semantics for the eXtensible Markup Language (XML) in which SCMML is defined.” (At the time that paper was written, IEEE 1900.5.2 was still in preparation — the working group “will capture” the SCM specification, in the paper's own future tense. We cite the paper for what it did, not as authority on what the standard now says.)

VIStology and Northeastern mapped SCMs into the Cognitive Radio Ontology, and the method generalizes to any standard that churns:

  • Convert the schema automatically. “we used a tool developed by VIStology that can automatically transform any XML schema definition to OWL” — producing not only the TBox but “an instance generator, which can convert XML documents to OWL ABox.” Because the tool is schema-agnostic, a new revision of the standard means re-running the converter, not rewriting an interpreter. (It maintains the majority of the schema's integrity constraints — the paper's word, and ours.)
  • Then add the axioms that a schema cannot carry. The raw conversion is thin: it “primarily captures the tree structure of the XSD schema.” The value is in the bridging axioms written by hand — equivalences between the SCM vocabulary and the radio ontology's, subclass links into the foundational ontology — and the payoff is precise: “the class Transmitter is part of both the CRO2 and of the SCMML … Inference is then needed to carry the consequences of the restrictions to the specific transmitters.” A spectrum request authored in someone else's markup inherits our axioms automatically.
  • And the arithmetic runs where arithmetic belongs. The two demonstrated use cases — is this transmitter inside the restricted volume, and would its emission exceed a receiver's underlay mask — needed geometry and power math, and got it: “Those operations were successfully implemented via procedural attachments that were invoked by the inference engine executing the rules.” Java did the numbers. OWL entailment did not, and we will not say it did.

The claim that paper supports is feasibility, and nothing beyond it. Its scenarios are hand-built, four transmitters and four receivers; there is no evaluation, no timing, no scale study, and the authors list all three as future work. What it demonstrates is that a spectrum-compatibility question — would this transmission interfere? — can be decided by a general-purpose reasoner over formal models, before the transmission happens.

Proof Points

Policy as data

The Cognitive Radio Engine

The 2021 flagship (Applied Sciences 11(15):7056): six components — Policy Manager, Policy Engine, Planner, Learner, Controller and Inference Store — with every datum in OWL, policies as 6-D hyper-rectangles and as SPARQL Update expressions, forward-chaining OWL 2 RL closure on every write, and a policy engine that returns transmission opportunities rather than a verdict. Rendezvous is reached by shared-policy consensus: every radio runs the same algorithm over the same policies. Boundaries, in the authors' own words: it is a prototype, the implementation details “have not been presented”, there is no system evaluation in the paper, and its O(log n) is an analytic bound, never measured. Funded by Hanwha Systems and the Agency for Defense Development (ADD), Republic of Korea.

Interoperability

Spectrum Models in Somebody Else's Schema

Spectrum Consumption Models are published as an XML schema and cannot be reasoned over. VIStology's schema-agnostic XSD→OWL converter lifts them automatically — TBox plus an XML→ABox instance generator — and hand-written bridging axioms fuse the result with the Cognitive Radio Ontology, so an SCM authored in plain markup inherits our axioms and a reasoner can decide, before transmission, whether a policy permits it and whether the emission would exceed a receiver's underlay mask. Boundaries: a feasibility demonstration on four transmitters and four receivers; no evaluation, no timing, no scale; and the geometry and power-margin arithmetic ran in Java procedural attachments called from the rules, not in OWL entailment.

Selected Publications

Towards Collaborative and Dynamic Spectrum Sharing via Interpretation of Spectrum Access Policies

Moskal, J.J., Choi, J.-K., Kokar, M.M., Um, S. & Choi, J.W.

Applied Sciences 11(15):7056 (2021)

View Publication

Mapping Spectrum Consumption Models to Cognitive Radio Ontology for Automatic Inference

Chen, Y., Kokar, M.M., Moskal, J.J. & Suresh, D.

Analog Integrated Circuits and Signal Processing 106(1):9-21

View Publication

See the full list of VIStology publications →

Related

Dynamic Spectrum Sharing & Cognitive Radio The solution this use case belongs to Cognitive Radio Systems The sibling use case: the reasoner inside the radio Capability Matching The sibling use case: the measured comparison Policy Reasoning & Secure Information Exchange The same policy-as-data doctrine, in the message path BaseVISor The engine in the Inference Store All Publications The full research record

Change the Rule Without Rebuilding the Radio

If a policy revision costs you a software release, we can help you move the policy out of the code and into data a reasoner interprets.

Get in Touch