Language Issues For Cognitive Radio: Proceedings of The IEEE May 2009

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/224401766
Language Issues for Cognitive Radio
Article in Proceedings of the IEEE · May 2009

DOI: 10.1109/JPROC.2009.2013028 · Source: IEEE Xplore
CITATIONS READS
27 384
2 authors:
Mieczyslaw M. Kokar Leszek Lechowicz

Northeastern University Northeastern University
199 PUBLICATIONS 3,243 CITATIONS 3 PUBLICATIONS 52 CITATIONS
SEE PROFILE SEE PROFILE
Some of the authors of this publication are also working on these related projects:
Semantics View project
VIStology Social Media Analytics View project
All content following this page was uploaded by Leszek Lechowicz on 31 May 2014.
The user has requested enhancement of the downloaded file.

INVITED
PAPER
Language Issues for

Cognitive Radio
Computer languages that may be useful for expressing cognitive radio concepts are
identified and evaluated in this tutorial paper.
By Mieczyslaw M. Kokar, Senior Member IEEE , and Leszek Lechowicz, Member IEEE
ABSTRACT | This paper discusses various aspects of formal The Software Defined Radio Forum (SDRF) [3] defines
languages in the context of cognitive radio. A bottom up cognitive radio as follows.
approach is taken in which an example of a specification of a a) Radio in which communication systems are
feature of cognitive radio in a selected language is shown, aware of their environment and internal state
followed by an example of a feature that cannot be expressed and can make decisions about their radio
in the language and the identification of a capability that needs operating behavior based on that information
to be added to the language in order to cover the identified gap and predefined objectives. The environmental
in the expressiveness. Following this pattern, we start with a information may or may not include location
language based on description logics and add the capability of information related to communication systems.
expressing rules, then functions, and finally behavioral aspects. b) Cognitive radio [as defined in a)] that utilizes
The running example used in this paperVconveying the software defined radio, adaptive radio, and other
description of a component to be synthesized by another technologies to automatically adjust its behavior
radioVcovers two major aspects of a cognitive radio: an ability or operations to achieve desired objectives.
to express own capabilities and an ability to interoperate with Kokar et al. in [4] pattern the definition of cognitive
other cognitive radios. radio upon the definition of a cognitive agent, i.e., a system
that can:
KEYWORDS | Cognitive radio; formal language; formal seman- • reason, using substantial amounts of appropriately
tics; radio ontology represented knowledge;
• learn from its experience so that it performs better
tomorrow than it did today;
I. INTRODUCTION • explain itself and be told what to do;
The notion of cognitive radio was first introduced by • be aware of its own capabilities and reflect on its
Mitola [1], [2]. His analysis started with a statement of own behavior;
need for radios to negotiate various aspects of communi- • respond robustly to surprise.
cation etiquette. Mitola’s conclusion was that a cognitive All of these definitions stress the fact that cognitive
radio must be self-aware (know its own structure, both radios must be able to express their knowledge of
hardware and software) and have a language in which to themselves and of the communication environment.
describe requests and replies to/from other radios and Thus, either directly or indirectly, they all call for the
network. He also described a language that could be used need of a language in which these concepts can be
to represent this kind of knowledge (models of radio and expressed. Thus in this paper we discuss not whether a
communication environment). language is needed to achieve the cognitive radio
functionality but what kind of language it needs to be.
At least two paths can be taken to specify requirements
for a language. In one approach one would specify some
Manuscript received November 11, 2008. Current version published April 15, 2009. The
work of M. Kokar was supported in part by the Defense Advanced Projects Research
general requirements for a language, and then such
Agency under programs XG, DTN, WANN and WNaN. requirements could be refined. The problem with this
The authors are with the Department of Electrical and Computer Engineering,
Northeastern University, Boston, MA 02115 USA (e-mail: [email protected];
approach is that for this to be possible, one would need to
[email protected]). have pretty good understanding of the expectation for such
Digital Object Identifier: 10.1109/JPROC.2009.2013028 a language. The concept of cognitive radio is still under
0018-9219/$25.00 2009 IEEE Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 689
Authorized licensed use limited to: Northeastern University. Downloaded on July 26, 2009 at 11:49 from IEEE Xplore. Restrictions apply.
Kokar and Lechowicz: Language Issues for Cognitive Radio
development, and thus it is difficult to put forward to the control structure. The control structure is partially
requirements that would capture all the future needs. captured by the ordering of operations in the list. The rest
In this paper, we are taking a different approach. We of the control structure is embedded in the program in the
first start with an attempt to satisfy the needs with an form of control statements like if-then-else, do-while, and
existing languageVWeb Ontology Language (OWL)1Vand do-until. Thus an imperative program includes the
then identify areas that cannot be expressed in this information on both what needs to be done and how it
language. This leads us to consider a more expressive needs to be accomplished (in what sequence). An
language (a rule language) that covers some of the gaps that imperative program is said to provide an algorithm. The
cannot be covered in OWL. Following the same path of Bwhat[ information is explicit, although it is distributed
reasoning, we come to the conclusion that the target over all the statements of the program.
language for cognitive radio must include the ability to A declarative language, on the other hand, represents a
introduce new functions. And finally, we show that in somewhat different paradigm of programming. In this
addition to this, the language must be capable of specifying paradigm, the program expresses what should be accomplished
dynamics (behaviors) of radio components. rather then how. The Bhow[ is left to a generic inference
Computer languages can be classified into two engine. Thus a declarative program is a collection of facts
groupsVimperative (or procedural) and declarative. In (referred to as clauses) expressed in a declarative language and
Section II, we give a brief overview of the main differences a goal provided by the user. The generic inference engine then
between these two groups and then argue that the tries to find a solution to the goal (or satisfy the query). Logic
flexibility of the functionality of cognitive radio requires programming, whose example is Prolog, is a representative of
the inference power of a formal declarative language with the declarative programming paradigm.
formal, computer-processable semantics. Both imperative and declarative programs take some data
The rest of this paper is organized as follows. In on input and produce some output. One more difference
Section III, we discuss the role of ontologies in the between the two paradigms shows up in the way modifica-
functioning of cognitive radio and show how OWL can be tion to a program is achieved. In the procedural approach,
used for expressing some properties of such radios. Then in modification involves replacement of a program. Typically
Section IV, we show that structures cannot be expressed in this means that a system needs to be taken offline and the
OWL and that at least the power of a rule language is modified piece needs to be recompiled and linked with the
necessary to achieve such functionality. We continue our whole system, after which the system can be restarted. In
analysis in Section V, recognizing the need for the ability to the declarative paradigm, on the other hand, the only part
reason about functions. In Section VI, we discuss the that needs to be modified is the fact and rule base (clauses).
problem of expressing behavioral aspects of radio compo- A clause can be removed and another clause can be added
nents. In particular, we discuss the problem of specifying during the system operation. This is possible because the
dynamics, e.g., delays. In Section VII, we provide an over- generic algorithm (the inference engine) is not modified.
view of three efforts whose goal is to develop a standard The clauses can be treated (almost) as input data.
language for radio/network communications. In Section VIII, It is important to notice, however, that any modifica-
we conclude this paper with a discussion of the language tion, whether of an imperative program or of the clauses in
issues that have and have not been covered here. a declarative program, carries the risk of inserting errors
into the system; thus in either case, such modification
requires testing. In the procedural case, this is the new
II. PROCEDURAL VERS US DECLARATIVE (modified) program that needs to be tested. In the
Computer languages can be classified in many different declarative case, the clauses can be tested with an inference
ways. It would be difficult, if not impossible, to come up engine (not necessarily the same one), and thus the testing
with a complete and disjoint classification that would procedure can be performed offline before the modification
capture all of the existing languages. Thus in this paper, we of clauses in the running program. More discussion on the
list some of the properties of languages rather than attempt advantages of declarative languages can be found in [6].
to provide a classification. The basic distinction in the So now comes the fundamental questionVwhich kind
properties of computer languages is whether a language is of computer language is more appropriate for cognitive
imperative (also known as procedural) or declarative. radio? Unfortunately, there is no simple answer to this
Examples of imperative languages are C, C++, Java, and question. In an attempt to answer this question, let us look
Fortran. Examples of declarative languages include Prolog, at some of the aspects of the definition of cognitive radio.
SQL, OWL, and SWRL. A program written in an In particular, we can see that cognitive radio must have the
imperative language can be viewed as a list of statements following capabilities:
(operations) that manipulate the state of the program [5]. • be aware of its own state and the state of the
The operations then are executed in a sequence according environment;
• tell other radios and network of what it knows and
1
http://www.w3.org/2004/OWL/. what it wants;
690 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

• reflect, i.e., be able to draw conclusions from the sequence of statements have to be provided by the
facts that it is aware of; programmer. Thus, although in both paradigms some
• react to surprise, i.e., react to the circumstances it knowledge must exist in the program, the fact that a
has not seen before. declarative program can find an answer without explicit
When we match these requirements with the features control knowledge makes this paradigm more appropriate
of the two types of computer languages, the first reaction to the achievement of the goal of reacting to surprise.
seems to be that a declarative language should be able to Note, however, that adding new knowledge dynamically to
satisfy all of them. In particular, it is easier for a radio to a running program implies that the program must be able
express its own knowledge in a declarative language rather to (correctly) interpret the added knowledge by itself.
than in a procedural one since it can be accomplished by This, in turn, implies that the declarative language in
stating only the Bwhat[ without saying Bhow.[ For in- which the knowledge is expressed must have a computer
stance, a radio can tell another radio Bdo this and this.[ It processable semantics. In other words, there must be a
would be much more difficult to actually tell the other logic associated with the language. This leads us to formal
radio how to accomplish this. languages (i.e., languages with formal syntax) that also
In order to satisfy the Bawareness[ requirement, it is have formal semantics. Formal syntax means rules for
important to realize that awareness includes not only the deciding whether a given string is in the language or not
knowledge of particular facts but also the ability to [strings that are part of a language are also called well-
understand the implications of the facts to the operation of formed forms (wffs)] and for generating wffs out of other
the radio. For instance, just knowing that the current wffs. Formal semantics, on the other hand, refers to
operating frequency is within the 700 MHz band, without interpretations, i.e., mappings from the terms of the
also knowing whether it is currently assigned to analog TV language to a mathematical domain (a set of individuals)
or for public safety, cannot be considered as a case of full and from sentences to truth values.2 Together with a set of
awareness. On the other hand, if the radio 1) has a inference rules and an inference engine, this constitutes a
declarative knowledge base that relates various variables, formal system. In this paper, we discuss formal languages
like frequencies, bands, band allocations, error rates, and with formal semantics within the context of a formal
such and 2) has a generic inference engine that can infer system.
the implications of various operating states and environ- An inference engine can take a set of sentences in the
mental conditions (like the understanding of whether it language and apply the inference rules of the formal
can access the TV band), then this will satisfy the system to derive new sentences. A formal system is desired
awareness requirement to a much higher degree. to be sound, i.e., given a consistent set of true sentences, it
The self-awareness also may need to include the can derive only true sentences, i.e., the sentences that map
concept of reflection, which is addressed by most declar- to the truth value of Btrue[ by the interpretation function
ative languages and by some procedural languages too. It is (although researchers in the semantic Web community are
important to point out here that although a program keeps working on ways of handling inconsistencies and un-
values of its variables, it does not automatically follow that soundness, e.g., [7]). This feature is particularly important
the program knows its own variables. We could require when automatic inference is carried out by an inference
(and this is rather reasonable) that for a program to know engine, without a human in the loop. Without this
its own variables it should be able to answer such queries characteristic, the system would not have a basis for
likeVwhat are your variables? And then, what is the type deciding which of the inference results should be admitted
of that variable, and what is its value? and which had to be ignored. Another desirable (but hardly
The ability of reacting to surprise is perhaps the most achievable) feature of a formal system is the completeness
prominent feature of cognitive radio that points in the requirement, which refers to the ability to infer all possible
direction of the declarative paradigm. If all the required true sentences using the rules of inference.
information is available at design time, the programmer Lastly, one aspect of computer languages that is very
can encode this information into a program using an important is the engineering aspectVthe time and
imperative language, which would most likely provide a memory requirements for a given language. The flexibility
better performance than one obtained by using an of declarative languages comes with a priceVthe high time
inference engine. This approach will not be too effective complexity. The worst case time complexity of inference in
if (costly) modifications to the program are frequently most of the declarative languages discussed in this paper
required. falls in the complexity class termed undecidable [8]. The
In the declarative paradigm, whatever knowledge consequence of this fact is that inference algorithms are
(clauses) that is available in the knowledge base can be not complete and may return an Bunknown[ answer given
utilized for finding answers to unexpected goals (queries). the time and/or memory limits are exceeded.
This is achieved through the searching and matching
algorithm of the inference engine. In the procedural 2
Note that this is only one of many ways of defining a semantics for a
paradigm, on the other hand, not only the facts but also the language.
Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 691

III . ONTOLOGIES AND OWL

A formal system is just a system for sound inference. In
order to make it useful to a specific domain, the things of
interest for the domain must be represented in the
language so that inference can be applied to the sentences
about these things. For the domain of cognitive radio,
some knowledge of the wireless communications domain
is necessary. The issue of knowledge representation has
been investigated for many years now by the artificial
intelligence (AI) community. Various competing repre-
sentation formalisms were developed over the years.
Recently, the AI community has converged on an
abstraction for knowledge representation called ontology.
In one sense, ontology is Ba science or study of being[ [9]
(onto), i.e., about what exists in reality. Ontology in this Fig 1. A simple ontology: Component and Ports.
sense is a branch of philosophy. AI, on the other hand, uses
ontology in a different sense (although still somewhat
related to philosophy). According to an AI definition (see
[10]), Ban ontology is an explicit specification of a example, Component and Port are classes. Relationships
conceptualization.[ Thus it is just knowledge of a domain are represented as arrows. For instance, isInputPortOf is a
represented in a declarative formalism. These are defini- relation (usually called property).
tions that associate the names of things in the universe of Classes are organized into a hierarchy of classes by the
discourse (e.g., classes, relations, functions, or individuals) subclass relationship. For example, InputPort and Out-
with human-readable text describing what the names putPort are both subclasses of the Port class. This means
mean, and formal axioms that constrain the interpretation that each individual of InputPort and OutputPort is also an
and well-formed use of these terms. It is a statement of a individual of Port. The subclass relationship in the
logical theory. In this paper, we use the term Bontology[ in notation we use here is represented by an arrow from
the sense of AI. the subclass to the superclass with an annotation Bisa.[
Another consensus that the AI community has reached Properties are relationships among individuals. There
is that a common language is desirable for representing are two kinds of properties. Data type properties are
ontologies. This trend can be observed in various attributes that individuals have, e.g., the number of ports
communities. For instance, the software engineering that a component has. A data type property is a
community has settled on one languageVthe Unified characteristic of a single individual, where that character-
Modeling Language (UML). Although there is no such a istic is a data value such as a number. An object property is a
strong agreement on a standard ontology representation relationship among various individuals. For example, a
language, the OWL has collected the largest number of component can have input ports and output ports. This is
practitioners and supporters so far. It is worthwhile shown in the ontology as arrows from the class Component
mentioning that the semantic Web community is working to the classes InputPort and OutputPort. The arrows are
on various ways of modifying OWL, in the direction of both annotated with the name of the propertiesVhasInputPort
weakening and increasing its expressivity. and hasOutputPort, respectively. The class at the tail of the
In this paper, we will present our attempts at using arrow is called the domain of the property, while the class
OWL for cognitive radio. Rather than waiting for a fully at the head of the arrow is called the range of the property.
approved standard (which may never happen), for the An ontology will generally have many different kinds of
purpose of this paper we took OWL as it exists now. In the data type and object properties. As with classes, one kind
rest of this paper, we show what can and what cannot be of property may be regarded as a set of elements called
achieved with OWL. We also show what kind of facts. For example, when a particular component c has an
expressiveness extensions are needed to satisfy the input port p, this fact is represented by the triple
cognitive radio requirements listed in Section I. ðc; hasInputPort; pÞ. Properties can be organized in a
To introduce the concept of ontology (as used in this hierarchy by the subproperty relationship.
paper), we use a simple example of an ontology that is The following fragment of the OWL code represents
relevant to the cognitive radio (CR) domain shown in Fig. 1. the ontology shown in Fig. 1. It is represented here in the
An ontology for a domain specifies the concepts of the XML syntax. First it states that this is a legal RDF
domain, attributes of the concepts, and relationships document and lists the XML namespaces and their
among the concepts. Concepts are specified as classes, abbreviations. The ontology shows declarations of classes
interpreted as sets of individuals. Typically, classes are (delimited by the owl:Class tags). Then it lists the
represented graphically by rectangles. For instance, in this properties (delimited by the owl:ObjectProperty tags)

with specifications of domains and ranges of all the rdf:resource=B#hasPort[/>

properties. It also states that some of the classes satisfy the Grdfs:range rdf:resource=B#OutputPort[/>
owl:disjointWith property, i.e., they have no individuals in Grdfs:domain rdf:resource=B#Component[/>
common. All the classes, subclasses, and properties in this G/owl:ObjectProperty>
listing can be directly traced to Fig. 1. G/rdf:RDF>
G?xml version=B1.0[?> To illustrate the use of OWL in the software radio

Grdf:RDF domain, consider a component [quadrature modulator
xmlns=Bhttp://www.llech.com/RadioTest1.owl#[ (QM)] shown in Fig. 2.
xmlns:rdf=Bhttp://www.w3.org/1999/02/22-rdf- QM is one of the most fundamental building blocks
syntax-ns#[ used in radio engineering [11]. QM shifts a carrier by 90 ,
xmlns:xsd=Bhttp://www.w3.org/2001/XMLSchema#[ multiplies the original carrier by one signal and the shifted
xmlns:rdfs=Bhttp://www.w3.org/2000/01/rdf- by another, and adds the two signals together. In this way,
schema#[ QM effectively encodes two different signals in the same
xmlns:owl=Bhttp://www.w3.org/2002/07/owl#[ band. Since the two carriers are orthogonal, the encoded
xml:base=Bhttp://www.llech.com/RadioTest1.owl[> information can be extracted at the receiver by synchro-
Gowl:Ontology rdf:about=B[/> nous demodulation. QM is frequently used to implement
Gowl:Class rdf:ID=BPort[> various functional modules in modern communication
Gowl:disjointWith> systems, for example, quadrature amplitude modulator
Gowl:Class rdf:ID=BComponent[/> (QAM), phase-shift keying modulator, and others. Practi-
G/owl:disjointWith> cal examples of its use are shown in Fig. 3.
G/owl:Class> The choice of QM in our running example can be
Gowl:Class rdf:ID=BOutputPort[> argued as being too simplistic and too disconnected from
Grdfs:subClassOf rdf:resource=B#Port[/> the context of its use for a real-life radio engineering
Gowl:disjointWith> example. Clearly, from the radio engineering perspective,
Gowl:Class rdf:ID=BInputPort[/> it would be more convincing to show an example of the
G/owl:disjointWith> specification of the QAM instead. However, such a
G/owl:Class> component would be too complex for showing the
Gowl:Class rdf:about=B#InputPort[> fundamental concepts related to ontologies, rules, and
Grdfs:subClassOf rdf:resource=B#Port[/> functions, mainly because a formal specification of this
Gowl:disjointWith component would require many pages of code. For this
rdf:resource=B#OutputPort[/> reason, we use QM as our running example throughout
G/owl:Class> this paper.
Gowl:Class rdf:about=B#Component[> In order to describe the QM component, our ontology
Gowl:disjointWith rdf:resource=B#Port[/> needs to have additional concepts. In particular, we need
G/owl:Class> the notion of BasicComponent specialized to various kinds
Gowl:ObjectProperty rdf:ID=BhasPort[> of basic components, like Adder, Multiplier, or Phase-
Grdfs:domain rdf:resource=B#Component[/> Shifter. For components that are not basic, we introduce
Grdfs:range rdf:resource=B#Port[/> the concept of Module. An extension of the ontology of
G/owl:ObjectProperty> Fig. 1 is shown in Fig. 4.
Gowl:ObjectProperty rdf:ID=BisConnectedTo[>
Grdfs:range rdf:resource=B#Port[/>
Grdfs:domain rdf:resource=B#Port[/>
G/owl:ObjectProperty>
Gowl:ObjectProperty rdf:ID=BhasInputPort[>
Grdfs:range rdf:resource=B#InputPort[/>
Grdfs:domain rdf:resource=B#Component[/>
Grdfs:subPropertyOf
rdf:resource=B#hasPort[/>
Gowl:ObjectProperty rdf:ID=BhasSubComponent[>
Grdfs:range rdf:resource=B#Component[/>
Grdfs:domain rdf:resource=B#Component[/>
Gowl:ObjectProperty rdf:ID=BhasOutputPort[>
Grdfs:subPropertyOf Fig 2. A simple component (quadrature modulator).

Fig 3. Example uses of QM in radio engineering.
The component shown in Fig. 2 consists of four basic representing the C input, is connected to the input port
components: one adder, one phase shifter, and two Mul1_Pin1 (input port of Multiplier 1) and PhSh1_Pin
multipliers. These components are captured as subclasses (input port of Phase Shifter). The rest of the connections
of BasicComponent of the ontology. QuadratureModulator can be traced in the similar way. A similar scenario,
has three ports for external input and one output port. although in the context of Web services, has been shown
Moreover, although this is not shown in the figure, each of in [12].
the basic components has at least one input port and an The main purpose of this exercise was to show that
output port of its own. individuals of classes of complex components can be
In Fig. 5, we show a graphical representation of a represented in OWL. This means that a CR node can
partial description of an individual of the Quadrature- describe its internal structure, i.e., the composition of
Modulator class. The arrows annotated with Fio_ stand for complex components (modules) can be represented. This
Bindividual of,[ i.e., the assertions that a given individual kind of capability may be very useful for the operation of the
belongs to a given class. For the sake of readability of the CR. However, under some circumstances, a more advanced
description, only some of the ports and the connections capability is required. To make this point more concrete,
among them are shown. As can be seen in this figure, the consider the following interoperability scenario [13].
ports include six individuals of InputPort and three The synthesis of more advanced concepts from the
individuals of OutputPort. The input port InputPC, facts in the base ontology is the foundation of the
Fig 4. A simple ontology: Subcomponents.

Fig 5. An individual of QM.
interoperability between cognitive radios. One of the uses might be a subclass of one of the classes in the upper
for this idea is achieving interoperability between CR ontology. Otherwise, Node A needs to explain to Node B
nodes at the specific protocol level. how to build such a component using the four basic
For example, one of the nodes (node A) might decide components. The straightforward way to do this is to send
that switching to a specific modulation scheme might the definition of class QuadratureModulator to Node B so
provide more optimized communication results in partic- that Node B can construct a structure that is an individual
ular circumstances. That node then sends a request to its of the class. In other words, Node B, after receiving the
peer (node B) to make a switch. If the peer Bknows[ the description of the QuadratureModulator class, would have
chosen modulation scheme, it might choose to comply to formally prove (using its own reasoner) that the
with the request or might decide to reject it. If it does not constructed structure (MyComponent) is an individual
Bknow[ the proposed modulation scheme, it might in (or type) of QuadratureModulator. Putting this in OWL
return send a query for an explanation of what exactly that terms, Node B would have to prove:
modulation scheme is. If the response to that query
contains concepts that are still not understood by the node, GModule rdf:ID=BMyComponent[>
it can continue querying for concepts all the way down to Grdf:type rdf:resource=B#QuadratureModulator[/>
those defined in the base ontology. While the scenario in G/Module>
which a node does not know a communication protocol
might be extreme, the assumption that a node knows Unfortunately, the expressive capabilities of OWL do not
everything would be at the other end of the spectrum. In allow for a representation of QuadratureModulator that
other words, assuming that communicating nodes, espe- would guarantee the correct decision. In other words, it is
cially CR nodes, know all the possible concepts about impossible to construct an OWL description that would
which they can exchange information would impose capture all components that are considered to be quadrature
extremely demanding (if achievable at all) requirements modulators and none of the components that are not
on the capabilities of cognitive radio. considered quadrature modulators. This is due to the fact
Continuing with our example, assume that Node A that OWL does not have a construct for expressing
requests Node B to use a QuadratureModulator but Node B composition of properties (relations). In this case, the
does not have such a module in its library. If the ontology is quadrature modulator has two multipliers. We can express in
built as an extension to an upper layer ontology (e.g., OWL the fact that a particular class (such as Quadrature-
SUMO,3 BFO,4 DOLCE,5 or GFO6) then Node B might be Modulator) is in a relationship with another class (such as
able to find at least some partial (more general) Multiplier) using a property (in our case, hasSubCompo-
information about the requested class since the class nent). Moreover, we can say that there are two individuals of
Multiplier in a quadrature modulator. We cannot, however,
distinguish the relationship with one of the multipliers from
3
http://www.ontologyportal.org/. the relationship with the other one, i.e., we can express in
4
http://www.ifomis.org/bfo.
5
http://www.loa-cnr.it/DOLCE.html. OWL the fact that the quadrature modulator is in the
6
http://www.onto-med.de/en/theories/gfo/index.html. relationship with InputPort, but it is impossible to

differentiate between the particular relationships for input formulas. Since variables are allowed in these formulas, we
ports I, Q, and C. The implication of this is that the definition can represent the composition of relations, e.g.,
of QuadratureModulator is not restrictive enough, i.e.,
various configurations will satisfy the definition for as long as
they have the necessary components. However, they will be uncleOfð?Z; ?YÞ : fatherOfð?X; ?YÞ; brotherð?X; ?ZÞ:
classified as individuals of this class even if they do not have
the correct connections. Returning to our example, by using rules (with
variables), the description of the QuadratureModulator
IV. RULES class can be made more precise. For instance, we could
reinforce the class definition by adding the predicate
The limitation of OWL described in the previous section hasQMConnections (F?_ as the first character in a name
can be resolved by extending the expressive power of OWL indicates that it is the name of a variable):
using other, more expressive languages and more powerful
reasoning mechanisms. The limitation of OWL described hasQMConnections(?QM) :-
above has been known in the semantic Web community as Module(?QM), hasSubComponent(?QM, ?M1),
the inability to define the Buncle[ relationship. In other type(?M1, Multiplier), hasInputPort(?M1, ?InPortM1),
words, it is impossible to express in OWL that an uncle is a hasInputPort(?QM, ?I), isConnected(?I, ?InPortM1), . . .,
person who is the brother of someone’s father. The main hasSubComponent(?QM, ?M2), not(?M1=?M2), . . .
issue here is that OWL does not have a way to capture the
Bwho is[ part of the above statement. In order to be able to This is not a complete rule. The intent here was to
do this, we would need the notion of variables that link two show how the following facts about a quadrature
different relations. In this example, we would need a modulator could be expressed using rules:
variable, say, ?X, which would represent the father, who 1) that a quadrature modulator has two different
would then have a child and a brother. This means OWL multipliers M1 and M2;
lacks the capability of expressing the composition of 2) that the input port I of the quadrature
relations. modulator is connected to the input port of
Other languages, e.g., Prolog [14]Vprobably the most M1 (but not to M2).
known declarative language (also classified as a logic The net result is that once the ontology is extended
programming language)Vallows logical statements that are with this kind of rule, the inference engine can verify that
Horn clauses. A Horn clause is a disjunction of literals in all the necessary connections are in place and thus that a
which at most one literal is positive. A definite Horn clause given structure is in fact a quadrature modulator. In our
has exactly one positive literal and thus is of the form experiments, we used BaseVISor [15], an engine that can
perform inference both with a subset of OWL axioms (so
:A1 _ :A2 _ . . . _ :An _ B: called BR-entailment[ [16]) and over rules. The need to
extend the expressivity of OWL by adding rules has also
been recognized in [17]–[19], where both OWL and rules
This can be rewritten in an equivalent form as an were used to express spectrum access policies. In these
implication (also often referred to as a rule) experiments, Jena7 was used as an inference engine for
reasoning over both the ontology and the rules.
A1 ^ A2 ^ . . . : ^ An ) B: A. Negation
While rules can make definitions of classes and
The symbols used in these two formulas represent properties more precise, there is yet another aspect that
negation ð:Þ, logical OR operation ð_Þ, logical AND needs to be understood in order to avoid errors. This is the
operation ð^Þ, and logical implication ð)Þ. In operational issue of various types of negation.
terms, this rule states that whenever A1 ; A2 ; . . . ; An hold, OWL is based on the open world assumption model in
so does B. Using Prolog notation, this formula can be which facts that have not been explicitly asserted to be true
represented as are not presumed to be false; they are simply unknown.
Negative facts, in this approach, have to be explicitly
proven. In other words, both the positive and the negative
B : A1 ; A2 ; . . . :; An : facts are treated in the same fashion (symmetrically). In
this approach, facts that have already been proven to be
true (or false) remain true (or false, respectively)
In this notation, the implication arrow is represented as
B:-[ while B,[ represents the logical AND. The literals can
7
be either propositional variables or first-order logic atomic http://jena.sourceforge.net/.

independently of new facts that might become part of an except those explicitly stated. For example, consider one of
existing base of facts. Only the facts whose truth values the input ports (port I) on the quadrature modulator
were unknown can be modified to either true or false. Due shown in Fig. 2. The description of the QuadratureModu-
to this incremental nature of inference, the reasoning in lator component must express the fact that an individual of
this kind of systems is called monotonic. Negation in this InputPort is connected to exactly one multiplier. We can
approach is referred to as logical negation. capture this by two rules that define the isExclusive-
Some of the rule languages, on the other hand, take a InputPortOf(?P,?C) and isNonExclusiveInputPortOf(?P,?C)
different approach called the closed world assumption (CWA). predicates
In this approach, if a fact cannot be proven to be true, it is
taken to be false. In case new facts arrive, the inference
isExclusiveInputPortOf(?P,?C) : inputPortOf(?P,?C);
system must modify its conclusions, i.e., modify the truth
values of some of the facts. Reasoning in this kind of systems not(isNonExclusiveInputPortOf(?P,?C)).
is called nonmonotonic. Perhaps the most known example of
this kind of reasoning is seen in databases, where if a fact is isNonExclusiveInputPortOf(?P,?C) :
not in the database, it is assumed to be false. For example, if a
inputPortOf(?P,?C); inputPortOf(?P,?D); not(?C ¼ ?D):
flight is not listed in an airline’s database, it is inferred that it
does not exist. This is consistent with the nameVthe world
is assumed to be closed, i.e., all that is relevant about it is in The predicate isNonExclusiveInputPortOf is asserted
the database. Negation in this approach is referred to as when a given input port is in the inputPortOf relationship
negation as failure (NAF). with more than one individual. The complementary
Both kinds of negationVNAF and logicalVare useful predicate isExclusiveInputPortOf can evaluate to true if
in modeling real-life problems [20]. If we admit only one isNonExclusiveInputPortOf is false. In the open world
type of negation in a formal language, we can have model, we could not make such a deduction because failure
difficulty modeling various situations and reasoning about to prove something does not imply the opposite. In the open
them using automatic inference engines. For instance, if world, the failure to prove this might be the consequence of
we accept only logical negation, we will not be able to infer the lack of complete knowledge about the connections
many of the negative facts that, by default, are known to within this particular component. Thus, in this example, we
hold. For instance, if a CR has policies that tell it under had to assume the closed world model. Consequently, the
what circumstances it can transmit, it will not be able to Bnot[ predicate in the body of the rule is a case of NAF. If
infer that it cannot transmit in case any of these more information about this port becomes available at a later
circumstances do not hold. But, on the other hand, if we time, the derived fact (that the port is an exclusive port) may
accept the CWA, then all the facts that are not currently in be negated, leading to an inconsistency (both the fact that
the database of the CR’s facts will be inferred to be false. the port is exclusive and is not exclusive in the same
For instance, under CWA, the CR will infer that the node it knowledge base). The reasoner must ensure that such a
is communicating with does not have a quadrature situation does not take place. One way to avoid this is to
modulator component (unless it has an explicit statement monitor for such nonmonotonic changes and remove the
in its knowledge base that it doesVand it is rather unlikely facts that have been derived through the use of NAF.
that a node would have complete knowledge about all the It is also worth noting that OWL provides the capability
nodes it communicates with). to state that a given class is Bclosed,[ i.e., that a class includes
So what is a way out of this impasse? Since both logical only a given collection of individuals. This is termed as the
negation and NAF are needed and since the combination Bclosed domain reasoning[ [21], which is not the same as the
of OWL and rules are necessary to provide more expressive closed world reasoning. In the closed domain reasoning we
power for modeling real-life problems, there is a need for a make assumptions about the domain and in the closed world
language that combines the features of both OWL and reasoning we make assumptions about our knowledge about
rules with a semantics that provides the meaning to both the domain. In the above example, we assumed that we knew
types of negation. Such a necessity has been recognized by everything about the connections within that component,
the semantic Web community, and research efforts are i.e., we were making an assumption about the complete-
under way to achieve such a goal (see [21]). In the ness of our knowledge about the domain.
meantime, the burden of avoiding logical inconsistencies
while modeling real-life problems is put on the developers
of ontologies, rules, and inference engines. V. FUNCTIONS
An example of this problem in the CR domain is the Augmenting OWL with a rule language enables cognitive
description of structure of radio components. A complete radio nodes to exchange information, for instance, about
knowledge of a component must include both what the structure of their components (class descriptions). In
subcomponents it has and how they are connected with general, nodes can exchange information about concepts
each other, as well as that there are no other connections that are not explicitly defined in an ontology but can be

expressed using OWL and terms from the ontology. For

instance, a node can query other nodes about the structure
of unknown components and then use this knowledge for
reconstructing components locally. Moreover, nodes can
use an automatic reasoner to prove that the component it
created locally is indeed the individual of the class
described in the recipe received from the remote node.
The knowledge of the structure of components,
however, is insufficient for some reasoning tasks that
involve components [22].
• Software components that are structurally differ-
ent may be equivalent in terms of their func-
tionality. For example, a software component
implementing the function f ða; b; c; dÞ according
to the scheme f ða; b; c; dÞ ¼ ða þ bÞðc þ dÞ is func- Fig 6. A composite module functionality equivalent to QM in Fig. 2.
tionally equivalent to the module implementing
the function f 0 according to the scheme
f 0 ðx; y; v; uÞ ¼ ðxv þ xu þ yv þ yuÞ, in spite of the functions, they do not provide quantification over func-
fact that their respective internal structures are tions and do not provide capabilities of expressing
different. An example of such a situation was equivalence of functions. In order to address those issues,
shown in Fig. 3, where the classical QAM modu- a more expressive language has to be selected.
lator followed by a power amplifier is equivalent to Quantification over functions takes us into the realm
the polar-loop QAM modulator. Obviously, since of second-order logic [23], which in turn is extended by
those two circuits work using different principles, higher order logic [24]. It is interesting to notice that higher
their structures and functional subcomponents are order logic has been used in hardware verification (see
different. [25]). While functions are at least partially covered by a
• The same functionality using two different data number of declarative languages, for our discussion we
types is seen as two different structures, as the choose a higher order logic language Metaslang, the
structure-based approach does not allow for language supported by the Specware tool [26]. The main
easy abstraction of the functionality from the reason for the selection of this language was that it
data type. supports composition, using constructs of category theory
• The structure-based approach does not allow for like morphism and colimit [27]. Specware also integrates
an easy Bunderstanding[ of the functionality, two theorem provers (Snark [28] and Isabelle [29]) that
which might lead to implementation inefficien- can be used to prove conjectures on functional equiva-
cies. For example, a CR node receiving the de- lency of components. Since Metaslang is based on the
scription of the quadrature modulator (Fig. 2) principles of category theory, it seems to be a good
expressed in terms of a base ontology and rules candidate for linking multiple languages and multiple
might not be able to realize that an alternative, inference engines into a formal hybrid inference system.
more efficient implementation of such structure The category theory concept of colimit is applied to the
might exist, e.g., one that uses a specialized category of specifications (also referred to as Spec) to
Multiply-Add hardware unit that is available for compose specifications that are related through specifica-
the node (see Fig. 6). tion morphisms [30]. Pavlovic and Smith [30] define spe-
All of these shortcomings support the requirement that cification as a finite presentation of a theory. The signature
the modeling language for cognitive radio should be of a specification defines concepts that describe indivi-
capable of describing the Bfunctionality[ of components. duals, operations, and properties in some domain. The
In formal terms, this means that the language should axioms included in the specification put constraints on the
support functions. Unfortunately, OWL has a very limited meaning of symbols.
capability in this respect. While it is possible to declare In order to show how functionality can be expressed in
properties that are functional, it is not possible to quantify Metaslang and then reasoned about within the Specware
over functions. It is possible to state that two or more framework, we first need to introduce some basic elements
properties are equivalent properties, but OWL does not and concepts of the language. Additionally, we show how
provide any mechanism that would enable inferring that the composition of specifications works in Metaslang.
two functions, like those listed in the examples above, are Moreover, we show how the same abstract specification
equivalent. Although rule languages can provide defini- can be easily refined to concrete specifications, i.e., how
tions of functions, they still do not resolve the above issues. the specification of Samples can be refined to either real or
Although rules can provide definitions of particular complex samples.

The following code presents an example of two simple morphism BinRel -> PreOrder {},
specifications. e2: n1->n3 +->
m_BinRel_Antisymmetry
BinRel = spec }
type E
op le: EE -> Boolean This diagram has three nodes ðn1; n2; n3Þ representing
endspec three specs (BinRel, PreOrder, and Antisymmetry, respec-
tively) and two edges e1 and e2. Note that since PreOrder
PreOrder = spec imports BinRel (in other words, BinRel is a part of
import BinRel PreOrder), the morphism from BinRel to PreOrder is a
trivial one.
axiom reflexivity is Specware can produce the colimit of the specifications
fa(x) x le x on the diagram. For example, PartialOrder can be defined
as a colimit of BinRelDiag.
axiom transitivity is
fa(x,y,z) PartialOrder = colimit BinRelDiag
(x le y) && (y le z) = > (x le z)
endspec An inspection of the resulting specification is shown
below. As we can see, the PartialOreder spec Bproduced[ by
BinRel is an abstract specification defining an abstract the colimit operation includes all of the axioms of the specs
type E and a binary operation le. used in this composition.
Those two elements are specified but not defined.
PreOrder is a refinement of the first specification and it spec PartialOrder
adds two axioms that constrain the functionality of the type {X, E}
op le. Specification morphisms map one specification into op {binOp, le}: X X -> Boolean
another in such a way that all theorems from the source import translate (BinRel) by
specification are preserved in the target. {type E +-> {X, E, E}, op le +-> le}
axiom reflexivity is fa(x:E) x le x = true
Antisymmetry = spec axiom transitivity is fa(x:E, y:E, z:E)
type X x le y && y le z = > x le z
op binOp: XX -> Boolean axiom antisymmetry is fa(x:X, y:X) binOp(x, y) &&
axiom antisymmetry is fa(x,y) binOp(y, x) = > x = y
binOp(x,y) && binOp(y,x) = > x = y endspec
endspec
One of the shortcomings of the structure-based
m_BinRel_Antisymmetry = interoperability scenarioVthe difficulty of separating the
morphism BinRel-> Antisymmetry functionality from the underlying data typeVcan easily be
{E +-> X, le +-> binOp} solved in Specware through the use of specification
refinements. For example, a Multiply-Add unit processing
In the above example, the morphism m_BinRel_Anti- real samples represented by single precision floating-point
symmetry maps BinRel into Antisymmetry. It maps type E numbers will be composed quite differently than a unit
of BinRel into type X of Antisymmetry and the op le into processing pairs of integers representing complex samples.
binOp. There is, however, some commonality between those two
A directed graph formed from specifications (nodes) functional units that could and should be captured at some
and morphisms (edges) is called a specification diagram. abstract functionality level. There are two benefits related
The three example specifications create the following to thatVfirst, the common functionality is represented
diagram. only once, so we avoid the inefficiency related to
representing and maintaining the same functionality
BinRelDiag = diagram { twice. The second, even bigger benefit is that Specware
n1 +-> is aware of the fact that those two different modules at
BinRel, some abstract level are the same and that this knowledge
n2 +-> can be used in refinements and proofs of theorems.
PreOrder, In the example shown below, an abstract specification
n3 +-> Samples is refined into two concrete specifications
Antisymmetry, IntSamples and CplxIntSamples (for real and complex
e1: n1->n2 +-> samples, respectively). Any software module using Samples

can easily be refined into a module using real samples or complex-valued samples. It also expands the Samples spec
complex samples. First we show the specification Samples. by the operation conj standing for Bcomplex conjugate,[
It first introduces the type Sample and NonZeroSample,
including the constants zero and one. Then it shows the CplxIntSamples = spec
signatures of the operations add, multiply, and minus. import Samples
Lastly, it presents some of the axioms that define these type Sample = {re:Integer, im:Integer}
three operations. def Sample.zero = {re ¼ 0, im ¼ 0}
def Sample.one = {re ¼ 1, im ¼ 0}
Samples = spec def Sample.multiply(x,y) =
type Sample {re ¼ ðx:re y:re x:im y:imÞ
type NonZeroSample = (Sample j nonzero?) im ¼ ðx:re y:im þ x:im y:reÞ}
def Sample.add(x,y) =
op Sample.zero: Sample {re ¼ ðx:re þ y:reÞ, im ¼ ðx:im þ y:imÞ}
op Sample.one: Sample def Sample.minus(x) =
{re ¼ x:re, im ¼ x:im}
op Sample.nonzero?: Sample->Boolean
def Sample.nonzero?(x) = x ¼ Sample:zero op Sample.conj: Sample -> Sample
def Sample.conj(x) =
op Sample.multiply: SampleSample->Sample {re ¼ x:re, im ¼ x:im}
op Sample.add: SampleSample->Sample endspec
op Sample.minus: Sample->Sample
In the code fragment below Adder_Int and Adder_
axiom Sample_mul_ax is CplxInt are refinements of Adder with concrete data
fa(a:Sample, b:Sample) types IntSamples and CplxIntSamples, respectively. Those
Sample.multiply(a,b) = specs are the result of specification substitution oper-
Sample.multiply(b,a) ation (square brackets), which is a simplified form of
axiom Sample.add_ax is colimit.
fa(a:Sample, b:Sample)
Sample.add(a,b) = Sample.add(b,a) MorphInt =
axiom Sample.mul_add_ax is morphism Samples -> IntSamples { }
fa(a:Sample, b:Sample, c:Sample)
Sample.multiply(a, Sample.add(b,c)) = MorphCplxInt =
Sample.add(Sample.multiply(a,b), morphism Samples -> CplxIntSamples { }
Sample.multiply(a,c))
endspec Adder = spec
import SampleSpec#Samples
Below, we show the specification of samples that take op Adder.Func: SampleSample -> Sample
integer values. It imports the Samples spec and then def Adder.Func(x,y) = Sample.add(x,y)
defines the constants zero and one as integer values of 0 endspec
and 1, respectively. Moreover, it identifies the operations
of add, multiply, and minus with their counterparts in the Adder_Int = Adder[MorphInt]
Integer type. Adder_CplxInt = Adder[MorphCplxInt]
IntSamples = spec The use of a theorem prover in Specware, together

import Samples with the fact that all transformations between specifica-
type Sample = Integer tions are formalized in Metaslang, makes it possible to
prove the equivalence of the functionality of two software
def Sample.zero = 0 modules. In the following example, the specification
def Sample.one = 1 QuadratureMod is expressed with elements from the base
def Sample.multiply(x,y) = x y ontology. The receiving CR node composes the specifi-
def Sample.add(x,y) = x+y cation Quad2, which uses a composite module MAC, not
def Sample.minus(x) = -x present in the base ontology. The reasoner is able to
endspec prove (see conjecture Quad2_conj below) that the func-
tion Quad2.Func used by the receiving CR node is equiv-
The CplxIntSamples spec shown below defines the alent to function QuadratureMod.Func in the original
meaning of the constants and operations for the type of specification.

QuadratureMod = spec order logic cannot be reduced to first order, the practical
import CplxIntSamples implications of this fact on the use of CL in cognitive radio
op QuadratureMod.Func: could be posed as an experimental question. In this paper,
SampleSampleSample -> Sample we do not delve into this issue but instead use a higher
def QuadratureMod.Func(I,Q,C) = order language. The most important reason for this
Sample.add(Sample.multiply(I, C), selection is Metaslang’s ability to represent in a very
Sample.multiply(Sample.conj(C),Q)) compact and elegant way the composition of logical
endspec theories (specs), as was shown in this section.
MAC = spec
import CplxIntSamples VI . BEHAVI ORAL ASPECTS
import Adder_CplxInt Metaslang is a functional language and, like other
import Multiplier_CplxInt functional languages (e.g., Haskell), does not easily
support the so-called side effects. In the functional
op MAC.Func: SampleSampleSample -> Sample programming paradigm, the result of application of a
def MAC.Func(m1,m2,a) = function always depends only on the input parameters. It
Adder.Func(Multiplier.Func(m1,m2),a) cannot depend on the previous results of that or any other
endspec function(s). This is a serious limitation in case it is to be
used to model behavioral aspects of systems, where the
Quad2 = spec results of computation depend on the state of the system,
import CplxIntSamples like in dynamical systems [34]. This limitation long has
import Adder_CplxInt been recognized and, as a result the concept of monads
import Multiplier_CplxInt [35], has been used to address this problem. The main idea
import PhShifter90Deg here is to use the monad concept to capture and pass some
import MAC state information of a computation among functions. Even
import QuadratureMod though monads can be useful for dealing with a limited set
of states within a context of a functional program, their use
op Quad2.Func: SampleSampleSample -> Sample to simulate memory elements and/or globally scoped
def Quad2.Func(I,Q,C) = variables, as is required in the context of software defined
MAC.Func(I, C, Multiplier.Func( radio, introduces additional overhead that normally does
PhShifter90Deg.Func(C), Q)) not exist in imperative languages.
Functional languages also do not provide any obvious
conjecture Quad2_conj is way to express and reason about time-dependent informa-
fa(I:Sample, Q:Sample, C:Sample) tion. In logical terms, this refers to relating the truth of
Quad2.Func(I,Q,C) = formulas at distinct time points. The simplest example of
QuadratureMod.Func(I,Q,C) this kind of a need in the domain of cognitive radio is the
endspec need to reason about delays introduced by the various
processing components. For instance, in the discrete time
Quad2_p0 = prove Quad2_conj in Quad2 options domain, we can say that a unit delay means that if the value
B(use-resolution t) (use-paramodulation t)[ of a signal for the time index t is sðtÞ ¼ a, the value of
another signal s0 related to s by the delay operation, for the
The main point of the above discussion was to show an (next) time index t þ 1, will be exactly a, i.e., s0 ðt þ 1Þ ¼ a.
example of the capability of reasoning about functions. We can say that delay means if the sentence sðtÞ ¼ a is
While we chose to use Meataslang, this goal could be true, then the sentence s0 ðt þ 1Þ ¼ a is also true. Note that
achieved in a number of different declarative languages. the intent here is to say that such a relationship between
One of the possible candidates is Common Logic (CL), two time-dependent sentences should hold for all time
which recently has become a standard of ISO/IEC [31]. instants t 2 T. Thus we want to express such facts without
According to [31], CL is a first-order language that explicitly referring to the time index.
Bpermits Fhigher order_ constructions such as quantifica- Other examples of descriptions involving temporal
tion over classes or relations while preserving a first-order information are: signal should be held at a given level until
model theory, and a semantics which allows theories to some event happens; signal should have a given value after
describe intensional things such as classes or properties.[ an event happens; a given combination of values should
Thus CL is not a higher order language like Metaslang is, never happen; a given event should happen before or after
since its de facto expressivity is limited to first order; it is another event; a given relationship should always be
referred to sometimes as a Breified first-order logic[ [32], satisfied (here Balways[ refers to time); the signal should
[33]. While it is a known fact in mathematics that second- have a given value within a given interval of time.

Note that by chaining the various predicates indicated The automatic inference task would involve reasoning about
above (marked by italics), the descriptions of temporal composition specific to the communications domain.
relations can be arbitrarily complex. For instance, we can To exemplify this kind of domain-specific reasoning, in
state that the signal never drops to 0 before it stays at 1 this paper we focus only on one aspect of temporal
within a given time interval. We might also need to com- reasoning: the one that is captured by the X operator of
bine such sentences using the logical connectives, like logi- LTL. However, instead of implementing a temporal logic,
cal OR, logical AND, negation, implication, or equivalence. we follow the approach that is typical in engineering.
Moreover, the special predicates listed above may be Towards this aim, we formalize the concept of unit delay
logically related, e.g., a sentence involving some combina- and then prove properties of systems composed of
tion of the predicates may be logically equivalent to another components that include delays. In particular, unit delay
sentence involving another combination. For instance, the allows us to model the temporal behavior of a system in
sentence Bthe signal will eventually drop to zero[ is terms of clock intervals, which removes explicit time
equivalent to the sentence Bnot always the signal will be values from the system description.
one.[ This suggests that one can define a logic that involves In the example specs below, we first define the
a collection of special (temporal) predicates. For this, a function UnitDelay.Func whose domain and range is the
formal language should be defined and formal semantics type Sample. Then we state two commutativity axioms
should be established. The semantics would have to for this operation for functions of one and two arguments,
incorporate a specific model of time. Then inference can respectively. It means that the composition of a function f
be carried out within such logic by the means of automatic with the unit delay is equal to the unit delay composed with
inference engines, like in any similar formal system. f . Note that in this spec, we quantify over all functions with
The logics that deal with time-dependent inference are domain Sample and range SampleVthe feature that re-
called temporal logics. The most popular logic in this group quires that functions be covered by the language (as
is called linear temporal logic (LTL) [36]. As the name discussed in Section V). This specification of unit delay is
indicates, the structure of time in this logic is assumed to not complete; it captures only the properties of this concept
be linear (a linearly ordered set). LTL uses discrete time, that are necessary to prove the conjectures shown later.
i.e., it assumes that events in the system can happen only at
the discrete moments in time. LTL is particularly useful for UnitDelaySpec = spec
modeling behaviors of clock-driven systems, i.e., systems import Samples
in which progression of events is controlled by a clock
signal (either explicitlyVas in case of hardwareVor op UnitDelay.Func: Sample -> Sample
implicitlyVas in case of a computer program running on
a processor clocked with certain frequency). Thus LTL may axiom UnitDelay_commutativity is
be useful for the domain of cognitive radio. fa(f:(Sample->Sample), x:Sample)
The predicates in this logic include X’ (’ must hold at UnitDelay.Func(f(x)) =
the neXt time instant); G’ (’ must hold on the entire f(UnitDelay.Func(x))
subsequent time); F’ (’ will hold eventually, in the
future); U’ (’ holds at the current or a future position axiom UnitDelay_commutativity2 is
and has to hold until that position; at that position does fa(f:(SampleSample->Sample),
not have to hold any more); R’ (’ is true until the first x:Sample, y:Sample)
position in which is true, or forever if such a position UnitDelay.Func(f(x,y)) =
does not exist, i.e., releases ’). Only three of these f(UnitDelay.Func(x),
predicates are necessary. The rest can be expressed in UnitDelay.Func(y))
terms of the other three. endspec
LTL has found applications in the area of verification of
distributed and reactive systems [37], where properties of In Section V, we specified the Bideal[ Adder and
systems such as reachability, safety, and deadlock are proven Multiplier components, i.e., components without any
in a formal way. Two approaches used in this process are delay. Now we specify delays introduced by these two
deduction (theorem proving) and model checking. Since components. As we can see in the specs below, we state
deductive inference for this domain is undecidable, model that they introduce a one-step delay.
checking is used more often to verify that a property holds in
a given model [38]. But some use a combination of the two AdderDelay = spec
approaches; see, e.g., [39]. In this paper, we are not import UnitDelaySpec
discussing the verification scenario but instead assume that
verification would be done offline and only the resulting op Adder.Func: SampleSample -> Sample
properties (in terms of an underlying, shared ontology) def Adder.Func(x,y) =
would be communicated among the participating radios. UnitDelay.Func(Sample.add(x, y))

endspec express time dependencies between different components

of the system without introducing time explicitly. Sec-
MultiplierDelay = spec ondly, it also proves that one can use automatic inference
import UnitDelaySpec engines to reason about abstract specifications, i.e., speci-
fications of concepts, like classes. However, Metaslang
op Multiplier.Func: SampleSample -> Sample cannot be used to reason about individuals of such classes.
def Multiplier.Func(x,y) = For this purpose, some additional capabilities are needed.
UnitDelay.Func(Sample.multiply(x,y)) One of the efforts in this direction is the development of the
endspec system called Accord [40]. Accord is an extension of Spec-
ware currently being developed by the Kesterel Institute.
The specification MACSpec shown below describes the The motivation for extending Specware was the observa-
behavior of a component that implements the multiply-add tion that the modeling of state becomes very important as
functionality with a two-clock-cycle delay for each input the system architectures move towards distributed and
set (it is a typical behavior for a MAC unit implemented in embedded systems. Additional motivations were increased
field-programmable gate array). The second spec in the computational efficiency that can sometimes be achieved
exampleVCompositeMACSpecVdescribes a module being through imperative programming as well as more direct
a composition of three other modulesVAdder, Multiplier, connection to common programming languages [40].
and UnitDelay. That spec contains a conjecture (Composite- In Accord, the behavior is encapsulated in a module,
MAC_conj) that is used by the theorem prover [28] to which is an extension of Metaslang’s spec. Accord is
prove that functionalities of MACSpec and CompositeMAC- backwards compatible with Metaslang, and so every
Spec are equivalent. Metaslang spec can be directly embedded into an Accord
module. Accord is built on ideas of evolving specifications
MACSpec = spec (e-specs). Since a state can be seen as a data structure and a
import UnitDelaySpec state transition as a finite change to that structure, the
states and their transitions can be seen as specs and
op MAC.Func: SampleSampleSample -> Sample conditional spec morphisms, respectively. In Accord, the
def MAC.Func(m1, m2, a) = behavioral aspect of a module is encoded in one or more
UnitDelay.Func( procedures (proc). Each proc contains modes, which
Sample.add( encode abstract states. For each procedure, there is an
UnitDelay.Func( implicit entry mode (initial state) and an implicit exit
Sample.multiply(m1, m2)), mode (final state). Steps specify abstract transitions and are
UnitDelay.Func(a))) usually guarded by logic expressions. Accord implicitly
endspec defines steps to the initial mode and from the final mode to
the exit. Other imperative elements introduced in Accord
CompositeMACSpec = spec include global variables and signals (exceptions). Accord is
import AdderDelay still in a very early stage of development at this point.
import MultiplierDelay However, when it matures, it might become an attractive
import MACSpec option for implementing inference about declarative
programs that capture some aspects that are normally
op CompositeMAC.Func: best addressed in imperative programming.
SampleSampleSample -> Sample To close this section, we should mention the efforts to
def CompositeMAC.Func(m1, m2, a) = capture state information in languages like UML8 or SDL.
Adder.Func(Multiplier.Func(m1,m2), However, we do not devote much attention to these lan-
UnitDelay.Func(a)) guages since they do not have formal semantics. Conse-
quently, formal inference cannot be carried out over the
conjecture CompositeMAC_conj is specifications of systems expressed in these languages.
fa(m1:Sample, m2:Sample, a:Sample)
CompositeMAC.Func(m1, m2, a) =
MAC.Func(m1, m2, a) VI I. LANGUAGE STANDARDIZATION
endspec EFFORTS FOR THE COGNITIVE RADIO
DOMAI N
p0 = prove CompositeMAC_conj in CompositeMACSpec A call for the development of a language for wireless
options B(use-resolution t) (use-paramodulation t)[ systems was presented in [41], emphasizing the need to
The above example shows two things. First, by using an 8

http://www.omg.org/spec/UML/2.1.2/Superstructure/PDF/change-
abstract specification with a set of axioms, we are able to barred/.

exchange information among various stakeholders, such as granularity enabling structure-based composition similar
network operators, enterprise networks, system and to what was demonstrated in our experiments with OWL
component vendors, software vendors, regulatory agen- and BaseVISor rules described in Section IV. FDL’s
cies, and end users, and to provide means for the end-to- capabilities go beyond simple composition, as it incorpo-
end reconfigurability. The paper states: rates some time constraints such as time baseline (clock),
latency, time deadlines (max delay), bandwidth, etc.
In an end-to-end reconfigurable system, there are However FDL (as it stands now) is not a formal system.
various tasks that require interactions with different FDL is defined in terms of XML, where the domain-
components in the network, and that require such specific XML tags need to be interpreted by the
components to communicate with each other. Exam- programmers. Since FDL does not have a formal seman-
ple tasks relate to network configuration, device re- tics, it cannot be used by an inference engine for automatic
configuration (involving download of applications/ derivation of facts about FDL descriptions.
firmware), and network operation (provisioning new The SDRF has a working group (MLM Working
services, upgrades, roll out of new AIS’s, etc.). De- Group) whose charge is to develop the MLM [43]. The
pending on the nature of the specific task, network group has developed a number of use cases that explicate
elements need to be queried, controlled, modified and justify the need for a formal language in which various
and managed, at varying levels of detail. aspects of the life cycle of communication nodes, in-
cluding mobile, could be described and shared among the
To achieve such interoperability goals, a standardized nodes and the stakeholders. The next step after the use
language that allows for exchange of information is cases will be the development of ontologies relevant to the
needed. Two nodes can efficiently exchange information communication domain. The developed ontologies will be
if they have a common language. captured in various formalisms. The classes and the pro-
The need for a standard declarative language for the perties will be formalized in OWL, and rules will supple-
domain of CR has been recognized by a number of ment the OWL descriptions. Other formalisms, including
organizations. Below we mention three organizations and other formal languages and mathematics, will also be
their efforts: Functional Description Language (FDL) from considered.
the End-To-End-Reconfigurability ðE2 RÞ organization, The SDRF approach to the development of its language
Modeling Language for Mobility (MLM) from the is somewhat different from the E2 R effort in the sense
Software Defined Radio Forum (SDRF), and Policy that from the very beginning, the stress is on expressing
Language and Policy Architectures for Managing Cognitive everything in a formal declarative language with formal
Radio for Dynamic Spectrum Access Applications from semantics so that automatic inference can be carried out
SCC 41 1900.5, an IEEE standards organization. by inference engines.
FDL [42] is envisioned to be the language software The third effort that is directly relevant to the CR
defined radios would use to communicate functional domain is the effort by SCC 41 to develop a standard for a
description data among themselves. FDL is based on collection of languages for the dynamic spectrum access
XML and defines the functionality of the system as a domain. At the time of this writing, SSC 41 has created the
collection of processes linked together by communication IEEE 1900.5 Study Group on Policy Language for
channels. The descriptions in that language are platform- Managing Cognitive Radio and Dynamic Spectrum Access
independent and are interpreted by the Configuration Applications. The charge of this group is to define a family
Control Module (CCM) in terms of specific software and/ of interrelated languages that would serve the needs of the
or hardware solutions available locally. It is envisioned domain described above.
that when a CCM encounters a description that is not While it is not possible to predict, with a high degree of
locally available, the node would be able to access a confidence, whether these three efforts will converge and
centralized database and download the missing software will produce a unified language and a unified set of
module. ontologies for the CR domain, it is encouraging that the
FDL enables SDR software modules to be defined as three organizations behind these efforts have working
hierarchical flow of signals between processes communi- relationships and have already started interacting with the
cating via one-to-one and one-to-many channels. The top intent of unification and the integration of both the
level of the functional description is the algorithm element, ontologies and the languages.
which might include one or more processes. It also defines
how those processes communicate by defining sets of input
and output ports per process and then linking them to the VIII. CONCLUSION
channels. FDL supports hierarchy so processes can contain The main motivation for this paper was to identify various
subprocesses and subprocess ports can communicate with formal, declarative languages and their expressivity fea-
ports of the higher level. That provides the potential for tures that may be relevant and useful to the implemen-
describing the functionality at an arbitrary level of tation of the concept of cognitive radio. A running

Table 1 Summary of Languages and Features
example was selected, and then various features were dis- Consequently, we were not able to cover all of them, and
cussed in a progressive manner. The languages discussed it is not even possible to provide a complete list of the
in this paper and their expressivity features are summa- issues that have not been covered. Here we mention only
rized in Table 1. some of them.
First, we discussed the useful role ontologies expressed 1) OWL can express only binary predicates (proper-
in a formal language can play in cognitive radio. Then we ties). However, in practice, we need to use n-ary
showed that some of the aspects that may be needed for predicates, too. We did not discuss how to deal
cognitive radio are missing in OWL, and that a more with these.
expressive language would be needed to fill the need. In 2) Although we discussed the distinction between
particular, we showed that rules complement OWL and closed-world reasoning and open-world reason-
allow us to describe architectures of types of components. ing, we have not discussed the distinction
This was followed by the discussion of negation, a logical between closed-world querying of open-world
concept that seems to be very simple in principle but is knowledge bases versus closed-world reasoning.
very difficult to implement within one language that 3) We have not discussed the issue of expressing
includes both OWL and rules. The main issue is that the integrity constrains. This relates to the distinction
negation in OWL is the logical negation, while in rules it is between constraints on the modeled world (e.g.,
negation as failure. Since this problem has not been solved as expressed in OWL) versus constraints on the
as yet, the best we could do in this paper is to provide the knowledge base.
background information and then indicate some directions 4) We only barely touched upon the issue of
of possible partial solutions. The next step was to show that nonmonotonic reasoning.
reasoning about the functionality of various components 5) We have not discussed query languages.
requires functions to be first-class objects in the formal 6) We have not discussed in any detail a very
language. We showed an example of proof that structurally important aspectVthe computational complexity
different components can be functionally equivalent. We of inference within particular languages. In
discussed the problems of representing and reasoning particular, we have not discussed the issue of
about behavioral aspects of components. The issue is that running an inference engine on limited comput-
most formal languages are functional, i.e., each func- ing resources of a CR.
tion’s value depends only on the inputs, while represen- In the last section of this paper, we provided references
tation of behavior requires memoryVresults of previous to three ongoing efforts to the standardization of languages
computationsVand dealing with temporal aspects. Dyna- relevant to the cognitive radio domain. We believe these
mical systems are one class of behavioral systems. We efforts will address the problems we identified in this
provided a brief overview of the use of linear temporal paper and identify solutions to some of them. h
logic to represent behaviors. Then we focused on one as-
pect of temporal behaviorVthe delay. We showed that
automatic inference about behavioral aspects can be Acknowledgment
carried out using inference engines. Interactions with P. Marshall, D. Hillman and
The range of issues related to the use of formal G. Denker have provided valuable input to this work.
languages for cognitive radio is probably unbounded. Moreover, collaboration with the Software Defined Radio

Forum, especially with M. Cummings and B. Fette, their deep gratitude to the anonymous reviewers who have
provided valuable information on the understanding of provided many very insightful comments that have
the applicability of formal declarative languages in the improved the completeness, consistency, and readability
cognitive radio domain. The authors would like to express of the presentation.
REFERENCES complexity,[ in Proc. 4th Int. Semantic Web [29] T. Nipkow, L. C. Paulson, and M. Wenzel,
Conf. (ISWC 2005), 2005, vol. 3729, Isabelle/HOL: A Proof Assistant for Higher-Order
[1] J. Mitola, III, BCognitive radio: An integrated pp. 668–684. Logic. New York: Springer, 2002, vol. 2283.
agent architecture for software defined radi,[
Ph.D. dissertation, Royal Institute of [17] J. D. Poston, W. D. Horne, M. G. Taylor, and [30] D. Pavlovic and D. R. Smith, BSoftware
Technology (KTH), Stockholm, Sweden, F. Z. Zhu, BOntology-based reasoning for development by refinement,[ in Proc. 10th
2000. context-aware radios: Insights and findings Anniv. Colloq. Formal Methods Crossroads: From
from prototype development,[ in Proc. 1st Panacea to Foundational Support (UNU/IIST),
[2] J. Mitola, III and G. Q. Maguire, Jr., IEEE Int. Symp. New Frontiers Dyn. Spectrum 2003.
BCognitive radio: Making software radios Access Netw. (DySPAN), 2005, pp. 634–637.
more personal,[ IEEE Wireless Commun., [31] Information TechnologyVCommon Logic
vol. 6, pp. 13–18, Aug. 1999. [18] A. Ginsberg, J. D. Poston, and W. D. Horne, (CL): A Framework for a Family of
BExperiments in cognitive radio and dynamic Logic-Based Languages, ISO/IEC Standard
[3] Software Defined Radio Forum, BCognitive spectrum access using an ontology-rule hybrid 24707, 2007.
radio definitions,[ Working Doc. architecture,[ in Proc. 2nd Int. Conf. Rules Rule
SDRF-06-R-0011-V1.0.0, Nov. 8, 2007. [32] C. Bock, M. Gruninger, D. Libes, J. Lubell,
Markup Lang. Semantic Web (RuleML), and E. Subrahmanian, BEvaluating reasoning
[4] M. M. Kokar, D. Brady, and K. Baclawski, Athens, GA, 2006. [Online]. Available: http:// systems,[ National Inst. of Standards and
BChapter 13: Roles of ontologies in cognitive 2006.ruleml.org/group3.html#3. Technology, Tech. Rep. NISTIR 7310, 2006.
radios,[ in Cognitive Radio Technology, [19] A. Ginsberg, W. Horne, and J. Poston,
B. Fette, Ed. Oxford, U.K.: Newnes, 2006, [33] P. Hayes and C. Menzel, BSimple common
BCommunity-based cognitive radio logic,[ in Proc. Workshop Rule Lang. Interop.
pp. 401–433. architecture: Policy-compliant innovation via (W3C), Washington, D.C., 2005. [Online].
[5] T. W. Pratt and M. V. Zelkowitz, Programming the semantic web,[ in Proc. 2nd IEEE Int. Available: http://www.w3.org/2004/12/rules-
Languages: Design and Implementation, 3rd ed. Symp. New Frontiers Dyn. Spectrum Access ws/paper/103/.
Englewood Cliffs, NJ: Prentice-Hall, 1996. Netw. (DySPAN), 2007.
[34] L. Padulo and M. A. Arbib, System Theory:
[6] J. W. Lloyd, BPractical advantages of [20] M. Kifer, Negation in knowledge representation, A Unified State-Space Approach to Continuous
declarative programming,[ in Proc. 1994 Joint unpublished notes, Jun. 9, 2007 and Discrete Systems. Philadelphia, PA:
Conf. Declarative Program (GULP-PRODE’94), [21] B. Motik, I. Horrocks, R. Rosati, and Saunders, 1974.
Peñiscola, Spain, 1994. U. Sattler, BCan OWL and logic programming [35] P. Wadler, BComprehending monads,’’
[7] P. Haase, F. van Harmelen, Z. Huang, live together happily ever after?[ in Proc. 5th in Proc. 1990 ACM Conf. LISP Funct. Program.,
H. Stuckenschmidt, and Y. Sure, BA Int. Semantic Web Conf., 2006, vol. 4273, Nice, 1990.
framework for handling inconsistency pp. 501–514.
in changing ontologies,[ in Proc. 4th [36] Z. Manna and A. Pnueli, The Temporal Logic
[22] L. Lechowicz and M. M. Kokar, of Reactive and Concurrent Systems:
Int. Semantic Web Conf., 2005. [Online]. BComposition, equivalence and
Available: http://www.cs.vu.nl/~frankh/ Specification. Berlin, Germany:
interoperability: An example,[ in Proc. Springer-Verlag, 1991.
abstracts/ISWC05.html. Software Defined Radio Tech. Conf. (SDR’07),
[8] H. Enderton, A Mathematical Introduction to [37] Z. Manna and A. Pnueli, Temporal Verification
2007.
Logic, 2nd ed. Boston, MA: Academic, 2001. of Reactive Systems: Safety. Berlin, Germany:
[23] S. Shapiro, Foundations Without Springer-Verlag, 1995.
[9] R. Corazzon. (2008). Ontology: A resource Foundationalism: A Case for Second-Order
guide for philosophers. [Online]. Available: [38] G. J. Holzmann, The Spin Model Checker:
Logic. Oxford, U.K.: Oxford Univ. Press,
http://www.formalontology.it/. Primer and Reference Manual. Reading, MA:
2000.
Addison-Wesley, 2004.
[10] T. Gruber, What is an ontology? [Online]. [24] C. E. Brown, Automated Reasoning in
Available: http://www-ksl.stanford.edu/kst/ [39] N. S. Bjørner, A. Browne, M. A. Colón,
Higher-Order Logic: Set Comprehension and
what-is-an-ontology.html. B. Finkbeiner, Z. Manna, H. B. Sipma, and
Extensionality in Church’s Type Theory.
T. E. Uribe, BVerifying temporal properties of
[11] J. G. Proakis, Digital Communications, 3rd ed. Oxford, U.K.: College Publications, 2007.
reactive systems: A STeP tutorial,[ Formal
New York: McGraw-Hill, 1995. [25] T. F. Melham, Higher-Order Logic and Methods Syst. Design, vol. 16, no. 3,
[12] D. Preuveneers and Y. Berbers, BAutomated Hardware Verification. Cambridge, U.K.: pp. 227–270, 2000.
context-driven composition of pervasive Cambridge Univ. Press, 1993.
[40] J. McDonald and D. R. Smith, Accord
services to alleviate non-functional concerns,[ [26] J. McDonald and J. Anton, Language Manual Version 4.2. Palo Alto, CA:
Int. J. Comput. Inf. Sci., vol. 3, no. 2, ‘‘SPECWAREVProducing software correct by Kestrel Institute, 2007.
pp. 19–28, Aug. 2005. construction,’’ Kestrel Inst., Tech. Rep. KES.
[41] M. Cummings and P. A. Subrahmanyam,
[13] L. Lechowicz and M. Kokar, BAchieving U.01.3., Mar. 2001.
BPerspectives of a metalanguage for
dynamic interoperability of communication: [27] D. R. Smith, BComposition by colimit and configurable wireless systems,[ in Proc.
Transfer of ontology and rules between formal software development,[ in Algebra, Software Defined Radio Tech. Conf. (SDR’04),
nodes,[ in Proc. Software Defined Radio Tech. Meaning, and Computation: A Festschrift in 2004.
Conf. (SDR’06), 2006. Honor of Prof. Joseph Goguen,
[42] C. Dolwin, R. Burgess, and B. Steinke,
[14] A. Colmerauer and P. Roussel, BThe birth of K. Futatsugi, J.-P. Jouannaud, and
BPower efficient and real-time configuration
prolog,[ in Proc. 2nd ACM Conf. History J. Meseguer, Eds. Berlin, Germany:
of resources in an end-to-end reconfigurable
Program. Lang. (SIGPLAN), 1992, pp. 37–52. Springer-Verlag, 2006, vol. 4060,
system,[ in Proc. Software Defined Radio
[15] C. Matheus, K. Baclawski, and M. M. Kokar, pp. 317–332.
Technical Conf. (SDR’05), Anaheim, CA,
BBaseVISor: A triples-based inference engine [28] M. E. Stickel, R. J. Waldinger, M. Lowry, 2005.
outfitted to process RuleML and R-entailment T. Pressburger, and I. Underwood,
[43] B. Fette, M. M. Kokar, and M. Cummings,
rules,[ in Proc. 2nd Int. Conf. Rules Rule Lang. BDeductive composition of astronomical
BNext-generation design issues in
Semantic Web, Athens, GA, Nov. 2006. software from subroutine libraries,[ in Proc.
communications,[ Portable Design Mag.,
[16] H. ter Horst, BCombining RDF and part of 12th Int. Conf. Autom. Deduct. (CADE-12),
no. 3, pp. 20–24, 2008.
OWL with rules: Semantics, decidability, Nancy, France, Jun. 1994, pp. 341–355.

ABOUT THE AUTHORS

Mieczyslaw M. Kokar (Senior Member, IEEE) Leszek Lechowicz (Member, IEEE) received the
received the M.S. and Ph.D. degrees in computer M.S. degree in electrical engineering and in com-
and system engineering from Wroclaw University puter science from Gdansk University of Technol-
of Technology, Wroclaw, Poland, in 1969 and 1973, ogy, Poland, in 1994 and 1996, respectively. He is a
respectively. doctoral candidate in the Department of Electrical
He is an Associate Professor in the Depart- and Computer Engineering, Northeastern Univer-
ment of Electrical and Computer Engineering, sity, Boston, MA.
Northeastern University, Boston, MA. His technical His research interests include software defined
research interests include information fusion, radio, self-controlling software, and the applica-
ontology-based information processing, software tion of formal methods in software engineering.
defined radio, self-controlling software, modeling languages, and formal He is a System Architect with Asterion Inc., Marlboro, MA. His previous
methods. He teaches various graduate courses in software engineering, professional experience includes variety of technical positions with
formal methods, and artificial intelligence. He is the author of numerous automated test equipment and networking companies.
publications in his areas of interest. He is a Cochair of the Software Mr. Lechowicz is a member of the IEEE Computer Society and ACM.
Defined Radio Forum Work Group on Modeling Language for Mobility.
Dr. Kokar is a member of ACM. He is a member of the IEEE 1900.5
Working Group on Policy Language and Policy Architectures for
Managing Cognitive Radio for Dynamic Spectrum Access Applications.

Authorized
View publication stats licensed use limited to: Northeastern University. Downloaded on July 26, 2009 at 11:49 from IEEE Xplore. Restrictions apply.

Language Issues For Cognitive Radio: Proceedings of The IEEE May 2009

Uploaded by

Copyright:

Available Formats

Language Issues For Cognitive Radio: Proceedings of The IEEE May 2009

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Language Issues For Cognitive Radio: Proceedings of The IEEE May 2009

Uploaded by

Copyright:

Available Formats

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Language Issues for Cognitive Radio

Article in Proceedings of the IEEE · May 2009

Mieczyslaw M. Kokar Leszek Lechowicz

SEE PROFILE SEE PROFILE

Semantics View project

VIStology Social Media Analytics View project

The user has requested enhancement of the downloaded file.

Language Issues for

690 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 691

III . ONTOLOGIES AND OWL

692 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

with specifications of domains and ranges of all the rdf:resource=B#hasPort[/>

G?xml version=B1.0[?> To illustrate the use of OWL in the software radio

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 693

Fig 3. Example uses of QM in radio engineering.

Fig 4. A simple ontology: Subcomponents.

694 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

Fig 5. An individual of QM.

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 695

696 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 697

expressed using OWL and terms from the ontology. For

698 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 699

IntSamples = spec The use of a theorem prover in Specware, together

700 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 701

702 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

endspec express time dependencies between different components

The above example shows two things. First, by using an 8

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 703

704 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

Table 1 Summary of Languages and Features

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 705

706 Proceedings of the IEEE | Vol. 97, No. 4, April 2009

ABOUT THE AUTHORS

Vol. 97, No. 4, April 2009 | Proceedings of the IEEE 707

You might also like