[PlanetKR] IJCAR 2012 -- First Call for Papers

Fri Sep 23 20:17:47 EST 2011

			Call For Papers --- IJCAR 2012
	  6th International Joint Conference on Automated Reasoning
		       Manchester, UK, June 26 - July1st, 2012
		      http://ijcar.cs.manchester.ac.uk/

Important Dates (all in 2012)
  Abstract submission  January 23       Final version due    April 16
  Paper submission      January 30       Conference dates   June 26-29
  Notification                  March 26           Satellite  
events       June 30-July 1

IJCAR is the premier international joint conference on all topics in  
automated
reasoning. IJCAR 2012, the 6th International Joint Conference on  
Automated
Reasoning, is a merger of leading events in automated reasoning: CADE
(International Conference on Automated Deduction), FroCoS (International
Symposium on Frontiers of Combining Systems), FTP (International  
Workshop on
First-order Theorem Proving), and TABLEAUX (International Conference on
Automated Reasoning with Analytic Tableaux and Related Methods).  
Previous
editions of IJCAR took place in Siena (2001), Cork (2004), Seattle  
(2006),
Sydney (2008) and Edinburgh (2010), cf. http:/ /www.ijcar.org/.

IJCAR 2012 is held as part of the Alan Turing Year 2012 just after The  
Alan
Turing Centenary Conference in Manchester.

Scope: IJCAR 2012 invites submissions related to all aspects of  
automated
reasoning, including foundations, implementations, and applications.  
Original
research papers and descriptions of working automated deduction  
systems are
solicited.

Logics of interest include: propositional, first-order, classical,  
equational,
higher-order, non-classical, constructive, modal, temporal, many-valued,
substructural, description, metalogics, type theory, and set theory.   
Methods
of interest include: tableaux, sequent calculi, resolution, model-
elimination, connection method, inverse method, paramodulation, term
rewriting, induction, unification, constraint solving, decision  
procedures,
model generation, model checking, semantic guidance, interactive theorem
proving, logical frameworks, AI-related methods for deductive systems,  
proof
presentation, efficient datastructures and indexing, integration of  
computer
algebra systems and automated theorem provers, and combination of  
logics or
decision procedures.

Applications of interest include: verification, formal methods, program
analysis and synthesis, computer mathematics, declarative programming,
deductive databases, knowledge representation, natural language  
processing,
linguistics, robotics, and planning.

Submission: Submission is electronic through
	      https://www.easychair.org/?conf=ijcar2012.
Authors are strongly encouraged to use LaTeX and the Springer llncs  
class
file, which can be obtained from
http://www.springer.de/comp/lncs/authors.html.  The page limit is 15  
pages for
full papers and 7 pages for system descriptions.  All papers will be  
evaluated
according to originality, significance, technical quality, and
readability. Submitted papers must be original and not submitted for
publication elsewhere. For more details concerning submission see the
conference web site. The proceedings of IJCAR 2012 will be published by
Springer-Verlag in the LNAI/LNCS series.

Student Travel Awards: Travel awards will be available to enable  
selected
students to attend the conference. Details will be available in early  
2012.

Further Information: For further and up-to-date information about  
IJCAR 2012
visit http://ijcar.cs.manchester.ac.uk/.

Program Chairs:
  Bernhard Gramlich (TU Wien)
  Dale Miller (INRIA Saclay -- Ile-de-France)
  Ulrike Sattler (Univ. of Manchester)

COMP60432	Building Web Applications
COMP60421	Ontology Engineering for the Semantic Web
COMP60411	Semi-structured Data and the Web
COMP60532 	Introduction to BioHealth Informatics
COMP60511 	Principles of Digital Biology
COMP60732	Advanced Database Management Systems
COMP60721 	Data Engineering
COMP60921 	Introduction to Health Informatics
COMP61011	Machine Learning and Data Mining
COMP61032	Optimization for learning, planning and problem-solving
COMP61021	Modelling and visualization of high-dimensional data
COMP61111	Logical Reasoning and Applications
COMP61132	Modal Logic and Description Logics
COMP60611 	Fundamentals of Parallel and Distributed Systems
COMP61232	Mobile Communications
COMP61221 	Mobile Systems
COMP60621 	Parallel Programming for Numerical Applications
COMP60632	Future Multi-Core Computing
COMP61421	Computer and Network Security
COMP61411	Cryptography
COMP61432 	IT Governance
COMP61521 	Component-based Software Development
COMP61532 	Pattern-based Software Development
COMP61511 	Software Engineering Overview
COMP61332 	Text Mining
COMP61632	Computer Vision
COMP61621	Computer Graphics and Animation
BMAN60111 	IS Strategy and Enterprise Systems
BMAN61102 	Decision Behaviour, Analysis and Support
MSEC40001 	Entrepreneurial Commercialisation of Knowledge
BMAN71621 	IT Leadership Forum
BMAN71642 	Human Computer Interaction and Web User Interfaces

D1. The ability to work and communicate effectively as a team member,
to prepare and present seminars to a professional standard, to
understand ethical issues related to professional activities, to write
theses and reports to a professional standard, and to perform  
independent and efficient time-management

Uli Sattler is a professor in the Informatio Management Group at the
University of Manchester. She has worked in the field of knowledge
representation and reasoning since 1994, and an important part of this
work has been devoted to the design of practical reasoning algorithms
for expressive description logics (DLs). Jointly with Ian Horrocks,
she designed the SHIQ family of DLs, determined their complexity, and
designed practical algorithms for their key inference problems. The
SHIQ family forms the logical basis of ontology languages such as
OWL. She develops reasoning services of knowledge representation
systems as requested by ontology applications to molecular biology and
the clinical sciences, e.g.,  for ontology explanation and
comprehension and for working modularly with ontologies.

She has been involved in several research projects and was a DAAD
fellow. She was a member of the editorial board of Journal of
Artificial Intelligence Research, is a member of the editorial board
of the Journal of Automated Reasoning and a corner editor of Journal
of Logic and Computation, was a member of the OWL 2 working group, PC
co-chair of KR2010, PC co-chair of IJCAR 2012, and a member of many
PCs, e.g., ISWC, AAAI, and AiML.

--------------------------------------------------------------
--- For your convenience, this form can be processed by EasyChair
--- automatically. You can fill out this form offline and then
--- upload it to EasyChair. Several review forms can be uploaded
--- simultaneously. You can modify your reviews as many times as
--- you want.
--- When filling out the review form please mind
--- the following rules:
--- (1) Lines beginning with --- are comments. EasyChair will
---     ignore them. Do not start lines in your review with ---
---     as they will be ignored. You can add comments to the
---     review form or remove them
--- (2) Lines beginning with *** are used by EasyChair. Do not
---     remove or modify these lines or the review will become
---     unusable and will be rejected by EasyChair
--------------------------------------------------------------
*** REVIEW FORM ID: 723855::258620
*** SUBMISSION NUMBER: 15
*** TITLE: Practical Epistemic Entailment Checking in SROIQ
*** AUTHORS: Anees Mehdi and Sebastian Rudolph
*** PC MEMBER: Riccardo Rosati
--------------------------------------------------------------
*** REVIEW:
---  Please provide a detailed review, including justification for
---  your scores. This review will be sent to the authors unless
---  the PC chairs decide not to do so. This field is required.

This paper describes a rewriting approach to query answering over
SROIQ ontologies with epistemic queries. In addition to describing the
approach, the authors also discuss an implementation and evaluation.

In this paper the authors first describe the "classical" semantics of
epistemic DLs (where epistemic operators used in the input ontology
and query). They then show this semantics doesn't work well with
expressive logics like SROIQ because (1) the rigid term assumptions
implies a UNA, and thus makes epistemic SROIQ incompatible with SROIQ,
and (2) the common (infinite!) domain assumption clashes with SROIQ's
ability to enforce finite domains, a second source of
incompability. Next, they introduce a revised version of the
semantics, which is compatible in both senses.  Then the authors
introduce a novel technique that allows one to answer epistemic
queries wrt this revised semantics over SROIQ ontologies (without
epistemic operators!). The essence of the technique is to rewrite the
epistemic query into a set of standard DL queries that will produce
the expected result. The authors claim (and prove in a TR) that the
result of the procedure are correct for their 'new' semantics, and
identical to the 'classic' semantics in the absence of nominals and
under UNA.

The authors have implemented a publicly available system that uses the
proposed approach and evaluated it on two ontologies, running five
queries with and without epistemic operations:

The paper discusses an interesting problem and presents an interesting
approach, but it also suffers from a number of issues:

- the authors fail to discuss the blow-up caused by the rewriting to
  the query: it seems as if could be exponential in the nesting of
  epistemic operators and thus should be discussed. Similarly, the
  rewriting requires some expensive (standard) entailment tests that
  look costly and would thus need to be discussed.

- the evaluation is rather weak: it involves only 1 ontology, in 2
  versions which are not publicly available and where it isn't clear
  how they have been obtained (see below for more), without an
  explanation of why this one was chosen. The evaluation is also
  rather weak: there is no information on the size of the rewriting,
  only the time it takes to run it.

Minor remarks:

- In Section 3 the authors mention axiom $\top\sqsubseteq \le 3
  U.\top$ as a way to restrict possible models to have only 3 elements
  in the domain. This construction is disallowed in SRIQ, as universal
  role is non-simple (as it is transitive), and thus can't be used in
  number restrictions...there are more direct ways to do this.

- In the definition (extended) epistemic model, the authors call the
  KB satisfiable if it has an epistemic model. In classical DL the KB
  that has a model is called consistent; it is probably worth use the
  same term here.

- In the evaluation part, the authors said: "For the purpose of
  testing, we consider two versions of the wine ontology with 483 and
  1127 individuals". The original Wine ontology contains about 60
  individuals. I read this as the authors add more individuals to the
  ontology without changing TBox/RBox. But this contradicts with the
  test result for the C5 concept, as it is unsatisfiable in the
  original ontology. I would suggest the authors to give an access to
  the test ontologies or to describe the changes made in more details.

- The description of the evaluation lacks some explanation on why the
  results of usual and epistemic queries differ. For example, I would
  like to see why the epistemic version of the C2 query (the universal
  restriction) contains no individuals in it.

--------------------------------------------------------------
*** REMARKS FOR THE PROGRAMME COMMITTEE:
---  If you wish to add any remarks for PC members, please write
---  them below. These remarks will only be used during the PC
---  meeting. They will not be sent to the authors. This field is
---  optional.

I didn't have a look at the technical report that contains all the
proofs so I didn't verify the correctness in detail.

--------------------------------------------------------------
--- If the review was written by (or with the help from) a
--- subreviewer different from the PC member in charge, add
--- information about the subreviewer in the form below. Do not
--- modify the lines beginning with ***
*** REVIEWER'S FIRST NAME: (write in the next line)
Dmitry
*** REVIEWER'S LAST NAME: (write in the next line)
Tsarkov
*** REVIEWER'S EMAIL ADDRESS: (write in the next line)
tsarkov at cs.man.ac.uk
--------------------------------------------------------------
--- In the evaluations below, uncomment the line with your
--- evaluation or confidence. You can also remove the
--- irrelevant lines
*** OVERALL EVALUATION:

---  3 (strong accept)
---  2 (accept)
1 (weak accept)
---  0 (borderline paper)
---  -1 (weak reject)
---  -2 (reject)
---  -3 (strong reject)

*** REVIEWER'S CONFIDENCE:

---  4 (expert)
3 (high)
---  2 (medium)
---  1 (low)
---  0 (null)

*** END
--------------------------------------------------------------
++++++++++++++++++++++

First of all, thank you all very much for your valuable catches.

You all had questions regarding the definition of problematic pairs
(Definition 4.4) and the following example. First, the definition is
correct, but was intended only to ensure that the first three cases in
Def. 4.4 cover all pairs of atoms. Next, the explanation of the
example is misleading, and we apologise for that: it should read

"From Def. 4.4., it follows that the atom d depends on a, and also
c and b depend on a. Furthermore, d and c, d and b, and b and c are
weakly dependent. "

In case of acceptance, we will make sure that the role and absence of
problematic pairs is explained well.

[in answer to Reviewer 2] Lemma 4.5 relies on the uniqueness of
x-modules, and this property holds for any notion of x-module, as
proven in [Kontchakov et al., 2009]. Also, there is a 1-1
correspondence between atoms and genuine modules M_\alpha, and thus
{M_\alpha | \alpha \in O} is also a linear---but possibly
overlapping---decomposition of O; for (disjoint) "building blocks" of
modules, one should thus choose atoms.

[in answer to Reviewer 2] All proofs that are skipped in the paper are
contained in the technical report on the anonymous website. In
particular, Proposition 4.9 is a consequence of the results in Section
6.

[in answer to Reviewer 2] The definition of principal ideal *of an
atom* is indeed slightly different from the one *of an element in a
poset*: it is (\mathfrak{a}] = \union_{\mathfrak{b}<=\mathfrak{a}}
\mathfrak{b}. Again, this will also be clarified in case of
acceptance.

[in answer to Reviewer 2] You are correct in observing the role played
by large signatures for the relevance of an atom. In particular, if we
consider the signature of the whole ontology obviously each atom is
relevant to it; on the other hand, it becomes interesting for small
signatures: for example, which atoms are relevant for one term.

[in answer to Reviewer 2] The correctness of Algorithm 1 will be
stated & proved explicitely in case of acceptance. In particular,
regarding your question about GenAxioms, we are sure that the
algorithm is correct: given the above 1-1 correspondence between atoms
and genuine modules M_\alpha, we can establish a further 1-1
correspondence between atoms and GenAxioms. As thus, it is correct
that GenAxioms is only ever updated in line 18 when we have found a
new module (see line 15).

----------------------

This paper describes an extension of ALC with a "is typically subsumed  
by" relation (in addition to the standard  "is subsumed by" one) whose  
semantics is based on a first order extension of propositional KLM  
semantics. This extension is presented and discussed, and some  
indications are given as to the computational complexity of the logic.

The paper seems to make a solid contribution to an interesting area  
and is mostly well written -- but I am not too sure whether it is  
suitable for IJCAI because it spends an enormous amount of space (some  
of which could be easily safed) introducing a formalism and, for my  
taste, too little space on discussing relevant properties of it for  
knowledge representation:

space savings: semantics of ALC is first introduced in the usual DL  
way, and then in the Kripke-style. At most one of these is necessary,  
and they seem interchangeable for this framework. The mirroring of  
definition 1 & 7 and Theorem 2 & 4 is superfluous.

Things relevant to KR that could be added: (1) the example is purely  
propositional and not too convincing (i.e., I would only want to  
conclude that VM is usually non-fatal if I also knew that M is  
subsumed by VM or BM -- otherwise, VM could be another 'tiny' or  
'atypical' subconcept of M and as fatal as VM?!). A more elaborate  
example or more detailed discussion of the late relational example  
would be interesting. More importantly, the authors claim that theorem  
5 gives us a decision procedure -- it would be interesting to see how,  
in particular because the rank of a complex concept expression such as  
C and not D doesn't seem to be defined (note, I think that this is  
easily fixable, but it would be nice to have it spellt out)

Regarding related work, there is some early-DL work by Quantz which  
looks extremely relevant.

-----------

This paper presents a rule-based implementation of an OWL 2 RL  
reasoner on an embedded device and reports on some evaluation using  
the LUBM benchmarks.

I think this is an interesting problem, and definitely worth  
investigating. The paper, as it stands, is however not of sufficient  
quality to be acceptable for IJCAI. Here are my main reasons:

- the implementation, as far as one can tell from the information  
provided, is a straightforward one from the OWL 2 spec (which involves  
80 rules) that work directly on the RDF triples and includes, e.g., a  
full axiomatization of equality and various rules to deal with RDF  
lists. As a consequence, the technical contribution is rather limited,  
and the paper also completely ignores all previous work that has been  
done on optimization of rule-based reasoning: e.g., it is well-known  
that equality can be dealt with in much more space-saving ways. In  
particular, the author's solution to the problem of too many inferred  
triples in the presence of datatypes is to "delete" datatypes -- which  
isn't insightful nor probably required.

- the authors don't distinguish between the (i) a reasoning approach  
and (b) its implementation, and between the (a) "complicatedness" of a  
reasoning approach and (b) the complexity of the underlying algorithm  
in term of space and time, (c) the complexity of the description logic  
for which this algorithm was designed. These need to be distinguished  
because, e.g., a reasoning approach such as the one used by CEL could  
be made to run on an embedded device if the memory constraints were  
clear during implementation. In particular, the author's conclusion  
that [existing] reasoners cannot be run on Gumstix *because* the  
underlying DLs are too complex is unjustified: existing reasoners  
couldn't run on gumstix due to technical reasons which had nothing to  
do with any DL complexity.

- the evaluation is weak (in that it only involves LUBM benchmarks)  
and presented with too little information: e.g., I can't see what has  
been measured in Figs. 4 & 5, and fig. 3 seems to involve only 3 data  
points? The "extracted" formula seem to be rather dubious given the  
sparsity of measuring points. Which queries have been tested? Section  
5.3 *could* contain some interesting observations (which rules have  
been rewritten? how?) but this information isn't spellt out.

Minor comments:

- the names for OWL and OWL 2 are used in a sloppy way - and the  
relatinship between OWL lite and the OWL 2 profiles seems confused

- the motivating example given for this implementation completely  
relies on datatypes -- but then datatypes are "deleted" (which I guess  
they aren't, simply ignored)

---------------

...rather than adding another review, I have chosen to mostly inline  
my comments into the author's reply to my review.

Dear authors,

I didn't mean to ask you to write a completely different paper, simply  
one that

- helps readers to see the connection with OWL (simply as a matter of  
politeness to newcomers from all areas) and one

- where we find a bit less technical terms and some more examples, and  
for this I suggested to expand the discussion of some core features  
(e.g., adding an example of nominals, TBox, ABox, role axioms --  
little helpful changes like that) and for that to not blow the paper  
up, perhaps mention some other features more briefly.

To be more precise, let me comment on your comments.

Best regards, Uli

REVIEWER 1

We would like to thank the reviewer for his work. However, as
described in the text below we think some of the remarks cannot and
should not
be the reason for writing a completely different paper.

The paper describes a very important and influential reasoner
system,
RacerPro, and thus is of interest for the journal. I am, however,
not
so sure about the suitability of the style: in particular, I think
that, by
(1) concentrating on Description Logics (and mentioning OWL
aspects only in passing and in an incomplete way),
Many people who read the manuscript really liked the non-Owlish
style. After all, this is really just a syntax issue.

it is, but it *would* be helpful and is not a big thing to add, e.g.,  
that EL++ and ELH are fragments of the OWL 2 EL profile.

(2) adding a lot of historic information on design choices, and
Why should one drop this? All those who read the manuscript liked the
way
the article is written.

(3) discussion what seems like a plethora of features without
distinguishing between 'core' and 'also available';
I do not agree with this statement.

I do not agree with your disagreement -- see above.

the authors have made the paper rather inaccessible to the semantic
web community, and thus to the readers of this journal.
I would suggest not to argue that the "semantic web community"
(whatever this is) cannot understand a system description, which
needs to mention a lot of features, just because there are a lot of
features in a system.

It's not about being (un)able to understand, it's simply about being  
friendly & accessible: if there is a direct connection between, say, EL 
++ and OWL 2 EL, why *not* mention it?

To put it the other way round,
I'd suggest to describe
(1') RacerPro mainly in OWL terms and mention relevant DL aspects
when
required (i.e., use class, property, etc., and OWL profile names),
We decided not to do so. OWL is nice, but it is just a syntax (if not
many).

...ok - so why not simply add, even as a footnote, the correspondence  
concept-class, role-property, etc...

(2') either drop most of the historic remarks or
concentrate them in a separate section for the interested reader,
and
We decided not to do so.

ok - so it's both a system desription plus a history of the  
development...if you think that this is more useful than easing access  
to your system description and *showcasing* some of its cool features  
(examples! e.g., for abduction and update rules!), then I guess this  
is your choice.

(3') concentrate on some core features and explain them in an
accessible way, using examples or, even better, publicly available
examples.
Example need a detailed introduction to syntax and semantics of DLs.

no they don't.

We do not agree that example can be presented in a reasonable amount
of pages.

More detailed remarks:
- [abstract] "knowledge-based applications based on ontologies"
seems
odd;
Solved.

- [Intro] "mosteffective"?  "an software"? "a a description logic"
Solved.

- [Intro] TBoxes are *not* ontologies (at least not in OWL)...this
can lead to unnecessary confusion!
This is religion. For us, the Tbox (plus the implicitly defined
signature) give us the ontology. Aboxes describe data. I would not
mind accepting a more strategic Abox (if no nominals are supported).

Please note that I wasn't worried about what you call what, but mostly  
about confusing readers -- a little explanation of the different  
usages of the term might help those people who call a set of RDF  
triples (i.e., probably data) "an ontology"...

---------------

- Section 2.2 is half a "History Sketch", and I guess only
accessible
to the
DL community (especially 1st paragraph).
Discussed above.

Also, shouldn't Hermit be
mentioned there?
Why should Hermit be mentioned here? It has not influenced the
design of our system.

...ah, you cite it via 58, so this is solved.

Also, in the last paragraph: *size* isn't
necessarily the decisive factor here...it's more than that?!
Yeas, but we do not see a severe problem here.

...are reviewers only allowed to point out *severe* problems? I was  
simply puzzled as to your choice of describing these use cases (as  
there are loads of variants)

- Section 2.3 contains some more history (and only accessible to
DL
community). Also, there is a reference missing for ELH (or better
use the OWL profile name?).
I do not really know who first defined this langage. It is part of
the ancient FL family? So, we decided to consider this language to be
part of the folklore.

In my understanding, it was first described in works by Baader,  
Brandt, and Lutz - despite the fact that it was supported by the old  
SNOMED classifier system whose name I have forgotten...I would think  
this reference *is* required!

Also, the relation between nRQL and
SPARQL-OWL should be mentioned.
We decided not to do this. Again, the text is a system description,
and, yes, not every topic on which there is a paper published that
might be somewhat relevant is included.

why would you *not* do this? Why don't you want to relate "your" query  
language with others out there, especially if it could make the paper  
more interesting for readers who are interested in SPARQL?!

Also, regarding instance retrieval
optimisation techniques, SHER and Requiem should probably be
mentioned.  Oh, and [55] is a reference to (stuff around) KAON
*2*.
I could change this in the final final version if the reviewer
really insisted on KAON *2*.

yes, i do: this is why I mentioned it. KAON has almost nothing in  
common with KAON 2, in particular, no DL reasoning was implemented in  
KAON. KAON 2 is a completely different system -- and not simply the  
latest version. Why do I have to explain this?

And "a sublanguage of OWL" is OWL 2 EL?
Why is this relevant? These are details of OWL 2. I doubt that people
are interested in these details.

...because people might be coming from another side, might have heard,  
e.g., that OWL 2 EL is used in various cool applications, and they  
look for a reasoner for a similar one...and you would help them  
understand that RacerPro is such a reasoner! I.e., as a courtesy to  
the reader. Again, why do I need to explain this?

- Section 3. I think you are showing a screenshot of Protege *4* and
it's the
OWL* *API.
We could change this in the final final version if the reviewer
insisted on correct version numbers and blanks (which, in the case of
OWL
API, might be very confusing).

yes, again, i do: this is why I mentioned it. Similar to the KAON  
case, Protege 4 and Protege 3 have almost nothing in common. and the  
OWL API is written with a blank.  Again, why do I need to explain this?

In Figure 4, I was surprised to see whole IRIs...aren't
they normally displayed in a shortened version/local names to make
things more readable (I really had difficulties reading through
this).
No cheating as you see, just true screen output with, maybe, a slight
glitch, we will consider this in the next version of RacerPro.

;)

I found the use cases slightly disappointing: they are
mostly  toy or own use cases, and sketched at such a high level of
abstraction that it is hard to gain insights...e.g., the event
recognition would have been nice to see in more detail to
understand
We have several Journal articles in which the subsystems are described.

There are too many desiderata here.

fair enough.

- 2. of FW more cautionary

--------

E. Jimenez-Ruiz, B. Cuenca Grau, U. Sattler, T. Schneider, and R.  
Berlanga. Safe and Economic Re-Use of Ontologies: A Logic-Based  
Methodology and Tool Support. In The Semantic Web: Research and  
Applications, vol. 5021 of LNCS, Springer Verlag, 2008. Part of this  
work was carried out within the TONES project.

R. Kontchakov, L. Pulina, U. Sattler, T. Schneider, P. Selmer, F.  
Wolter, M. Zakharyaschev.

Original Objectives:

The goal of this project is to develop meaningful notions and related  
reasoning services for composing and decomposing ontologies to serve  
as the basis for the collaborative development and re-use of ontologies.

Since state-of-the-art ontology languages such as OWL are logic-based,  
a useful approach to support ontology developers in composing and  
decomposing ontologies will be based on variants of conservative  
extensions. Roughly speaking, conservativity will ensure that the
composition of two or more ontologies does not corrupt these  
ontologies and that such a composition behaves in a controlled,  
modular way, e.g., as we would expect software modules  to behave. The  
notions and reasoning services to be developed will provide tool  
support for the following tasks:

(T1) developing ontologies with interfaces (and acceptable
restrictions on their usage) which guarantee that, if such an ontology
is composed with other ontologies, it neither corrupts nor is
corrupted by the ontologies they are composed with;

(T2) evaluating the consequences of the composition of a set of given
ontologies which may have been built in a completely unrestricted way;

(T3) decomposing a large ontology into modules that can be edited in a
controlled way.

In (T1)--(T3), conservativity plays different roles. In (T1), because  
the ontologies are regarded as ``black boxes'', one has to ensure  
conservativity for any ontology obeying certain syntactical/semantical  
constraints. In contrast, in (T2), one has to decide a posteriori  
whether a given ontology is a conservative extension of another.  The  
appropriate variants of the notion of a
conservative extension have to be determined based on the following  
criteria (and might well not be same for all tasks):

What do the users want? What kind of consequences should be preserved?
E.g., should all consequences be preserved, or only the subsumption
hierarchy, or something in between? We are going to develop the
notions required to compare ontologies through liaisons with designers
of ontologies from bio-informatics and medical informatics.

What is the computational complexity of detecting whether one ontology
is a conservative extension of another?  Can we design ``practical''
algorithms which detect this for real ontologies?

Which notions of conservativity have important meta-properties? There  
are various known, desirable properties, for example the so-called  
Robinson
consistency property.

For which notions do there exist transparent, syntactical, acceptable
approximations? That is, restrictions that (i) can be explained to a
designer and are acceptable, (ii) are syntactic so that they can be
controlled by ontology editors, and (iii) ensure that compositions
with other ontologies are conservative extensions.

Our research aims are:

To specify notions of conservative extensions between DL ontologies
and investigate their computational and meta-properties.

To provide rigorous specifications for (T1)--(T3) by applying those
notions to the problems of composing and decomposing DL ontologies for
both the prescriptive and the analytical approach.

To design algorithms which support those applications. This includes
algorithms for deciding certain notions of conservativity and
algorithms that use these notions for decomposing ontologies.

To implement and evaluate these algorithms in cooperation with
ontology editor developers and ontology designers.

    --------------

Beneficiaries:

A wide range of UK and international research efforts in areas such as
the Semantic Web/Grid, knowledge management, medical-informatics,
bio-informatics and e-Science are now dependent on ontologies to
capture domain semantics and to promote interoperability---this is
evidenced by  the widespread use of other ontology design tools such  
as Protege and
SWOOP. Due to the size of ontologies and current state of the art, it  
is crucial to support the design and maintenance of these ontologies  
with services to enable collaborative
editing and re-use of ontologies, both of which are based on
controlled composition and decomposition of ontologies. Without such  
support, ontologies will be difficult and costly to develop, and their  
increasing size and complexity will lead to their rapidly becoming  
unmaintainable.

In addition to its direct benefit  to  those who aim to develop and/or  
use ontologies, this work will also benefit the wider UK research  
community: in the first place, it will
deepen our understanding of modularity for logical theories in general
(not only DLs but also temporal logics/modal logics), and in the
second place, it will help to consolidate the UK's already established
world leadership in research on knowledge representation and reasoning
in general and ontology languages and reasoning in particular.

In the longer term, this work will also be of benefit to the
increasing number of companies who are developing ontology
design/deployment tools and ontology based applications. This includes  
technology companies such as Siemens and IBM, and ontology users such  
as NASA, Freshwaterlife, and Ordnance Survey.

--------------------------

"Gul Aftab" Ahmed ahmedga at cs.man.ac.uk
Javid Akhter akhter at cs.man.ac.uk
Ahmad  Almakhlafi aalmakhlafi at cs.man.ac.uk
Abdullah ALNAJEM aalnajem at cs.man.ac.uk
Majed ALSABAAN malsabaan at cs.man.ac.uk
Iman ALSHARHAN ealsharhan at cs.man.ac.uk
Xin Bao xbao at cs.man.ac.uk
Hassan BASHIR hbashir at cs.man.ac.uk
Giorgio BRAJNIK gbrajnik at cs.man.ac.uk
Georgios CHAROPOULOS gcharopoulos at cs.man.ac.uk
Klitos CHRISTODOULOU christodoulou at cs.man.ac.uk
Timothy  Clark clarkt at cs.man.ac.uk
Alex  Constantin aconstantin at cs.man.ac.uk
Geraint DUCK gduck at cs.man.ac.uk
Andrea  Edwards aedwards at cs.man.ac.uk
David FOX dfox at cs.man.ac.uk
Francesco  Galluppi fgalluppi at cs.man.ac.uk
Peter  Glaus pglaus at cs.man.ac.uk
Demetris HADJITOFALLIS hadjitofallis at cs.man.ac.uk
Darren HAU dhau at cs.man.ac.uk
Mohammad KHODADADI khodadam at cs.man.ac.uk
Roman  Krenicky krenicky at cs.man.ac.uk
Danielius KUDINSKAS dkudinskas at cs.man.ac.uk
Qinan LAI qlai at cs.man.ac.uk
Keletso LETSHOLO kletsholo at cs.man.ac.uk
Claudiu MIHAILIA cmihaila at cs.man.ac.uk
Ioannis MOUPAGIATZIS imoupagiatzis at cs.man.ac.uk
Fabio PAPACCHINI fpapacchini at cs.man.ac.uk
Zoya POURMIRZA zpourmirza at cs.man.ac.uk
Giles REGER reger at cs.man.ac.uk
Peter RODDA prodda at cs.man.ac.uk
Yanti RUSMAWATI rusmawati at cs.man.ac.uk
Arsalan SADRI sadria at cs.man.ac.uk
Petch Sajjcholpunt sajjachp at cs.man.ac.uk
Alan STOKES astokes at cs.man.ac.uk
Jennifer TALBOT jtalbot at cs.man.ac.uk
Andrew WEBB awebb at cs.man.ac.uk
Raymon WHITE rwhite at cs.man.ac.uk
"Mona Mohamed"   "Zaki Ali" alsubhi at cs.man.ac.uk

Modularity-based approaches to finding all justifications are already  
in use, as described in \cite{SuQiJi08}. The main focus of work will  
be to find out how to partition the ontology into suitable modules to  
assist and improve justification finding strategies. It has to be  
ensured that the union of the justifications in all modules equals all  
justifications for the entailment in question.

Another interesting aspect of modularity is its usage for predicting  
disjointness of justifications, which could then feed into the HST  
algorithm. This approach builds upon the fact that depleting modules  
contain all justifications for an entailment and will involve the  
following steps: we find one justification $J$ for the entailment in  
question using the \enquote{find one} mechanism. Then we apply a  
repair on one axiom, i.e. remove this axiom from the justification.  
 From this, a module is constructed based on the repaired  
justification. If the axiom that has just been removed from the  
justification is not contained in the module, we can predict that it  
will not occur in any other justifications for the entailment, which  
is an indicator for disjointness of the justifications.

   Advanced Database Management Systems 	COMP60732
   Building Web Applications 	COMP60432
   Component-based Software Development 	COMP61521
   Computer Graphics and Animation 	COMP61621
   Computer Vision 	COMP61632
   Computer and Network Security 	COMP61421
   Concurrent Programming for Numerical Applications 	COMP60621
   Cryptography 	COMP61411
   Data Engineering 	COMP60721
   Decision Behaviour, Analysis and Support 	BMAN61102
   Entrepreneurial Commercialisation of Knowledge 	MSEC40001
   Fundamentals of Parallel and Distributed Systems 	COMP60611
   Future Multi-Core Computing 	COMP60632
   Human Computer Interaction and Web User Interfaces 	BMAN71642
   IS Strategy and Enterprise Systems 	BMAN60111
   IT Governance 	COMP61432
   IT Leadership Forum 	BMAN71621
   Introduction to BioHealth Informatics 	COMP60532
   Introduction to Health Informatics 	COMP60921
   Logic and Applications 	COMP61111
   Machine Learning and Data Mining 	COMP61011
   Mobile Communications 	COMP61232
   Mobile Systems 	COMP61221
   Modal Logic and Description Logics 	COMP61132
   Modelling and visualization of high-dimensional data 	COMP61021
   Ontology Engineering for the Semantic Web 	COMP60421
   Optimization for learning, planning and problem-solving 	COMP61032
   Pattern-based Software Development 	COMP61532
   Principles of Digital Biology 	COMP60511
   Research Methods and Professional Skills 	COMP60990
   Semi-structured Data and the Web 	COMP60411
   Software Engineering Overview 	COMP61511
   Text Mining 	COMP61332

The paper describes a progressive query answering algorithm for OWL 2  
QL query answering, and reports on some performance analysis.

Even though I find the approach in general interesting, I find this  
paper lacking in various aspects (see below for more detail):

(1) it does not place the approach sufficiently into context; in  
particular, any comparison with anytime approaches to query answering  
(for example, see [1,2,3,4]) are missing: since progressive algorithms  
are a special case of anytime algorithms, such a comparison is  
essential.

(2) the presentation of the approach is rather overformalized, hard to  
follow and verify.

(3) the experimental evaluation is questionable and it is hard to see  
how the reported tests can be significant.

In summary, I cannot suggest to accept this paper for ISWC.

More detailed remarks:

- the usage of 'most' is bold and would require some form of  
substantiation

- "OWL 2 QL [...] the CQ answering problem can be solved in polynomial  
[...] time." misses QL's point: it can besolved by a reduction to  
standard RDB query answering!

- in the introduction, other papers around REQUIEM, as well as papers  
describing other QA approaches (SHER, Trowl, Quonto)

- the description of "a certain answer" in section 2 is too sketchy.

- the notation used in the first paragraph of section 3 would need  
introducing (I shouldn't have to guess what [R|E](q,O) is)

- shouldn't res(P) be res(P;q,O)? and shouldn't s(P;i:j) be  
P(q,O;i:j)? Admittedly, dropping parameters from terms makes them  
shorter -- but also more opaque and, in the latter case, less uniform/ 
easy to understand.

- for your measure to work, you need that sigma maps into some (total  
or partially?) ordered set -- and it would have been helpful if you'd  
said that 'smaller means more relevant'.

- in definition 3, ", after the execution... ."? I am confused.

- the definition of one stride being strictly smaller than another one  
is unclear...if not all tuples in s1 have to be <= than all in s2,  
then what?

- in the example on page 6,
---- the 'he advises him' is unclear in the presence of 3 men...
---- there are some typos around the strides, and it would have been  
helpful to see some comparisons between them...

- I'd like to see evidence for " In typical web applications of  
semantic query answering (Se-
mantic Web information retrieval) the data is more strong than the  
knowledge. " and the following discussion of exceptions is confusing/ 
un-understandable.

- "The problem of progressive query answering is much more diﬃcult  
than"...how much?

- as the examples show, "Thus, we can evaluate against the database  
the fresh queries
(rewritings) as they are derived and provide the user with a set of  
fresh answers. " is misleading: you provide the users with 'sometimes  
none, sometimes fresh and sometimes old answers'?

- query graphs have been used widely in the QA literature

- using "non-distinguished" for 'only occurring once' is misleading

- L(x) seems undefined (all Ls have subsripts), and the description of  
'rolling up' distinguished nodes is very confused ("into an  
existential restriction" is missing?).

- Definition 5 only works for graphs who share nodes...at least one  
would require nodes in query graphs to be named uniformly -- or an  
explanation that we will use this comparison only on graphs where one  
is the result of modifying the other one...and for this case, I am  
sure, this definition can (and should) be simplified

- sigma was introduced as a similarity measure, now (on page 8,  
bottom) it is a similarity relation between queries...this is confusing!

- the explanation & description of the algorithm on page 9 is rather  
convoluted & hard to digest (in particular, it switches unhelpfully  
between 'standard' notions of the resolution calculus with a version  
of a graph-based on, and it mixes descriptions, observations, and  
explanations into a rather big paragraph...and I still don't know  
exactly what is going on), and doesn't mention the basic resolution  
rule -- which would be helpful because of the above mentioned switches  
to a graph-based view...also,
--- the display formula for ProgResAns uses unclear indizes n_j and m,
--- I thought that from page7,  unbound variables had been removed,  
and now they play again a role...

- the proofs on page 11 could be more convincing:
--- I am not sure whether the index "in" in "Q_in" refers to 2  
parameters i and n as in "_{i,n}" or the word 'in'...
--- for termination, what is " ﬁnite max distance node sets "
--- the structure of the completeness proof is rather unhelpful: I was  
expecting to see, as usual, a answer tupe 'a' fixed, and then some  
argument of why 'a' would be returned, and in which stride...
--- similarly, the structure of the 'sigma sortedness' part: I can't  
even find an explanation of the claim that needs to be proved...

- in the evaluation,
--- the authors chose 2 ontologies (A and B) from a set of ontologies  
used elsewhere...they fail to explain their choice, and why this  
should be representative.
--- i was missing an explanation for the queries chosen
--- I couldn't follow the explanation of why REQUIEM needed re- 
implementing: wouldn't it have been fairer to at least also consider  
REQUIEM as it is? As well as other tools, including Quonto and Presto?  
In particular, because these tools include a number of optimisations  
and redundancy elimination techniques which, as Table 2 shows, don't  
seem to be used in the approach described here (i.e., we can easily  
build a query of length n which would be rewritten into 2^n queries -  
see the rewriting of in Table 2).

[1] Eyal Oren, Christophe Guéret, Stefan Schlobach: Anytime Query  
Answering in RDF through Evolutionary Algorithms. International  
Semantic Web Conference 2008: 98-113

[2] Jeff Z. Pan, Edward Thomas and Yuting Zhao. Completeness  
Guaranteed Approximation for OWL DL Query Answering. In Proc. of the  
22nd International Workshop on Description Logics (DL2009). 2009.

[3] Michael Wessel, Ralf Möller: A High Performance Semantic Web Query  
Answering Engine. Description Logics 2005

[4] Riccardo Rosati, Alessandro Almatelli: Improving Query Answering  
over DL-Lite Ontologies. KR 2010

-----------

This paper describes an approach to ranking and filtering relevant  
terms and relationships in concept maps using metrics from the graph  
theory. This work is aimed at knowledge extraction on a large scale  
particularly on extracting the important knowledge (in this case  
ranked lists of terms and relations) based on huge corpora and the  
Web. The authors propose a filtering method that is able to extract  
relevant terms & relations from texts without recurring to any  
external semantic resources.

The paper as a whole is well organized, well written, easy to read and  
to follow. It explained what was being undertaken, why it was being  
undertaken and what was intended to be learned in a straightforward  
manner.

I am not sure whether I understood Fig. 1 wrongly or the figure was  
not in sync with the explanation. It was  mentioned in the last  
paragraph of page 5 that "The input to this ranking step (shaded in  
Fig.1) are domain specific concepts map that can originate from two  
sources: (1) emerging from domain corpus (texts) using a tool such as  
OntoCmaps, or (2) existing
domain concepts maps from repositories." I suppose by following this  
explanation, arrow with label 2 in the Fig 1 should point to Concept  
Map Ranking instead.

In Section 3.4 (paragraph 4 & 5), it is useful to the reader if the  
authors explain the reason why alpha is set between 0.1 and 0.2, and  
also reason for normalization of the metrics, as they discussed the  
reason behind using mean for setting up threshold.

It would be nicer if the data is represented using some graphs instead  
of tables.

Having special emphasize on precision only is probably not enough. It  
would be more interesting if both precision and recall are taken into  
account, in order to evaluate the effectiveness of the proposed metrics.

To summarize, I think the overall effort is nice and useful. The  
results are presented in an adequate fashion.

9-12 Lectures, 12-13 Lunch, 13-14 Assisted Study (in lecture theatre),  
14-15 Short Test, 15-17 Lectures (No need for lab space/places, in the  
sense of coursework requiring access to computers.)

thanks again for your good reviewing work. Unsurprisingly, we have yet  
another request for you: we need your help in discussing and voting  
for the best paper award. To make your life easier, we have pre- 
selected all papers whose average score was larger than or equal to 2  
(where we used the reviewer's confidence to weight average scores per  
paper): this resulted in eleven papers, and with a nice distance to  
the next paper which scores 1.8.

To enable access to those papers and a discussion about it, we have  
created another instance of easychair, KR-10-best-paper, have uploaded  
all final versions of these 11 papers to it, and gave access to all KR  
10 PC members who are *not* authors of any of the 11 top ranked papers  
to be discussed -- you will soon receive an invitation to KR-10-best- 
paper from easychair.

Please have a look at as many of those as you can and, for each of  
those you formed an opinion about, share with us if and why this paper  
should, could, or shouldn't be awarded the best paper award. In case  
you want your comments to be confidential, feel free to send them  
directly to us -- otherwise, please discuss on easychair.

We are not going to have a vote or make a numeric decision so as to  
take community size out of the equation, but will base our decision on  
a mixture of votes and reasons given.

PS: if you look at the papers KR-10-best-paper, they all look as if  
they were authored by "not Uli"...this is because I uploaded them in  
bulk

Fangzhen Lin <flin at cs.ust.hk>
Uli Sattler <sattler at cs.man.ac.uk>
Gabriele "Kern-Isberner" <gabriele.kern-isberner at cs.uni-dortmund.de>
Sebastien Konieczny <konieczny at cril.fr>
Gerhard Lakemeyer <gerhard at cs.rwth-aachen.de>
Jerome Lang <lang at irit.fr>
Joohyung Lee <joolee at asu.edu>
Nicola Leone <leone at unical.it>
Yves Lesperance <lesperan at cse.yorku.ca>
Hector Levesque <hector at cs.toronto.edu>
Paolo Liberatore <liberato at dis.uniroma1.it>
Vladimir Lifschitz <vl at cs.utexas.edu>
Thomas Lukasiewicz <Thomas.Lukasiewicz at comlab.ox.ac.uk>
Carsten Lutz <clu at informatik.uni-bremen.de>
Pierre Marquis <marquis at cril.univ-artois.fr>
Sheila McIlraith <sheila at cs.toronto.edu>
"John-Jules" Meyer <jj at cs.uu.nl>
Thomas Meyer <tommie.meyer at meraka.org.za>
Ralf Moeller <r.f.moeller at tu-harburg.de>
Leora Morgenstern <leora at steam.stanford.edu>
Ilkka Niemela <ilkka.niemela at tkk.fi>
Maurice Pagnucco <morri at cse.unsw.edu.au>
Peter "Patel-Schneider" <pfps at research.bell-labs.com>
Bijan Parsia <bparsia at cs.man.ac.uk>
Ramon Pino Perez <pino at ula.ve>
HSofia Pinto <sofia at algos.inesc-id.pt>
Fiora Pirri <pirri at dis.uniroma1.it>
Henry Prakken <henry at cs.uu.nl>
R. Ramanujam <jam at imsc.res.in>
Riccardo Rosati <rosati at dis.uniroma1.it>
Francesca Rossi <frossi at math.unipd.it>
Torsten Schaub <torsten at cs.uni-potsdam.de>
Luciano Serafini <serafini at fbk.eu>
Stuart Shapiro <shapiro at cse.buffalo.edu>
Munindar Singh <singh at ncsu.edu>
Tran Cao Son <tson at cs.nmsu.edu>
Mikhail Soutchanski <mes at scs.ryerson.ca>
" V.S." Subrahmanian <vs at cs.umd.edu>
Annette ten Teije <annette at cs.vu.nl>
Michael Thielscher <mit at inf.tu-dresden.de>
Pietro Torasso <torasso at di.unito.it>
Wiebe van der Hoek <wiebe at csc.liv.ac.uk>
Leon van der Torre <leon.vandertorre at uni.lu>
Laure Vieu <vieu at irit.fr>
Kewen Wang <k.wang at griffith.edu.au>
Chris Welty <cawelty at gmail.com>
"Mary-Anne" Williams <mary-anne at it.uts.edu.au>
Frank Wolter <wolter at liverpool.ac.uk>
Michael Wooldridge <mjw at csc.liv.ac.uk>
"Jia-Huai" You <you at cs.ualberta.ca>
Yan Zhang <yan at scm.uws.edu.au>
Mingyi Zhang <zhangmingyi045 at yahoo.com.cn>
Bernhard Nebel <nebel at informatik.uni-freiburg.de>
Michael Fisher <m.fisher at csc.liv.ac.uk>
Grigoris Antoniou <antoniou at ics.forth.gr>
Diego Calvanese <calvanese at inf.unibz.it>
Enrico Franconi <franconi at inf.unibz.it>
Salem Benferhat <benferhat at cril.univ-artois.fr>
Thomas Eiter <eiter at kr.tuwien.ac.at>
Gerhard Brewka <brewka at informatik.uni-leipzig.de>
Giuseppe De Giacomo <degiacomo at dis.uniroma1.it>
Joseph Halpern <halpern at cs.cornell.edu>
Ulle Endriss <ulle.endriss at uva.nl>
Hector Geffner <hector.geffner at upf.edu>
Sylvie Coste-Marquis <coste at cril.univ-artois.fr>
Ernest Davis <davise at cs.nyu.edu>
Chitta Baral <chitta at asu.edu>
James Delgrande <jim at cs.sfu.ca>
Volker Haarslev <haarslev at cse.concordia.ca>
Leila Amgoud <amgoud at irit.fr>
Juergen Dix <dix at tu-clausthal.de>
Andreas Herzig <herzig at irit.fr>
Enrico Giunchiglia <giunchiglia at unige.it>
Patrick Doherty <patdo at ida.liu.se>
Nicola Guarino <guarino at loa-cnr.it>
Anthony Hunter <a.hunter at cs.ucl.ac.uk>
Michael Gelfond <mgelfond at cs.ttu.edu>
Xiaoping Chen <xpchen at ustc.edu.cn>
Ian Horrocks <Ian.Horrocks at comlab.ox.ac.uk>
Didier Dubois <dubois at irit.fr>
Philippe Balbiani <balbiani at irit.fr>
Adnan Darwiche <darwiche at cs.ucla.edu>
Franz Baader <baader at tcs.inf.tu-dresden.de>
Francesca Toni <f.toni at imperial.ac.uk>
Guillermo Simari <grs at cs.uns.edu.ar>
Hans van Ditmarsch <hvd at us.es>
Michael Zakharyaschev <michael at dcs.bbk.ac.uk>
Arild Waaler <arild at ifi.uio.no>
Umberto Straccia <straccia at isti.cnr.it>
Pei Wang <pei.wang at temple.edu>
Oliver Kutz <okutz at informatik.uni-bremen.de>
"Jeff Z." Pan <jeff.z.pan at abdn.ac.uk>

Energy Assessment of Medium Access Protocols for Amulet2e Sensor Motes  
Running TinyOS	NICHOLAS FILER
Zainab Akinwande	Flat Hunting - to Rent/Buy	DONAL FLYNN
Abdullah Albahdal	Implementation of A Concurrent Signature Signing  
Protocol 	NING ZHANG
Fahad Albogamy	A Library of Schema Matching Algorithms for Use in  
Dataspace Management Systems	ALVARO FERNANDES
Eirini Alevizou	Web Based Group Decision Support System	LUDI MIKHAILOV
Ali Alfayly	Damaged packet delivery and PLC for VoWLAN	BARRY CHEETHAM
Sumayah Saeed Alharbi	Finding Text in Maps	DAVID MORRIS
Samah Alhazmi	Information Extraction	JOHN MCNAUGHT
Sikandar Ali	Research to find variances in ERPs and document best  
practices	Peter KAWALEK
Hana Almagrabi	Information Extraction	JOHN MCNAUGHT
Abdullah Alnajem	Risk-aware collaborative downloading 	NING ZHANG
Noha Alnazzawi	New methods for low-level processing of next generation  
sequencing data	MAGNUS RATTRAY
Majed Alshammari	Design patterns for component-based software  
development	KUNG-KIU LAU
Zaki Alsubhi	Web-Based Support for Teaching Delivery	CHRISTOPHER  
HARRISON
Abdulla Alzaabi	Developing a Software Transactional Memory Library	 
Mikel Lujan
Zaure Ashygali	Monitoring the state of Peer-to-Peer systems using  
topology adaptation	JOHN BROOKE
Sana Asif	An Analysis of Financial Market Blogs and Forums	GORAN NENADIC
Ludovic Balon	Modelling the Environmental and Genomic Causes of  
Disease 	NEIL LAWRENCE
Muna Binothman	Arabic speech recognition	ALLAN RAMSAY
Ewan Booth	Calendaring for Knowledge and Innovation	ALASDAIR RAWSTHORNE
Daniel Carrington	Evaluating a Privacy-preserving Two-party  
Nonparametric Sign Test Protocol using MATLAB	NING ZHANG
Audric Castillan	Gaze correction for one-to-one video conferencing 	 
APHRODITE GALATA
Georgios Charopoulos	Query expansion for search interfaces 	SOPHIA  
ANANIADOU
Cheng Chen	Design patterns for component-based software development	 
KUNG-KIU LAU
Xu Yue Chen	Vehicle Tracking	DAVID MORRIS
Anais Chesneau	Pyrotechnic Display Simulation.	ERNEST HILL
Andrew Chikerema	What's in the Web of Data?	SEAN BECHHOFER
Erol-Valeriu Chioasca	Soft Information Systems and Technologies  
Methodology	CHRIS ATKINSON
Klitos Christodoulou	Collaborative On-line Concept Mapping	ALEXANDRIA  
WALKER
Paul Clegg	Augmented Reality - architectural visualisation	TOBY HOWARD
Sivaram Damineni	Prediction of Football Scores	NEIL LAWRENCE
Roopa Dass	Research project	DONAL FLYNN
Azad Dehghan	Extracting active URLs from scientific literature	GORAN  
NENADIC
John Denman	Design of Multifactorial Experiments by Genetic Search	 
JOSHUA KNOWLES
Sam Dluzewski	Support for Teaching XML	CHRISTOPHER HARRISON
Robert Donkin	Machine Learning for Java Garbage Collection	GAVIN BROWN
Steven Doyle	Integrated GIS monitoring systems for disease  
surveillance	ANDREW BRASS
Oluwaseyi Dudubo	Research project	DONAL FLYNN
Israh Elrajhy	Evaluating a Privacy-preserving Two-party Nonparametric  
Sign Test Protocol using MATLAB	NING ZHANG
Vivek Enniriyil	A Web Application: Simulating Micro Payments	THIERRY  
SCHEURER
Oluwatoyin Etiko	The Application of Technology in Business	Martin Henery
Sameh Fayez	Composition tool	ALLAN RAMSAY
Anirudh Gahlot	Vehicle Route and Velocity Mapping using an iPhone 3GS	 
NICHOLAS FILER
Manan Garg	BI-Social Networking	BABIS THEODOULIDIS
Antony Arokya Das Gilbert	Internet Marketing	Christopher Holland
Mahwash Goni	Internet marketing in. ….	Christopher Holland
Akshay Gopale	BI-Energy	BABIS THEODOULIDIS
Sharvena Govindasamy	AstraZeneca or North West e-Health or National  
Drug Evidence Centre	ANDREW BRASS
Sharath Kumar Gowder Shadaksharappa	Sensor Network Query Processing -  
Dynamically Adapting Acquisition Rates in SNEE	ALVARO FERNANDES
Ioannis Hadjipanayis	Amazon SimpleDB or Google Datastore on Multi-core  
Architectures	Mikel Lujan
Demetris Hadjitofallis	Automatic term recognition	SOPHIA ANANIADOU
Auracha Hanbunchong	Design and Implementation of a Web Service  
Application for SCM	Sandra Sampaio
Jean-Damien Hatzenbuhler	Videorealistic speech animation	APHRODITE  
GALATA
Turgut Helvacioglu	ABC English language proficiency testing: Automated  
feedback 	JOHN SARGEANT
Madina Ipalakova	Information Extraction	JOHN MCNAUGHT
Junpeng Jiang	Reconstructing data from the scientific literature	 
Stephen Pettifer
Mamatha Kagathi Chandrashekar	Personalised Health Information  
Management	BABIS THEODOULIDIS
Gurdeep Kang	Component-based software for the avionics domain	KUNG-KIU  
LAU
Gurpreet Kaur Khakaru	Database Reverse Engineering	Illias Petrounias
Mohammad Khodadadi	E-science strategies for interpreting large volume  
SNP data from next-generation sequencing	ANDREW BRASS
Jonathan Kirkham	GL.1 Accelerometer Controlled Scientific  
Visualization	MARTIN TURNER
Athanasios Kitsos	Learning to Solve Rubik's Cube with Grid Computing  
(Evolutionary Algorithms Competition)	JOSHUA KNOWLES
Georgios Konstantinidis	A web portal for distributed systems biology  
modelling	PEDRO MENDES
Harinath Kopeti	Pattern Classification of Stock Price Moving	XIAOJUN  
ZENG
Qinan Lai	Enabling the Generation of Websites from Models	ANDREW  
CARPENTER
Charalambos Laos	Internal Marketing	Christopher Holland
Surajdeen Ayobami Lasisi	Scenario Based Learning	ALEXANDRIA WALKER
Yann Yves Leenhardt	Semantic Spreadsheets - using the Semantic Web for  
Scientific Data	CAROLE GOBLE
Chuan Li	Crowdsourcing Manchester's Story	ALASDAIR RAWSTHORNE
Yinji Li	Gadgets and Tools for Nature Networks	CAROLE GOBLE
Wei Lin	Image Analysis of Patterned Structures	PAUL NUTTER
Vasileios Liolios	A web portal for distributed systems biology  
modelling	PEDRO MENDES
Xiaoxing Liu	Zhongwen Youxi He	RICHARD BANACH
Jeremie Loudet	Evolving Simple Robot Control Systems	STEPHEN FURBER
Ji Luo	A Web-based Play Production Management System	THIERRY SCHEURER
Chhavi Maheshwari	A Perfect Developer Case Study	RICHARD BANACH
Omer Malik	The Influence of Structure on Users Attention on websites	 
Nikolay Mehandjiev
Ashley McDonald	OWL/XML Tools	BIJAN PARSIA
Melville McDonald	Zhongwen Youxi He	RICHARD BANACH
Ashutosh Mondal	Extracting SKOS vocabularies from News Feeds 	SEAN  
BECHHOFER
Anwar Ahmad Moon	Dynamic, distributed fault tolerance	JAMES GARSIDE
Gokulanathan Murthy	Fuzzy DSS	LUDI MIKHAILOV
Simon Mussard	Projection of 3D images using anaglyphs	ALLAN RAMSAY
Mehshan Mustafa	High performance numerical simulation of wave  
propagation	Fumie Costen
John Muumbi	GIS Support for Emerging Infectious Diseases in East  
Africa	RICHARD BANACH
Sanjay Narayanan	Developing Applications on GPUs	Mikel Lujan
Hinnah Nasir	Analysing the ACS Masters Project Book	ROBERT STEVENS
Japari Ngilari	Rapid Prototyping via Executable (Equational)  
Specifications	CHRISTOPHER HARRISON
Hiep Nguyen	Web-based Multiuser 2D2 Space	ALEXANDRIA WALKER
John Nolan	Own	MARK VAN HARMELEN
Oluwatomilola Okulaja	Mapping requirements directly to component-based  
software architectures	KUNG-KIU LAU
Adetayo Oni	The Application of Technology in Business	Martin Henery
Andy Onyung	iTLS: Intelligent Thread Level Speculation	Mikel Lujan
Temilola Oti	Relationship between CRM and Data Mining	Illias Petrounias
Nathan Perianayagassamy	Disc Drive Interogation and Data Recovery	PAUL  
NUTTER
Priyadarshini Ramachandran	From natural language to Entity- 
Relationship diagrams	IAN PRATT-HARTMANN
Giles Reger	Developing RuleR for fault detection, diagnosis and  
repair.	HOWARD BARRINGER
Shamim Rezaie	Sloodle to Aid Distance Learning of Computer Science	 
NICHOLAS FILER
Juan Antonio Rocha Valdez	Analysis, Comparison and Evaluation of Cost/ 
Effort/Schedule Estimation Models for Software Engineering Projects	 
XIAOJUN ZENG
Peter Rodda	AstraZeneca or North West e-Health or National Drug  
Evidence Centre	ANDREW BRASS
Yanti Rusmawati	Own	DAVID RYDEHEARD
Aseim Safaya	Web Development	DONAL FLYNN
Anjali Saji	Viterbi decoder for forward error correction in mobile  
networks.	BARRY CHEETHAM
Manjari Saji	Effect of bit-errors on compressed speech and music.	 
BARRY CHEETHAM
Petch Sajjacholapunt	Propagation modelling in the heart	Fumie Costen
Assel Sakhipova	BI-Fraud	BABIS THEODOULIDIS
Pallavi Sathe	Uncertainty of Databases	Illias Petrounias
Bhavik Shah	Android Based Group Meeting	WEIGANG WANG
Bilal Shahid	Web-Based Support for Teaching Delivery	CHRISTOPHER  
HARRISON
Surendiran Shanmugam	Enabling the Generation of Websites from Models	 
ANDREW CARPENTER
Subash Sivaji	Business Intelligence	Illias Petrounias
Balaji Subramanian	Pattern Classification of Stock Price Moving	 
XIAOJUN ZENG
Zhiyong Sun	SpiNNaker Robot Arm System	STEPHEN FURBER
Tobias Ternent	AstraZeneca or North West e-Health or National Drug  
Evidence Centre	ANDREW BRASS
Olamide Togun	ABC: 'Banking' structured questions	JOHN SARGEANT
Olamide Togun	Soft Information Systems and Technologies Methodology..	 
CHRIS ATKINSON
Pierre Trouve	Modelling Motion Capture for Game Animation	NEIL LAWRENCE
Sebastian Tsierkezos	Comparing Data Integration Algorithms 	Sandra  
Sampaio
Anastasia Tsoutsoumpi	Question answering from FAQ pages	GORAN NENADIC
Ijeoma Udejiofor	A Web-based Race Management System	THIERRY SCHEURER
Andreas Vourkos	The People Prompter: The iPhone Killer App for People  
Over 45 years	CAROLE GOBLE
Andri Wally	ABC English language proficiency testing: Generating  
questions	JOHN SARGEANT
Yanlei Wang	Business Intelligence	Illias Petrounias
Zhaopu Wang	Supporting Synchronous Groupware on Google Phones	WEIGANG  
WANG
Andrew Wise	Augmented Reality - Inspiring the next generation	TOBY  
HOWARD
Richard Wood	Simulation Study of IPSec Protocol in a Mobile IP  
environment 	ANDREW CARPENTER
Guofeng Xu	Architectural Model of a RISC Processor	LINDA BRACKENBURY
Badamasi Ya'U	Mapping requirements directly to component-based  
software architectures	KUNG-KIU LAU
Azat Yerzhan	Social Networks, Bus Stops, and Crowdsourcing Information	 
ALASDAIR RAWSTHORNE
Yiqi Zhu	Animation of avatars using human motion data 	APHRODITE GALATA

# COMP60011 Future Multi-Core Computing
# COMP60022 Grid Computing and eScience
# COMP60032 High Performance Computing in Science and Engineering
# COMP60041 Low-Power System Design
# COMP60051 Visualisation for HPC
# COMP60071 Introduction to Computational Science
# COMP60081 Fundamentals of High Performance Execution
# COMP60092 Computational Finite Element Methods
# COMP60121 Automated Reasoning
# COMP60161 Knowledge Representation and Reasoning
# COMP60171 Interactive System Design
# COMP60242 Mobile Computing
# COMP60302 Introduction to BioHealth Informatics
# COMP60311 Computational Biology - The Application of Computer  
Science to the Problems of Post-Genome Biology
# COMP60321 Computer Animation
# COMP60361 Advanced Database Management Systems
# COMP60372 Semi-structured Data and the Web
# COMP60391 Computer Security
# COMP60431 Machine Learning
# COMP60442 Advanced Machine Vision
# COMP60462 The Semantic Web: Ontologies and OWL
# COMP60551 Introduction to Health Informatics
# COMP60562 Clinical Decision Support
# COMP60900 MSc Dissertation
# COMP60990 Research Methods and Professional Skills
# COMP609PM Plagiarism and Malpractice test
# COMP67011 Foundations of Computing
# COMP67021 High-Level Programming (Java)
# COMP67032 Building Web Applications
# COMP67052 Patterns for eBusiness Applications
# COMP67321 Systems Design and Databases

-----------
There are numerous ontology languages around, most prominently the Web  
Ontology Language OWL. OWL has been developed based on experiences  
with its predecessors DAML+OIL and OIL, and its design has been  
carried out by W3C working groups. OWL 2 is an extension and revision  
of the OWL (published in 2004) and is a W3C recommendation.

OWL and OWL 2 are called Web Ontology Languages because they 
are based on web standards such as XML, IRIs, and RDF, and because 
they are designed in such a way that they can be used over 
the web (for example, one OWL file can import others by their URI). 
There are numerous usages of OWL and OWL 2, however, that are rather 
local, for example to a software or information system.

These languages come with a lot of options and choices, which we will 
only briefly mention here, and only come back to when they are 
important: OWL comes in three flavours (OWL Full, OWL lite, 
and OWL DL), and OWL 2 comes with two semantics (i.e., two 
ways of determining the meaning of an ontology, direct and 
RDF-based) and three profiles (i.e., fragments or syntactic 
restrictions, called OWL 2 EL, QL and RL), and you can choose between 
a number of syntaxes to safe your ontology in. Since the tools and 
especially the reasoners around mostly support OWL 2's direct 
semantics and OWL DL, we will concentrate here on those. Also, OWL 2 
is backwards compatible to OWL, so we can discuss advantages and new 
features of OWL 2 elsewhere, and can forget the difference for now and 
just talk about OWL (and mean both OWL and OWL 2).

Next, we would like to utter a warning: OWL has been designed to be  
consumed by computers, so in its natural form (especially in certain  
syntaxes), it is really hard to read or write for humans: e.g., the  
following snippet of an OWL ontology in the RDF syntax says that

<em>a:Boy</em> <em>owl:equivalentClass</em> _:x .
_:x <em>rdf:type</em> <em>owl:Class</em> .
_:x <em>owl:intersectionOf</em> ( <em>Child</em> <em>Male</em>)

boys are exactly those children who are male. The same example in the  
Manchester syntax looks more readable,

EquivalentClasses( <em>Boy</em> ObjectIntersectionOf( <em>Child</em>  
<em>Male</em> ) )

but we can easily imagine a much nicer presentation of this statement,  
and tool developers have designed useful, goal- or application- 
oriented tools or visualisations. This is clearly a good thing: it  
helps the user to interact with an (OWL) ontology, without requiring  
them to be fluent in the ontology language and while supporting the  
task at hand.

Now what is in an OWL ontology? There is some stuff like headers and 
declarations around an ontology but, in essence, an OWL ontology is a 
set of axioms, and each of these can say something about 
classes, individuals, and properties. For example, 
the following axioms (in Manchester syntax) talk about two classes, 
Man and Person, and one property, hasChild, and two individuals, Alice and Bob.

SubClassOf( <em>Man </em><em>Person</em> )

SubClassOf(<em>Person (hasChild </em>only <em>Person))</em>

ClassAssertion(<em>Bob Man)</em>

PropertyAssertion(<em>hasChild Bob Alice</em>)

Roughly speaking, these axioms say something about these classes, 
properties, and inviduals, and this meaning is fixed through their 
semantics, which allows us to distinguish interpretations/ 
structures/worlds/... that satisfy these axioms from those 
that don't. For example, a structure where every Man is a 
Person would satisfy the first axiom, whereas one where we 
have a Man who is not a Person would not satisfy the 
first axiom. Rather confusingly for modelers in general, we call those 
interpretations/structures/worlds/... that satisfy all axioms 
of an ontology a model of this ontology. It is worth pointing 
out that one ontology can have many many models, of varying size and 
even infinite ones. And here we can even have a sneak preview at 
reasoning or inferencing: assume the axioms in our ontology are such 
that in all its models, it happens that every 
GrandParent is a Parent. Then we call this an 
entailment or a consequence of our ontology, and we 
expect a reasoner to find this out and let us know (if you 
are familiar with Protégé, then you might have seen an inferred class 
hierarchy, which is basically this).

More detailed, this semantics works as follows: first, fix a set --  
any set of things will do, finite or infinite, as long as it is not  
empty. Then, take each class name (such as <em>Man</em>) and  
<em>interpret </em>it as a set -- any set is fine, it can even be  
empty. Then, take each <em>property </em>name (such as <em>hasChild)</ 
em> and interpret it as a relation on your set (basically by drawing  
edges between your elements) -- again, you are free to chose whatever  
relation you like. Then, take each <em>individual</em> name (such as  
<em>Bob</em>) and interpret it as one of your elements. All together,  
you have now an <em>interpretation </em>(but remember that 1 ontology  
can have many many interpretations).<em> </em>Now, to check whether  
your interpretation satisfies an ontology, you can go through your  
ontology axiom by axiom and check whether your interpretation  
satisfies each axiom. For example, in order for your interpretation to  
satisfy
<ul>
	<li>the first axiom, SubClassOf( <em>Man </em><em>Person</em> ), the  
set that interprets <em>Man </em>has to be a subset of the set that  
interprets  <em>Person. </em>Since this will soon become horribly  
contrived, we can say 'every instance of <em>Man </em>is also an  
instance of <em>Person'. </em></li>
	<li>the second axiom, SubClassOf(<em>Person (hasChild </em>only  
<em>Person)), </em>every instance of  <em>Man </em>is only related,  
via the property <em>hasChild</em> to instances of <em>Person </ 
em>only. I.e., an instance of <em>Man, </em>if it has an out-going  
<em>hasChild </em>edge, then this must link it to an instance of  
<em>Person.
</em></li>
	<li>the third axiom, ClassAssertion(<em>Bob Man), </em>the element  
that interprets <em>Bob </em>must be an instance of <em>Man </em>(see,  
now it becomes quite easy?)<em>.
</em></li>
	<li>the fourth axioms, PropertyAssertion(<em>hasChild Bob Alice</ 
em>), <em> </em>the element that interprets <em>Bob </em>must be  
related, via the <em>hasChild </em>property, to the element that  
interprets <em>Alice.
</em></li>
</ul>
So, in this case, we could <em>in principle, </em>construct or invent  
interpretations and test whether they satisfy our ontology, i.e.,  
whether it's a model of it or not. This would, however, hardly enable  
us to say something about what holds in all  models in our ontology  
because, as mentioned earlier, there can be loads of those, even  
infinitely many...so we rather leave this to tools called reasoners  
(and they do this in a more clever way). This whole exercise should,  
however, help us unterstand the above mentioned entailment. Consider  
the following two axioms:

EquivalentClass(<em>Parent</em> (<em>Person</em> and <em>isParentOf</ 
em> some <em>Person</em>))

EquivalentClass(<em>GrandParent</em> (<em>Person</em> and  
(<em>isParentOf</em> some (<em>isParentOf</em> some <em>Person</em>)))

The first axiom says that the instances of <em>Parent </em>are exactly  
those elements who are related, via <em>isParentOf, </em>to some  
<em>Person. </em>The second axiom says that the instances of  
<em>GrandParent </em>are exactly those elements who are related, via  
<em>isParentOf, </em>to some element who is related, via  
<em>isParentOf, </em>to an instance of <em>Person. </em>Please note  
that the <em>GrandParent </em>axiom does not mention <em>Parent. </ 
em>Now you can try to construct an interpretation that satisfies both  
axioms and where you have an instance of <em>GrandParent </em>that  is  
not a <em>Parent...</em>and it will be impossible...then you can think  
some more and come to the conclusion that, these two axioms <em>entail  
</em>that every <em>GrandParent </em>is a <em>Parent, i.e., </em><em>  
</em>that  <em>GrandParent </em>is a sub class of <em>Parent. </ 
em>Coming back to Protege: if you look at the inferred class hierarchy  
in Protege, then you see both the 'told' plus these <em>entailed</em>  
subclass relationships. In OWL, we also have two special classes,  
<em>thing </em>and <em>nothing,</em> and they are interesting for the  
following reasons:
<ul>
	<li>if thing is a subclass of a user-defined class, say <em>X, </ 
em>then every element in every interpretation is always an instance of  
<em>X. </em>This is often regarded as problematic, e.g., for reuse  
reasons.</li>
	<li>if your class, say <em>Y, </em>is a subclass of <em>nothing, </ 
em>then<em> Y </em>can never have any instance at all, because  
<em>nothing </em>is according to the OWL specification, always  
interpreted as the empty set. In many cases, this thus indicates a  
modelling error and requires some repair.</li>
</ul>
Finally, we also ask our reasoner to<em> answer a query, </em>e.g. to  
give us all instances of <em>Person. </em>If you look again at the  
four axioms above, then we only have that <em>Bob </em>is an instance  
of <em>Man, </em>so we might be tempted to not return <em>Bob </em>to  
this query. On the other hand, we also have the axiom that says that  
every instance of<em> </em> <em>Man </em>is also an instance of  
<em>Person, </em>so we should return <em>Bob </em>because our ontology  
<em>entails </em>that <em>Bob</em> is a <em>Person. </em>Reasoners can  
be used to answer such queries, and they are not restricted to class  
names: for example, we could also query for all instances of  
<em>(Person </em>and (<em>hasChild</em> some <em>Person</em>)). Now,  
from the four axioms we have, we can't infer that <em>Bob </em>should  
be returned to this query because, although we know that <em>Bob </ 
em>is a <em>Person </em>and is <em>hasChild</em> related to <em>Alice,  
</em>we don't know anything about her, and thus we don't know whether  
she is a <em>Person </em>or not. Hence <em>Bob </em>can't be returned  
to this query. Similarly, if we query for all instances of <em>(Person  
</em>and (<em>hasChild</em> atmost 1<em></em>)), we cannot expect  
<em>Bob </em>to be in the answer:  although we know that <em>Bob </ 
em>is a <em>Person </em>and is <em>hasChild</em> related to <em>Alice,  
</em>we don't know whether he has possibly other children, unbeknownst  
to us. This kind of behaviour is referred to as OWL's  <em>open world  
assumption. </em>

It is quite common to distinguish class-level ontologies 
(which only have axioms about classes, but don't mention individuals), 
from instance-level ontologies (i.e., assertions about the 
types and relations between individuals). We find ontologies that are 
purely class-level, such as Snomed-CT, and where OWL and reasoning is 
used purely to make sure that the things said about classes and the 
resulting entailed class hierarchy are correct, and that no 
contradictory things have been said that would lead to subclasses of 
nothing or to the whole ontology being contradictory. One 
interesting option is then, e.g., to export the resulting class 
hierarchy as a SKOS vocabulary to be used for navigation. We also find 
ontologies with both class- and instance-level axioms, and which are 
used with the above query answering mechanism for flexible, powerful 
mechanism for accessing data.

Also, let me point out that (i) OWL is heavily influence by classical  
first order predicate logic and by research in description logics  
(these are fragments of first order logic that have been developed in  
knowledge representation and reasoning since the late 80ies), and that  
(ii) OWL is much more than what is mentioned here: e.g., we can  
annotate axioms and classes, import other ontologies, etc.

Finally, if you want to use OWL for your application, you will first 
have to clarify whether this involves a purely class-level ontology, 
or whether you want to use OWL for accessing data. In the latter case, 
you have two options: you can leave the data in the database, files, 
or formats that it currently recides in, and use existing approaches 
to map this data to your class-level ontology and thus query 
it through the OWL ontology. Or you can extract and load it 
into an instance-level ontology and go from there. Both have clearly 
advantages and disadvantages, whose discussion goes beyond the scope 
of this article (as many other aspects).

So, where to go next if you want to learn more about OWL? First, you  
could download an OWL editor such as Protege 4 and follow a tutorial  
on how to build an OWL ontology (see below for more links). You could  
also read the substantial OWL Primer (it has a cool feature which lets  
you decide which syntaxes to show and which to hide!) and take it from  
there. Or you could read some of the papers on experiences with OWL in  
modelling biology. Regardless of what you do, building your own OWL  
ontology and asking reasoners to make entailments salient seems always  
to be a good plan.

Helpful links:

OWL primer

tutorials

Protege

reasoners

%% one little weakening of the bio-health aspect here:

\begin{quotation}\hypothesis{Probabilistic description logics---that  
is, decidable fragments of standard first order probabilistic logic--- 
are useful and useable formalisms for representing significant  
knowledge for a variety of applications, in particular in  bio-health  
applications.}\end{quotation}

We have six high level objectives:
\begin{enumerate}
\item \textbf{To establish a substantive validation methodology for  
evaluating probabilistic formalisms.} We plan to develop a clear  
\emph{methodology} for comparing probabilistic logic formalisms as  
well as substantive \emph{content} represented in these formalisms so  
that methodology can be applied. Our goal is to develop a ``problem  
benchmark'' that can be used to compare formalisms; see WP1.

\item \textbf{To develop a set of  theoretically reasonable,  
expressive probabilistic description logics.} We plan to develop an  
understanding of attractive features (e.g., relational ABox,   
independence) for probabilistic description logics: these features  
interact in non-trivial ways, and their understanding involves the  
investigation of semantic suitability, decidability of the relevant  
reasoning problems, and prospect of implementable reaosning  
algorithms; see WP2.

\item \textbf{To determine the computational practicality of the  
proposed formalisms.} We plan to investigate which of the  
theoretically reasonable probabilistic description logics are indeed   
computationally practical, e.g., for which we can implement tools and  
reasoners that scale to real problems; see WP3.

\item \textbf{To determine the expressive adequacy of the proposed  
formalisms with respect to bio-health domains.} We plan to investigate  
which of the  theoretically reasonable and computationally practical  
formalisms are useful in the sense that the modellers can say what  
they need and want to say in that formalism with reasonable effort;  
see WP???.

\item \textbf{To establish key benefits of bio-health probabilistic  
ontologies.} We aim to have concrete demonstration of some of those  
benefits, most prominently on the development, reusability,  
transparency, and  maintainability  of probabilistic models; see WP??.

\item \textbf{To provide a grounded recommendation to a  
standardization organization (and other key adopters) for an extension  
of OWL to capture probabilistic knowledge.} Our objective is to be  
able to give sufficient information so that a founded decision can be  
made as to the suitability of such an extension.
\end{enumerate}

-------------

<TR><TD>Rima Addas	</TD><TD>Monday, Carole</TD> </TR><TR>
<TD>Maytham Alabbas	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Samar Mohammed Alkhuraiji	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Aqeel Al-Naser	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Samantha Bail	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Xin Bao	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Craig Barton	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Riza Theresa Batista-Navarro	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Ben Brewer	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Rebekah Carter	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Miss Ashley Carver	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Sadia Cheema	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Chiara Del Vescovo	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Sergio Davies	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Matthew Gamble	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Martin Grymel 	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Rafael Goncalves	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Bo Hyun Nam	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Alfredo Kalaitzis	</TD><TD>Friday, Carole</TD></TR><TR><TD>
George Karystianis	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Imran Khan	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Anthony Kleerekoper	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Peter McNerney	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Miss Eleni Mikroyannidi	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Raheel Nawaz	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Matthew Orlinski	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Muhammad Raza Ali	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Jonathan Roberts	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Akshay Sangodkar	</TD><TD>Monday, Carole</TD></TR><TR><TD>
Thomas Sharp	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Thomas Standley	</TD><TD>Friday, Carole</TD></TR><TR><TD>
Petr Stepan	</TD><TD>Friday, Uli</TD></TR><TR><TD>
Paul Tar	</TD><TD>Monday, Carole</TD></TR><TR><TD>
James Thomas	</TD><TD>Monday, Uli</TD></TR><TR><TD>
Li Zhang	</TD><TD>Friday, Carole</TD></TR><TD>

------

\section{Relevance to Health Care}

% Long version:
The increased amount of genetic information available from genome-wide  
association studies has increased the demand for improved tool support  
to evaluate  lines of evidence and to support clinical decision  
making. For example, if a patient has colon cancer, we need to know  
whether this is due to an inherited predisposition (i.e. a germline  
mutation), such as hereditary non-polyposis colon cancer (HNPCC) or  
familial adenomatous polyposis (FAP). If the patient has either, this  
would have implications both for their future treatment and for  
screening of relatives who may have inherited the same mutation.   
There are different lines of evidence that will be used by clinicians  
to make their decision such as: age (inherited colorectal cancer is  
associated with younger patients Family history), patient phenotype  
(HNPCC more frequently has a right side tumour localization, and other  
indicators such as \emph{café au lait} spots),   tumour phenotype  
(microsatellite instability and immunohistochemistry evidence can  
indicate HNPCC),  genetic testing (exons of genes known to be involved  
in HNPCC or FAP may be sequenced, and clinical scientists will then  
identify nonsense (e.g. premature stop codon, or altered mRNA  
splicing) or missense variants (replacing a codon with a codon for a  
different amino acid). If variants are identified, databass searches  
will be used to ascertain whether they have been identified previously  
and if so whether they were thought to be pathogenic mutations. In  
addition, bioinformatics techniques (e.g. predicting the effect of an  
amino acid substitution) will be used to assess the risk associated  
with the variant.)

The representation and manipulation of these lines of evidence  
requires suitable tool support, and involves both terms from  
"classical" biomedical ontologies such SNOMED CT and GO (e.g., colon  
cancer)   and "probabilistic" knowledge (e.g., microsatellite  
instability can indicate HNPCC).  In the future,  it is likely that  
other lines of evidence will be identified, both from clinical  
observation and from recently developed high throughput techniques  
such as genome wide association studies (GWAS), and from integrated  
approaches such as \cite{Goldgar04}.   These approaches will identify  
low risk alleles which may be involved in the large number of cancers  
which though genetic are not due to Mendelian syndromes, such as HNPCC.

The proposed research, if successful,  will develop the basis of an  
ontology language that is able to capture both classic ontological  
knowledge and combine it, in an integrated way, with probabilistic  
knowledge. The related reasoning algorithms will be able to detect  
contradictions in modelling (and thus ensure coherent modeling), and  
to infer (ranges of implicit) probabilities from the ones stated  
explicitly, while taking    both classic ontological and probabilistic  
knowledge into account. The latter can be used to answer questions  
such as "given the current state-of-the-art in oncology and genetics  
and the findings related to patient X, what is the probability that  
X's tumour is due to a genetic predisposition of kind Y?".

% Short version:
The increased amount of genetic information available from genome-wide  
association studies has increased the demand for improved tool support  
to evaluate  lines of evidence and to support clinical decision  
making. For example, if a patient has colon cancer, we need to know  
whether this is due to an inherited predisposition (i.e. a germline  
mutation), such as hereditary non-polyposis colon cancer (HNPCC) or  
familial adenomatous polyposis (FAP). If the patient has either, this  
would have implications both for their future treatment and for  
screening of relatives who may have inherited the same mutation.   
There are different lines of evidence that will be used by clinicians  
to make their decision such as: age, patient phenotype,   tumour  
phenotyp,  and genetic testing.

The representation and manipulation of these lines of evidence  
requires suitable tool support, and involves both terms from  
"classical" biomedical ontologies such SNOMED CT and GO (e.g., colon  
cancer)   and "probabilistic" knowledge (e.g., microsatellite  
instability can indicate HNPCC).  In the future,  it is likely that  
other lines of evidence will be identified, from clinical  
observations, high throughput techniques, and integrated approaches  
such as \cite{Goldgar04}.   These approaches will identify low risk  
alleles which may be involved in the large number of cancers which  
though genetic are not due to Mendelian syndromes, such as HNPCC.

The proposed research, if successful,  will develop the basis of an  
ontology language that is able to combine classic ontological  
knowledg, in an integrated way, with probabilistic knowledge. The  
related reasoning algorithms will be able to detect contradictions in  
modelling (and thus ensure coherent modeling), and to infer (ranges of  
implicit) probabilities from the ones stated explicitly, while  
taking    both classic ontological and probabilistic knowledge into  
account. The latter can be used to answer questions such as "given the  
current state-of-the-art in oncology and genetics and the findings  
related to patient X, what is the probability that X's tumour is due  
to a genetic predisposition of kind Y?".

-------------------------------------

Integrated methods for combining evidence have been developed in the  
past. For example Goldgar et al., (2004) have published a method for  
assessing sequence variants associated with breast cancer. MAYBE PAVEL  
SHOULD INCLDE SOMETHING HERE ABOUT THE ADVANAGES OF AND OWL BASED  
APPROACH OVER BAYSIAN NETWORKS.

Goldgar DE et al 2004. Integrated evaluation of DNA sequence variants  
of unknown clinical significance: application to BRCA1 and BRCA2. Am J  
Hum Genet. 75(4):535-44

I think that we might also want to include something about the  
Orphanet classification which we have converted into OWL format. This  
contains links between diseases, clinical signs (ie phenotypes) and  
genes.

% Short version:

The rapidly increasing amount and complexity of biomedical knowledge  
requires adequate means for a formal representation of all flavors of  
probability in ontologies. The current experience of building  
biomedical ontologies often shows that the more detailed the knowledge  
the less can actually be represented in a classical way, i.e. with  
full confidence. For example, instead of a single gene responsible for  
blue eye color there are a number of genes each of which  
\textit{probably} has an impact on the color. The success of the  
proposed project will greatly facilitate representation and  
intelligent use of such knowledge and, therefore, will have a  
substantial positive impact on medical applications that currently  
employ ontologies. It is also expected to be highly beneficial for  
medical decision making by providing means for combining different  
lines of statistical evidence with ontological knowledge. Finally, the  
proposed project is especially important in light of the new medical  
technologies, such as Next-Generation DNA Sequencing  
\cite{Mardis08ARGHG} which will be adopted in the near future and will  
further contribute to the proliferation of medical knowledge. %In a  
broader sense the success of the project would also strengthen the  
role of logic as a unifying approach to knowledge representation, in  
particular, justify its applicability under uncertainty, as well as  
add further evidence for epistemic adequacy of probability.

-----------
The World Wide Web Consortium, W3C, has just standardized a new  
version of the Web Ontology Language, OWL 2. Both OWL 2 and its  
predecessor are based on a family of logics, so-called “description  
logics” which have played a prominent role in the field of knowledge  
representation, esp. bio-medical informatics, for over 30 years. My  
research has played a key role in the development of these logics from  
the theory, to the development of reasoning techniques, to the  
application and in their standardization in the form of OWL and OWL 2.  
In collaboration with Prof. Ian Horrocks (who has recently moved from  
the University of Manchester to Oxford University), I have designed  
the logic and reasoning techniques for the description logics  
underlying both OWL (the logic “SHOIQ”) and OWL 2 (the logic  
“SROIQ”). Almost all DL reasoners are based on reasoning techniques  
developed by Sattler and Horrocks (e.g., Fact++, RacerPro, Pellet,  
Kaon2), related publications are highly cited (e.g., ISI WoK counts 45  
citations of "Query answering for OWL-DL with rules"), and OWL is  
widely used: e.g., it is used in the Systematized Nomenclature of  
Medicine — Clinical Term (SNOMED-CT), a key component of many  
national clinical information management systems.

PC co-chair of KR 2010

Member of the editorial board of JAIR (until 2005)

Member of the editorial board of JAR

Member of the W3C Web Ontology Working Group

PC co-chair OWLED 2008

Member of numerous programme committees: ESWC 2007-8  ISWC 2008, AAAI  
2008, AiML 2008,  DL 2008, and many more

This is a revised version of a paper in which the author describes a  
generalization of PDL that is motivated by the need to reason about  
semantic web services. In particular, PDL is extended with an operator  
that allows to state that an agent i can perform an action A, and a  
(propositional) form of pre-condition/post-condition operator (in  
contrast to the previous version, the converse operator is no longer  
present).  A Gentzen-style proof system is given, its soundness is  
proved, cuts are eliminated, a small model property is proven using a  
suitable extension of Fischer-Ladner closure, and thus decidability is  
concluded and an analysis of the size of the Fischer-Ladner closure  
together with a type elimination algorithm leads to an ExpTime upper  
bound for a certain fragment of the logic. Moreover, canonical models  
are defined, from which completeness of the proof system seems to be  
concluded. Finally, a 'positive' fragment is defined.

I still found the paper extremely dense and hard to follow: it lacks  
explanations of how the results obtained relate to the reasoning  
problems like regression, projection, or planning that have motivated  
the work. Some techniqual details were sloppily presented (see more  
detailed remarks below).

Moreover, and equally important, the author mentions and now discusses  
some related work and how this logic relates to applications, but the  
discussion is, on the one hand, still very superficial and, on the  
other hand, in some cases simply wrong - again, see below for more  
detailed remarks. For example, the pre-conditions/post-conditions in  
[3,4,18] are of a very different nature to those here in 2 ways: on  
the one hand, 'worlds' are structured interpretations in [3,4,18],  
whereas they are propositional in the present paper. On the other  
hand, [3,4,18] considers minimality of change, which isn't even  
mentioned here. Another example of lack of detail is the way the  
reasoning problems are discussed in 5.5: it is left unclear what the  
role of which part of the input is, and how this relates to an  
application scenario (i.e., why would i want to decide a projection  
problem, what would that tell me about my system?).

More detailed remarks:

- naming conventions of the logics investigated are sloppy: the main  
logic doesn't seem to have a name, the restricted logic defined in 3.5  
doesn't have on either, so complexity results are stated in an  
ambiguous way ("The logic"? "\phi"?) -- and then we come across a  
name, (G)RPDL(Cap) in Lemma 3.7 which is undefined...

- it would be helpfull to use either "AB" or "A,B" for the composition  
of actions, but not both

- are "basic actions" and "atomic processes" the same?! If yes, please  
unify. If no, explain, and also introduce "At" before using it (or  
don't use it)

- in an L-model N, why is it not \rho^N (cause we have \iota^N) or  
just \iota (cause we have just \rho)

- in the definition of the semantics, it seems as if the size of X  
could be chosen arbitrarily, e.g., to be 1. This together with the way  
in which the extension of \phi? and of \phi \Rightarrow \psi is  
defined seems wrong: why not define the latter as follows (which i  
think is clearer and closer to what the author had in mind):

   [\phi?]^N_\rho = {(v,v) \in W^2 | u \in [\phi]^N_\rho}

  [\phi \Rightarrow \psi]^N_\rho = {(u,v) \in W^2 | u \in  [\phi]^N_ 
\rho and  v \in  [\psi]^N_\rho }

- in 2.1.3., reasoning problems are introduced, but they aren't  
related at all to any application scenario: why would one be  
interested in those, and would do they tell me?

- in section 2.2., "we formalize the notion of logical consequence'  
sounds strange, after one has just seen the definition of consequence  
relations...

- in section 2.3, a canonical model is defined. First, S is defined as  
the set of maximal consistent sets....of what? Please clarify. More  
importantly, this seems highly redundant in the light of section 3:  
filtration gives us a (nice, well-understood, standard) canonical  
model. Why do you need both? This seems to be a "historic" artifact of  
the way the paper was written.

- Lemma 3.2 needs to be completely re-phrased (the first sentence is  
non-grammatical, and (i-v) is bad style).

- it would be nice to have the relevant corollary of section 3.1  
formulated in a corollary.

- section 3.2 isunconvincing: you claim to have proved the absence of  
a linear bound, but for your examples given, cardinality(FL(\phi)) < 2  
|\phi|....so that would be a  linear bound!

- around definition 3.5., the notion normally used there is 'modal  
depth'?! Also, a claim such as "which is not much loss, given our  
intended use of the system" is (i) too imprecise (how much is too  
much?) and (ii) would require some evidence/argument (why not?).

- I guess that FL(\phi) is exponential in the size of \phi for the  
unrestricted language? If yes, this should be mentioned -- as well as  
its consequences. E.g., you would get a more general theorem 3.8  
(e.g., even the unrestricted logic is decidable)! Also, what you would  
have proven for both logics is usually called a "Small Model Property"  
or "Bounded Model Property", both are stronger than FMP.

- Section 4, second paragraph: since the formula's satisfiability is  
to be checked...where do you get the canonical model from in case it's  
unsatisfiable?! And how does this canonical model relate to the two  
others that you have defined so far? It seems as if, by following the  
proof of [11] too closely, you made the reader work harder than  
necessary..this needs re-working. In addition, I'd recommend to think  
about using the rather more powerful technique of  Hintikka sets/types  
and standard "type elimination"?

- section 5.2 needs more detail: are there semantic differences? E.g.,  
if i restrict the use of the logic presented here to the usual PDL  
constructors, do models coincide?

- section 5.4: first, some DLs allow to express certain kind of role  
expressions - perhaps not enough to capture the logic presented here,  
but they do (intersection & implication are standard, negation is  
available in Boolean modal logics/ALB. Also, I couldn't make sense of  
the last paragraph.

- section 5.5: as mentioned above, the logics presented here and those  
discussed in [3,4,18] are very different.  The fact that the author  
doesn't mention any of the 2 differences is slightly worrying.

----------

Gottlob is undoubtedly an internationally leading researcher who has  
shown a sustained, excellent track record over the past 20 years. His  
work is

- highly cited (according to google scholar, he has 4 publications  
after 2000 that are cited over 300 times, and is an ISI Highly Cited  
author),

- highly influential (he has been fundamental in shaping datalog, the  
hypertree decomposition method has gained widespread attention and is  
applied in various areas, his insight into the intrinsic reasons for  
the complexity of XPath queries has led to a large number of further  
investigations and improvements),

- highly recognised (4 best paper awards in the last 7 years, 3 in the  
last 3 years, all at top rated conferences; over 40 invited talks;  
Fellow of the ACM, etc.), and

- of high quality (e.g., 11 J. ACM papers, 19 PODS paper).

He is and has been holding a significant number of grants, both from  
the EU and national research council. He has supervised an impressive  
number of students, many of which are now leading researchers  
themselves.

His research is mainly centered around methods for querying data, and  
is rather unusual in that it

- shows a large variety w.r.t. the *form* in which the data is stored  
(in relational databases, web or pdf documents, etc),

- is concerned with and informed by a deep understanding of the  
computational complexity of the underlying reasoning problems, and

- is driven by applications from the real world, and is used to  
develop solutions of real world problem. The Lixto system is a fine  
example of the outcome of the latter.

In summary, he has shown numerous times that he is able to confront  
major research challenges, and to initiate new productive lines of  
thinking.

--------
The research project is ambitious, timely, well-thought trough, and  
groundbreaking. It includes ambitious objects on a variety of levels,  
ranging from theoretical foundations of vertical analysis and search  
of web sites via two case studies through to the challenges of  
designing a full-blown system, and needs to combine different learning  
and abstraction methods with domain expert knowledge.

If successful, it will lead to an impressive number of scholarly  
papers on the underlying foundations and formalisms, and to the  
development of a technology that would solve what leading experts in  
the area regard as one of the core challenges regarding web- and  
document-based search. As a consequence, it will consolidate Europe's  
and Oxford University Computing Laboratory's international position in  
the area of Semantic Web Technologies, more precisely logic- and  
knowledge-based approaches to managing  information in  and extracting  
information from web documents.

The approach sketched in the proposal brings together an impressive  
variety of technologies, formalisms, and heuristics, and is thus of a  
formidable complexity. It involves design and investigations of the  
logic foundations as well as the development and combinations of  
existing approaches and heuristics. It is, however, building on  
existing work in the area, and doing so in an appropriate, incremental  
fashion. The design, implementation, and evaluation are closely  
interlinked and concerned with two concrete example cases, one of  
which is estate agents web sites.

Given the experience of the PI and his groups and collaborators and  
the careful, incremental design of the project,  I believe that this  
project is feasible. It is highly ambitious and thus involves a  
certain element of risk, but the structure of the project is such  
that, even if some of the pieces of the project turn out to be not  
feasible during the run of the project, the project as a whole is not  
at risk: it would still be producing theoretical results and  
technological contributions. More importantly, in case the project is  
successful, the achieved technological and scholarly advances will  
have indeed a major impact on the research area and the way we use and  
search the web in general.

--------------------------------------------

The research environment this project is located in could not be better.

First there is Oxford University in general and Oxford University  
Computing Laboratory, whose outstanding quality does not require any  
further commenting. What need commenting, however, is the way in which  
the PI is connected within OUCL, i.e., his on-going collaborations  
with Ian Horrocks, Boris Motik, Stephen Pullman, Yorrick Wilks, and  
others.  These connections and collaborations will be extremely useful  
for some of the phases and aspects of the projects.

Second, there is Gottlob's international network of colleagues with  
whom he has discussed ideas for this project, and  some of whom alreay  
have  algreed to visit him in Oxford.

Thirdly, there is the EU projects environment to be considered. Being  
a member of the FOX Network, and having already discussed DIADEM ideas  
with partners from the WedDAM and the SeCom project, Gottlob is  
already optimally linked to colleagues in Europe working on  
complementary aims.

In summary, Gottlob not only works in a research environment that is  
ideally suited for this kind of research to be carried out in, but he  
has been and is building, in a forward-looking, open way, a network of  
colleagues and projects with whom to work on this project.  Given the  
breadth of techniques involved and the degree of novelty and ambition  
of this project, this approach is  well-planned, suitable, and highly  
promising.

------------------------------------------------------------------
Semantic Technologies is a pathway that combines intelligent reasoning  
technologies from the "Logic and Automated Reasoning" theme with web  
and ontology related topics from the "Advanced Web Technologies"  
theme. Students chosing this pathway will thus gain insight into both  
topics, and how they can be used and combined fruitfully in ontology- 
based applications and the Semantic Web.

The paper tackles an interesting problem, but suffers from the  
following problems:

1) it is technically very vague: the information given on what kind of  
input the work is concerned with and what algorithm is used for the  
retrieval of search results is insufficient to evaluate the proposed  
method. For example, the idea that 'In general, ontologies can be  
interpreted as graphs' is rather naive even for RDFS ontologies, and  
more so for OWL ontologies: an explanation of how this graph is  
obtained from these ontologies would be required since there are many  
different such ways.

2)  The use case explained in section 3 seems to suggest that a nice  
*ranking* of the search results would be really useful -- and only  
then possibly an explanation. I have difficulties imagining a user who  
receives 20 documents for his search to be willing to look at  
explanations of them...

3) The related work discussed there completely ignores recent advances  
in explanations for semantic web ontologies -- none of the works that  
google returns for "explanation OWL" is mentioned or discussed. It  
might be the case that some of the assumptions underlying the work  
presented (see 1 above) imply that those explanations are irrelevant  
but, since they concern ontologies as well, this needs to be mentioned.

Leila	Amgoud	amgoud at irit.fr
Grigoris	Antoniou	antoniou at ics.forth.gr
Franz	Baader	baader at tcs.inf.tu-dresden.de
Philippe	Balbiani	balbiani at irit.fr
Chitta	Baral	chitta at asu.edu
Salem	Benferhat	benferhat at cril.univ-artois.fr
Brandon	Bennett	brandon at comp.leeds.ac.uk
Leopoldo	Bertossi	bertossi at scs.carleton.ca
Philippe	Besnard	besnard at irit.fr
Isabelle	Bloch	isabelle.bloch at enst.fr
Gerhard	Brewka	brewka at informatik.uni-leipzig.de
Diego	Calvanese	calvanese at inf.unibz.it
Xiaoping	Chen	xpchen at ustc.edu.cn
Sylvie	"Coste-Marquis"	coste at cril.univ-artois.fr
Adnan	Darwiche	darwiche at cs.ucla.edu
Ernest	Davis	davise at cs.nyu.edu
Giuseppe	"De Giacomo"	degiacomo at dis.uniroma1.it
James	Delgrande	jim at cs.sfu.ca
Marc	Denecker	marcd at cs.kuleuven.be
Juergen	Dix	dix at tu-clausthal.de
Carmel	Domshlak	cdomshlak at gmail.com
Didier	Dubois	dubois at irit.fr
Thomas	Eiter	eiter at kr.tuwien.ac.at
Ulle	Endriss	ulle at illc.uva.nl
Esra  	Erdem	esraerdem at sabanciuniv.edu
Boi	Faltings	Boi.Faltings at epfl.ch
Helene	Fargier	fargier at irit.fr
Michael 	Fisher	m.fisher at csc.liv.ac.uk
Enrico	Franconi	franconi at inf.unibz.it
Antony	Galton	apgalton at exeter.ac.uk
Hector	Geffner	hector.geffner at upf.edu
Michael	Gelfond	michael.gelfond at ttu.edu
Enrico	Giunchiglia	giunchiglia at unige.it
Nicola	Guarino	guarino at loa-cnr.it
Volker	Haarslev	haarslev at cse.concordia.ca
Joseph	Halpern	halpern at cs.cornell.edu
Andreas	Herzig	herzig at irit.fr
Pascal	Hitzler	hitzler at aifb.uni-karlsruhe.de
Ian	Horrocks	Ian.Horrocks at comlab.ox.ac.uk
Anthony	Hunter	a.hunter at cs.ucl.ac.uk
Tomi	Janhunen	Tomi.Janhunen at tkk.fi
Nick	Jennings	nrj at ecs.soton.ac.uk
Gabriele	"Kern-Isberner"	gabriele.kern-isberner at cs.uni-dortmund.de
Sebastien	Konieczny	konieczny at cril.fr
Gerhard	Lakemeyer	gerhard at cs.rwth-aachen.de
Jerome	Lang	lang at irit.fr
Jooyong	Lee	joolee at asu.edu chair
Nicola	Leone	leone at mat.unical.it chair
Yves	Lesperance	lesperan at cse.yorku.ca
Hector	Levesque	hector at cs.toronto.edu
Paolo	Liberatore	liberato at dis.uniroma1.it
Vladimir	Lifschitz	vl at cs.utexas.edu
John	Lloyd	john.lloyd at anu.edu.au
Thomas	Lukasiewicz	Thomas.Lukasiewicz at comlab.ox.ac.uk

Pierre	Marquis	marquis at cril.univ-artois.fr
Sheila	McIlraith	sheila at cs.toronto.edu
"John-Jules"	Meyer	jj at cs.uu.nl
Thomas	Meyer	tommie.meyer at meraka.org.za
Ralf	Moeller	r.f.moeller at tu-harburg.de
Leora	Morgenstern	leora at steam.stanford.edu
Ilkka	Niemela	Ilkka.Niemela at tkk.fi
Maurice	Pagnucco	morri at cse.unsw.edu.au
Peter	"Patel-Schneider"	pfps at research.bell-labs.com
Bijan	Parsia	bparsia at cs.man.ac.uk
Ramon	Pino Perez	pino at ula.ve
HSofia	Pinto	sofia at algos.inesc-id.pt
Fiora	Pirri	pirri at dis.uniroma1.it
David	Poole	poole at cs.ubc.ca
Henry	Prakken	henry at cs.uu.nl
R.	Ramanujam	jam at imsc.res.in
Riccardo	Rosati	rosati at dis.uniroma1.it
Francesca	Rossi	frossi at math.unipd.it
Torsten	Schaub	torsten at cs.uni-potsdam.de
Luciano	Serafini	serafini at fbk.eu
Stuart	Shapiro	shapiro at cse.buffalo.edu
Munindar	Singh	singh at ncsu.edu
"Trao Can"	Son	tson at cs.nmsu.edu
Mikhail	Soutchanski	mes at scs.ryerson.ca
"V.S."	Subrahmanian	vs at cs.umd.edu
Annette	"ten Teije"	annette at cs.vu.nl
Michael	Thielscher	mit at inf.tu-dresden.de
Pietro	Torasso	torasso at di.unito.it
Wiebe	van der Hoek	wiebe at csc.liv.ac.uk
Leon	van der Torre	leon.vandertorre at uni.lu
Laure	Vieu	vieu at irit.fr
Kewen	Wang	K.Wang at griffith.edu.au
Chris	Welty	cawelty at gmail.com
"Mary-Anne"	Williams	mary-anne at it.uts.edu.au
Frank	Wolter	wolter at liverpool.ac.uk
Michael	Wooldridge	mjw at csc.liv.ac.uk
"Jia-Huai"	You	you at cs.ualberta.ca
Yan	Zhang	yan at cit.uws.edu.au
Mingyi	Zhang	zhangmingyi045 at yahoo.com.cn

<?xml version="1.0"?>

<!DOCTYPE Ontology [
    <!ENTITY owl "http://www.w3.org/2002/07/owl#" >
    <!ENTITY dc "http://purl.org/dc/elements/1.1/" >
    <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
    <!ENTITY owl2xml "http://www.w3.org/2006/12/owl2-xml#" >
    <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
    <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
    <!ENTITY ontologies "http://www.semanticweb.org/ontologies/ 
2009/5/" >
    <!ENTITY ML2 "http://www.semanticweb.org/ontologies/2009/5/ 
ML&amp;" >
    <!ENTITY MoL "http://www.semanticweb.org/ontologies/2009/5/ 
MoL&amp;" >
    <!ENTITY SSD "http://www.semanticweb.org/ontologies/2009/5/ 
SSD&amp;" >
    <!ENTITY SSW "http://www.semanticweb.org/ontologies/2009/5/ 
SSW&amp;" >
    <!ENTITY Grid "http://www.semanticweb.org/ontologies/2009/5/ 
Grid&amp;" >
    <!ENTITY Hack "http://www.semanticweb.org/ontologies/2009/5/ 
Hack&amp;" >
    <!ENTITY Comp "http://www.semanticweb.org/ontologies/2009/5/ 
Comp&amp;" >
    <!ENTITY Modell "http://www.semanticweb.org/ontologies/2009/5/Modell&amp 
;" >
    <!ENTITY Distrib "http://www.semanticweb.org/ontologies/2009/5/Distrib&amp 
;" >
    <!ENTITY Ontology1245861313437 "http://www.semanticweb.org/ontologies/2009/5/Ontology1245861313437.owl# 
" >
    <!ENTITY ML "http://www.semanticweb.org/ontologies/2009/5/Ontology1245861313437.owl#ML 
&amp;" >
    <!ENTITY RS "http://www.semanticweb.org/ontologies/2009/5/Ontology1245861313437.owl#RS 
&amp;" >
    <!ENTITY HCI "http://www.semanticweb.org/ontologies/2009/5/Ontology1245861313437.owl#HCI 
&amp;" >
    <!ENTITY Data "http://www.semanticweb.org/ontologies/2009/5/Ontology1245861313437.owl#Data 
&amp;" >
    <!ENTITY Logic "http://www.semanticweb.org/ontologies/2009/5/Ontology1245861313437.owl#Logic 
&amp;" >
]>

<Ontology xmlns="http://www.w3.org/2006/12/owl2-xml#"
     xml:base="http://www.w3.org/2006/12/owl2-xml#"
     xmlns:owl2xml="http://www.w3.org/2006/12/owl2-xml#"
     xmlns:Distrib="&ontologies;Distrib&amp;"
     xmlns:Data="&ontologies;Ontology1245861313437.owl#Data&amp;"
     xmlns:MoL="&ontologies;MoL&amp;"

xmlns:Ontology1245861313437="&ontologies;Ontology1245861313437.owl#"
     xmlns:Grid="&ontologies;Grid&amp;"
     xmlns:HCI="&ontologies;Ontology1245861313437.owl#HCI&amp;"
     xmlns:Hack="&ontologies;Hack&amp;"
     xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
     xmlns:Logic="&ontologies;Ontology1245861313437.owl#Logic&amp;"
     xmlns:RS="&ontologies;Ontology1245861313437.owl#RS&amp;"
     xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
     xmlns:SSW="&ontologies;SSW&amp;"
     xmlns:owl="http://www.w3.org/2002/07/owl#"
     xmlns:Modell="&ontologies;Modell&amp;"
     xmlns:Comp="&ontologies;Comp&amp;"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:SSD="&ontologies;SSD&amp;"
     xmlns:ML2="&ontologies;ML&amp;"
     xmlns:ontologies="http://www.semanticweb.org/ontologies/2009/5/"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:ML="&ontologies;Ontology1245861313437.owl#ML&amp;"
     URI="&ontologies;Ontology1245861313437.owl">
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Class URI="&owl;Thing"/>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <ObjectSomeValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
            <Class  
URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        </ObjectSomeValuesFrom>
    </SubClassOf>
    <EquivalentClasses>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitCS"/>
        <ObjectIntersectionOf>
            <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
            <ObjectHasValue>
                <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
                <Individual  
URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
            </ObjectHasValue>
        </ObjectIntersectionOf>
    </EquivalentClasses>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitCS"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </SubClassOf>
    <EquivalentClasses>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitsNonCS"/>
        <ObjectIntersectionOf>
            <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
            <ObjectComplementOf>
                <ObjectHasValue>
                    <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
                    <Individual  
URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
                </ObjectHasValue>
            </ObjectComplementOf>
        </ObjectIntersectionOf>
    </EquivalentClasses>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitsNonCS"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </SubClassOf>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#ExternalLecturer"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Class URI="&owl;Thing"/>
    </SubClassOf>
    <EquivalentClasses>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#NewCourseUnitsCS"/>
        <ObjectIntersectionOf>
            <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitCS"/>
            <ObjectComplementOf>
                <Class  
URI="&ontologies;Ontology1245861313437.owl#OldCourseUnitsCS"/>
            </ObjectComplementOf>
        </ObjectIntersectionOf>
    </EquivalentClasses>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#NewCourseUnitsCS"/>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitCS"/>
    </SubClassOf>
    <EquivalentClasses>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#OldCourseUnitsCS"/>
        <DataSomeValuesFrom>
            <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
            <Datatype URI="&xsd;string"/>
        </DataSomeValuesFrom>
    </EquivalentClasses>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#OldCourseUnitsCS"/>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitCS"/>
    </SubClassOf>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P1CourseUnit"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </SubClassOf>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P1CourseUnit"/>
        <ObjectAllValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
            <Class URI="&owl;Nothing"/>
        </ObjectAllValuesFrom>
    </SubClassOf>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P1CourseUnit"/>
        <DataHasValue>
            <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
            <Constant>1</Constant>
        </DataHasValue>
    </SubClassOf>
    <EquivalentClasses>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P2CourseUnit"/>
        <ObjectSomeValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
            <ObjectAllValuesFrom>
                <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
                <Class URI="&owl;Nothing"/>
            </ObjectAllValuesFrom>
        </ObjectSomeValuesFrom>
    </EquivalentClasses>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P2CourseUnit"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </SubClassOf>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P2CourseUnit"/>
        <DataHasValue>
            <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
            <Constant>2</Constant>
        </DataHasValue>
    </SubClassOf>
    <EquivalentClasses>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P3-4CourseUnit"/>
        <ObjectSomeValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
            <ObjectSomeValuesFrom>
                <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
                <ObjectAllValuesFrom>
                    <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
                    <Class URI="&owl;Nothing"/>
                </ObjectAllValuesFrom>
            </ObjectSomeValuesFrom>
        </ObjectSomeValuesFrom>
    </EquivalentClasses>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P3-4CourseUnit"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </SubClassOf>
    <SubClassOf>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#P3-4CourseUnit"/>
        <DataHasValue>
            <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
            <Constant>3 or 4</Constant>
        </DataHasValue>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Class URI="&owl;Thing"/>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <ObjectMinCardinality cardinality="2">
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasTheme"/>
            <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        </ObjectMinCardinality>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#School"/>
        <Class URI="&owl;Thing"/>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Class URI="&owl;Thing"/>
    </SubClassOf>
    <SubClassOf>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <ObjectExactCardinality cardinality="1">
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
            <Class  
URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        </ObjectExactCardinality>
    </SubClassOf>
    <InverseObjectProperties>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#belongs2theme"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
    </InverseObjectProperties>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#belongs2theme"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#belongs2theme"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
    </ObjectPropertyRange>
    <SubObjectPropertyOf>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
    </SubObjectPropertyOf>
    <SubObjectPropertyOf>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
    </SubObjectPropertyOf>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
    </ObjectPropertyRange>
    <InverseObjectProperties>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#belongs2theme"/>
    </InverseObjectProperties>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </ObjectPropertyRange>
    <InverseObjectProperties>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasTheme"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#belongs2pathway"/>
    </InverseObjectProperties>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasTheme"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasTheme"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
    </ObjectPropertyRange>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
    </ObjectPropertyRange>
    <SubObjectPropertyOf>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasTheme"/>
    </SubObjectPropertyOf>
    <SubObjectPropertyOf>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasTheme"/>
    </SubObjectPropertyOf>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#School"/>
    </ObjectPropertyRange>
    <TransitiveObjectProperty>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requires"/>
    </TransitiveObjectProperty>
    <SubObjectPropertyOf>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requires"/>
    </SubObjectPropertyOf>
    <ObjectPropertyDomain>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </ObjectPropertyDomain>
    <ObjectPropertyRange>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </ObjectPropertyRange>
    <DataPropertyDomain>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </DataPropertyDomain>
    <DataPropertyRange>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Datatype URI="&xsd;string"/>
    </DataPropertyRange>
    <DataPropertyDomain>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <ObjectUnionOf>
            <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
            <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        </ObjectUnionOf>
    </DataPropertyDomain>
    <DataPropertyRange>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Datatype URI="&xsd;string"/>
    </DataPropertyRange>
    <DataPropertyDomain>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <ObjectUnionOf>
            <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
            <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
            <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        </ObjectUnionOf>
    </DataPropertyDomain>
    <DataPropertyRange>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Datatype URI="&xsd;string"/>
    </DataPropertyRange>
    <DataPropertyDomain>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasName"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
    </DataPropertyDomain>
    <DataPropertyRange>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasName"/>
        <Datatype URI="&xsd;string"/>
    </DataPropertyRange>
    <DataPropertyDomain>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </DataPropertyDomain>
    <DataPropertyRange>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Datatype URI="&xsd;string"/>
    </DataPropertyRange>
    <DataPropertyDomain>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
    </DataPropertyDomain>
    <DataPropertyRange>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Datatype URI="&xsd;string"/>
    </DataPropertyRange>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;AdvAR"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;AdvAR"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;AdvAR"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RenateS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;AdvAR"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;AdvAR"/>
        <Individual URI="&ontologies;FOL"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;AdvAR"/>
        <Constant
            >Advanced Automated Reasoning</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;AdvAR"/>
        <Constant>COMP60121</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;AdvAR"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;AdvPDBs"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;AdvPDBs"/>
    </ClassAssertion>
    <ClassAssertion>
        <DataAllValuesFrom>
            <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
            <DataComplementOf>
                <Datatype URI="&xsd;string"/>
            </DataComplementOf>
        </DataAllValuesFrom>
        <Individual URI="&ontologies;AdvPDBs"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;AdvPDBs"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SandraS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;AdvPDBs"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#GoranN"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;AdvPDBs"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;AdvPDBs"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;AdvPDBs"/>
        <Constant
            >Advanced practical databases (design, maintenance)</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;AdvPDBs"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AlvaroF"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Individual URI="&ontologies;AdvPDBs"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Constant
            >Advanced Database Management Systems (HP querying)</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Constant>COMP60361</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#Med"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
        <Individual URI="&ontologies;HealthInf"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
        <Constant>MEDN60172</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
        <Constant
            >Clinical Decision Support Systems</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NingZ"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DanielD"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Individual URI="&ontologies;Crypto"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Constant
            >Computer and Network Security</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Constant>COMP60391</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;CompAnimation"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;CompAnimation"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MartinT"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AphroG"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#TobyH"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Individual URI="&ontologies;CompVision"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Constant
            >Computer Graphics and Animation</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Constant>COMP60321</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;CompAnimation"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;CompBSD"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;CompBSD"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;CompBSD"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#KingKiuL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;CompBSD"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;CompBSD"/>
        <Individual URI="&ontologies;SE-P"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;CompBSD"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;CompBSD"/>
        <Constant
            >Component-based Software Development</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;CompBSD"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;CompVision"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;CompVision"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;CompVision"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CaroleT"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;CompVision"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AphroG"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;CompVision"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;CompVision"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;CompVision"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;CompVision"/>
        <Constant>Computer Vision</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;CompVision"/>
        <Constant>COMP60442</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;CompVision"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Crypto"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Crypto"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Crypto"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RichardB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Crypto"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Crypto"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Crypto"/>
        <Constant
            >Cryptography and data security</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Crypto"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;DialogSys"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#NewCourseUnitsCS"/>
        <Individual URI="&ontologies;DialogSys"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;DialogSys"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#KeC"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AllanR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Individual URI="&ontologies;NLPPrinc."/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Constant>Dialog Systems</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;DialogSys"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#NewCourseUnitsCS"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
        <Constant
            >Paradigms in Parallel and Distributed Computing</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;FOL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#NewCourseUnitsCS"/>
        <Individual URI="&ontologies;FOL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;FOL"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;FOL"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AndreiV"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;FOL"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;FOL"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;FOL"/>
        <Constant
            >Logic and Applications </Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;FOL"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;FuMuCore"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;FuMuCore"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MikelL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#IanW"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Constant
            >Future Multi Core</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Constant>COMP60012</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;FuMuCore"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
        <Constant
            >Grid-, Cloud-, and location-independent Computing</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
        <Constant>COMP60021</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class  
URI="&ontologies;Ontology1245861313437.owl#CourseUnitsNonCS"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
    </ClassAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
        <Constant
            >Hacking &amp; Anti-hacking</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >this is currently in discussion with a friend of Mark  
vHarmelen</Constant>
        </Annotation>
    </EntityAnnotation>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;HealthInf"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;HealthInf"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#Med"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;HealthInf"/>
        <Individual URI="&ontologies;Intro2CB"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;HealthInf"/>
        <Constant>MEDN70991</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;HealthInf"/>
        <Constant
            >Health Informatics</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Intro2CB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Intro2CB"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Intro2CB"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AndyB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Intro2CB"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RobertS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Intro2CB"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Intro2CB"/>
        <Constant>COMP60311</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Intro2CB"/>
        <Constant
            >Computational Biology - The Application of Computer  
Science to the Problems of Post-Genome Biology</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Intro2CB"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ClassAssertion>
    <ClassAssertion>
        <ObjectAllValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
            <Class URI="&owl;Nothing"/>
        </ObjectAllValuesFrom>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MagnusR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#GavinB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Constant
            >Machine Learning and Data Mining</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Constant>COMP60431</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RenateS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#UliS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Individual URI="&ontologies;FOL"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Constant
            >Modal Logic and Description Logics</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Constant>COMP60161</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;MobSys"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;MobSys"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;MobSys"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SteveF"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;MobSys"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;MobSys"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;MobSys"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;MobSys"/>
        <Constant>Mobile Systems</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;MobSys"/>
        <Constant>COMP60041</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;MobSys"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;MobileComm"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;MobileComm"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NickF"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BarryC"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Individual URI="&ontologies;MobSys"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Constant
            >Mobile Communications</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Constant>COMP60242</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;MobileComm"/>
        <Constant>3</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NeilL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
        <Constant
            >Modelling and visualization of high-dimensional data</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;NLPPrinc."/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;NLPPrinc."/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#IanPH"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AllanR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Individual URI="&ontologies;FOL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Constant
            >Principles of Natural Language Processing</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;NLPPrinc."/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ClassAssertion>
    <ClassAssertion>
        <ObjectAllValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
            <Class URI="&owl;Nothing"/>
        </ObjectAllValuesFrom>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SeanB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BijanP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Constant
            >Ontology Engineering for the Semantic Web</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Constant>COMP60462</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;OntEng4SW"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AI"/>
        <Constant
            >Artificial Intelligence</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Individual URI="&ontologies;W2.04Science"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SeanB"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Constant
            >This theme aims to provide students with an overview and  
understanding of a number of advanced web technologies, which are  
being used to facilitate the move from a web from a web of documents,  
to a web of documents, data and applications. The theme will cover  
technological aspects, such as languages for representing documents  
(HTML/CSS), for working with semi-structured data (XML/XSLT) and for  
knowledge representation (OWL/RDF), along with the theory and  
methodologies behind the use of such languages. The theme also  
discusses human factors issues surrounding the Web and investigates  
the use of advanced web technologies to support science. This is not a  
course aimed at those who wish to build web sites, but is for those  
students who are seeking a deeper understanding of the technologies  
that are being used to support the continuing evolution of the Web.</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
        <Constant
            >Advanced Web Technologies</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
        <Constant
            >Advanced Web Technologies</Constant>
    </DataPropertyAssertion>
    <Declaration>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTechPW"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AllanR"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AllanR"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AlvaroF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AlvaroF"/>
    </ClassAssertion>
    <Declaration>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AndreiV"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AndyB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AndyB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AphroG"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AphroG"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BarryC"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BarryC"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BijanP"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BijanP"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SysBio"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
        <Individual URI="&ontologies;Intro2CB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AndyB"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
        <Constant
            >Computational Biology</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
        <Individual URI="&ontologies;HealthInf"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
        <Individual URI="&ontologies;CliDecSupSys"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
        <Individual URI="&ontologies;Intro2CB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AndyB"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
        <Constant
            >Bio-Health Informatics</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ThierryS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
        <Constant>COMP67032</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
        <Constant
            >Building Web Applications</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BuildingWebApps"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CaroleT"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CaroleT"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ChrisH"/>
    </ClassAssertion>
    <Declaration>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ChrisH"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompEng"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompEng"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompEng"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompEng"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompEng"/>
        <Constant
            >Computer Systems Engineering</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompSec"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompSec"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompSec"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompSec"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompSec"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#CompSec"/>
        <Constant
            >Computer Security</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Individual URI="&ontologies;FuMuCore"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnG"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Constant
            >Microprocessor manufacturers have recently presented the  
software industry with its most serious challenge ever, by switching  
from serial execution architectures clocked at ever-increasing clock  
rates to ever-more parallel multi-core architectures clocked at a  
constant (or even decreasing) clock rate. The consequences will be  
profound because concurrent computational activities will need to be  
handled as the norm, rather than the exception; programmers of the  
future will need skills that are currently possessed by very few, due  
to the inherent complexities of concurrent systems. This  
&#8220;Concurrency&#8221; theme introduces students to the  
aforementioned complexities, and provides techniques and tools that  
can alleviate the ensuing problems of correctness, reliability,  
performance and system management.  </Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
        <Constant>Concurrency</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DanielD"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DanielD"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Data&amp;KnowledgeMgmnt"/>
        <Constant
            >Data and Knowledge Management</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Individual URI="&ontologies;AdvPDBs"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Individual URI="&ontologies;AdvancDBMSs"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnK"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
        <Constant>Data Management</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DecBehaviour"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DecBehaviour"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DecBehaviour"/>
        <Constant>BMAN 61102</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DecBehaviour"/>
        <Constant
            >Decision Behaviour, Analysis and Support</Constant>
    </DataPropertyAssertion>
    <Declaration>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DecBehaviour"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#DigBio"/>
        <Constant>Digital Biology</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#School"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#FLS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#FLS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#GavinB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#GavinB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#GoranN"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#GoranN"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#HCI&amp;WI"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#HCI&amp;WI"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#HCI&amp;WI"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#HCI&amp;WI"/>
        <Constant>BMAN71642</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#HCI&amp;WI"/>
        <Constant
            >HCI and Web User Interfaces</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ILF"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ILF"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ILF"/>
        <Constant>BMAN71621</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ILF"/>
        <Constant
            >Industrial Leadership Forum</Constant>
    </DataPropertyAssertion>
    <Declaration>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ILF"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ISStrategy"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ISStrategy"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ISStrategy"/>
        <Constant>BMAN60111</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ISStrategy"/>
        <Constant
            > IS Strategy and Enterprise Systems</Constant>
    </DataPropertyAssertion>
    <Declaration>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ISStrategy"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ITM"/>
        <Constant>IT Management</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#IanPH"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#IanPH"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#IanW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#IanW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AndyB"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
        <Individual URI="&ontologies;Intro2CB"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
        <Constant
            >Introduction to BioHealth Informatics</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
        <Constant>COMP60302</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnG"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnG"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnK"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnMN"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnMN"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JonS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JonS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JoshK"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JoshK"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#JunichiT"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#JunichiT"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#KeC"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#KeC"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#KingKiuL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#KingKiuL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#KonstantinK"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#KonstantinK"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#LenF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#LenF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#LipingZ"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#LipingZ"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
        <Individual URI="&ontologies;MoL&amp;DL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
        <Individual URI="&ontologies;FOL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
        <Individual URI="&ontologies;AdvAR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RenateS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
        <Constant
            >Logic &amp; Automated Reasoning</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#School"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
        <Individual URI="&ontologies;Optimisation"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MagnusR"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
        <Constant
            >Machine Learning and Optimisation</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MagnusR"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MagnusR"/>
    </ClassAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasName"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MagnusR"/>
        <Constant>Magnus Rattray</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
    </ClassAssertion>
    <ClassAssertion>
        <ObjectAllValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
            <ObjectAllValuesFrom>
                <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
                <ObjectOneOf>
                    <Individual  
URI="&ontologies;Ontology1245861313437.owl#MBS"/>
                </ObjectOneOf>
            </ObjectAllValuesFrom>
        </ObjectAllValuesFrom>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ISStrategy"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DecBehaviour"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ILF"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#PM"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NickF"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Constant
            >This information-centric theme is designed for computer
scientists who have the desire to drive technology into effective
use in business.  Information systems are pervasive in every
aspect of industry, business and society and therefore there is growing
demand for people who have a high level of technical knowledge and are
prepared for a leadership role, utilising entrepreneurial and management
skills in the solution of business problems.

This theme will provide the technology competent graduate with the
additional skills required to take up this challenge.</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Constant>IT Management</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >this is not really a theme - but the set of MBS CUs  
for ACS with ITM</Constant>
        </Annotation>
    </EntityAnnotation>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MartinT"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MartinT"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#School"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#Med"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#Med"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MikelL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MikelL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
        <Individual URI="&ontologies;MobSys"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
        <Individual URI="&ontologies;MobileComm"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NickF"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
        <Constant datatypeURI="&xsd;string"
            >This theme aims to provide students with an overview of  
the current
state of the art in computing to support mobility for telecommunications
(mobile phones), PDAs and laptop/netbook systems. The theme discusses  
the example wireless systems and the different ways they work, the  
design of low-power hardware for battery driven applications and the  
way in which distribution is supported and exploited in mobile  
applications
running on mobile operating systems. </Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
        <Constant
            >Mobile Computing</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Concurrency"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioHealthApplications"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#BioApplications"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Management"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MobileComputing"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Constant
            >Microprocessor manufacturers have recently presented the  
software industry with its most serious challenge ever, by switching  
from serial execution architectures clocked at ever-increasing clock  
rates to ever-more parallel multi-core architectures clocked at a  
constant (or even decreasing) clock rate. The consequences will be  
profound because concurrent computational activities will need to be  
handled as the norm, rather than the exception; programmers of the  
future will need skills that are currently possessed by very few, due  
to the inherent complexities of concurrent systems. This pathway is  
centred round a core &#8220;Concurrency&#8221; theme that introduces  
students to the aforementioned complexities, and provides techniques  
and tools that can alleviate the ensuing problems of correctness,  
reliability, performance and system management. Subsidiary themes  
allow students to investigate broader areas in which they might apply  
their newly learned skills.</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MultiCC"/>
        <Constant
            >Multi-Core Computing</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
        <Individual URI="&ontologies;FOL"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
        <Individual URI="&ontologies;NLPPrinc."/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AllanR"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
        <Constant
            >The Natural Language Processing theme covers the major  
topics required
for writing general purpose natural language processing
systems. Natural language processing draws on ideas and techniques
from a range of areas--linguistics, for the fundamental notions of how
languages work; logic, for ideas about meaning; machine learning, for
acquiring patterns of usage from text.  The units that make up this
theme provide students with the background required for developing
systems that can understand and generate natural language texts for a
variety of purposes.</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
        <Constant
            >Natural Language Processing</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
        <Individual URI="&ontologies;DialogSys"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
        <Individual URI="&ontologies;TextMining"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AllanR"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
        <Constant
            >Natural language processing systems have a variety of  
potential
applications. Two particularly important areas are extracting
information from large collections of material, e.g. from scientific
literature in areas like biomedical research, and providing user
interfaces to a range of applications. The Applications of NLP theme
extends the fundamental ideas introduced in the Natural Language
Processing theme to these applications, using a variety of practical
tools to back up the theoretical discussion and to allow students to
explore the power and limitations of current technology in this area.</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
        <Constant
            >Applications of Natural Language Processing</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLPPW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLPPW"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLPPW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLPPW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#NLPApps"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLPPW"/>
        <Constant
            >Natural languages are the languages that people use, for  
communicating
with one another, and for recording their ideas. If computers could
understand these languages, they would be easier to use, and they
would have access to all the information that people have written
down. The Natural Language Processing theme provides a thorough
grounding in the area, so that students with no background in it can
follow the advanced units; the Applications of NLP theme then covers
the theory, and practical issues, of systems that can interact with a
user in natural language; and of systems for extracting information
from large amounts of text, either open-ended resources like the
entire web or more constrained technical knowledge-bases such as
collections of journal articles.</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NLPPW"/>
        <Constant
            >Natural Language Processing</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NeilL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NeilL"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NickF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NickF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NingZ"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NingZ"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#PM"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#MBS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#PM"/>
        <Constant
            >Project Management</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;Ontology1245861313437.owl#PM"/>
        <Annotation annotationURI="&dc;subject">
            <Constant
                >successor of &quot;IT Trends&quot;</Constant>
        </Annotation>
    </EntityAnnotation>
    <Declaration>
        <Individual URI="&ontologies;Ontology1245861313437.owl#PM"/>
    </Declaration>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MagnusR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
        <Constant>COMP60991</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
        <Constant
            >Research Skills &amp; Professional Issues</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RS&amp;PI"/>
        <Constant>1 - 3</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RenateS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RenateS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RichardB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RichardB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RobertS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#RobertS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
        <Individual URI="&ontologies;CompBSD"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
        <Individual URI="&ontologies;PatternBSD"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
        <Individual URI="&ontologies;SE-P"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#KingKiuL"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
        <Constant
            >The impact of Software Engineering on everyday life is  
ever increasing, as software becomes all pervasive. This theme starts  
with an overview of existing approaches to Software Engineering,  
evaluating their pros and cons, and then provides an introduction to  
two particular approaches at the forefront of Software Engineering  
research and practice,  Pattern-based and Component-based  Software  
Development.  </Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
        <Constant
            >Software Engineering</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SEPW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SEPW"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SEPW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SE"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SEPW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SEPW"/>
        <Constant
            >Software Engineering</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SandraS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SandraS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SeanB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SeanB"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
        <Individual URI="&ontologies;Hack&amp;Antih"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
        <Individual URI="&ontologies;Comp&amp;NW-Security"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
        <Individual URI="&ontologies;Crypto"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#NingZ"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasDescription"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
        <Constant
            >While a large-scale application of the Internet and  
telecommunication technologies has made our daily communications and  
data and services accesses faster, cheaper and at anytime, regardless  
of national and/or geographic boundaries, it also routinely generates  
enormous amount of information that is transmitted, processed, stored,  
and managed on networked systems on a global scale. Information  
recorded electronically on a networked system is particularly  
vulnerable to security threats, such as theft, manipulation or misuse  
of valuable or confidential information, deliberate damage to systems  
and services, and fraud and forgeries in e-business dealings. These  
threats could endanger national security, business interests, and  
personal privacy. The field of Security, namely the study of  
countermeasures to address these serious security threats, is  
therefore of paramount importance to our quality of life.
This Security theme is aimed at introducing the technologies,  
standards, policies, procedures and practices that can be used to  
secure information, computer systems and networks. It embraces a range  
of technologies such as cryptography, computer security, and network  
security, and also includes risk assessment procedures and the study  
of how security can best be managed.</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Security"/>
        <Constant>Security</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SemWebTech"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SemWebTech"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SemWebTech"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Logic&amp;AR"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SemWebTech"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SemWebTech"/>
        <Constant
            >Semantic Web Technologies</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SimonH"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SimonH"/>
    </ClassAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasName"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SimonH"/>
        <Constant>Simon Harper</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#School"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SophiaA"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#SophiaA"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SteveF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SteveF"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SteveP"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SteveP"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SysBio"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SysBio"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SysBio"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SysBio"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#Intro2BiohealthInfo"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SysBio"/>
        <Constant>Systems Biology</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ThierryS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ThierryS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#TimM"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#TimM"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#TobyH"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#TobyH"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Lecturer"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#UliS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#UliS"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Individual URI="&ontologies;ML&amp;DM"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Individual URI="&ontologies;CompVision"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Individual URI="&ontologies;PerceptInterf"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Individual URI="&ontologies;CompAnimation"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Individual URI="&ontologies;ScientificVis"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AphroG"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#VisualComputing"/>
        <Constant
            >Visual Computing</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Theme"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
        <Individual URI="&ontologies;Grid&amp;Cloud"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
        <Individual URI="&ontologies;W2.04Science"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasOptionalCU"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
        <Individual URI="&ontologies;ScientificVis"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeLeader"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnB"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
        <Constant>eScience</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#Pathway"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption1"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eScience"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#AdvWebTech"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#ML&amp;O"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasThemeOption2"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#DataManagement"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#eSciencePW"/>
        <Constant>eScience</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;Optimisation"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;Optimisation"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JoshK"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JonS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Individual URI="&ontologies;Modell&amp;VisI"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Constant
            >Optimization for learning, planning and problem-solving</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;Optimisation"/>
        <Constant>3</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;PatternBSD"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;PatternBSD"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;PatternBSD"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#LipingZ"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;PatternBSD"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;PatternBSD"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;PatternBSD"/>
        <Constant
            >Pattern-based Software Development</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;PatternBSD"/>
        <Constant>COMP67052</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;PatternBSD"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;PerceptInterf"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;PerceptInterf"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#AphroG"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#TimM"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Individual URI="&ontologies;CompVision"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Constant
            >Perceptual Interfaces</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;PerceptInterf"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
        <Constant
            >Practical Concurrent Programming for Business</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;PractConcProg4Busin"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
        <Individual URI="&ontologies;Distrib&amp;ParaComp-P"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
        <Constant
            >Practical Concurrent Programming for System Software</ 
Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;PractConcProg4SSW"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;SE-P"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;SE-P"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;SE-P"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#ChrisH"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;SE-P"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;SE-P"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;SE-P"/>
        <Constant
            >Software Engineering Overview</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;SE-P"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;SE-P"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >this might be turned into SoA?</Constant>
        </Annotation>
    </EntityAnnotation>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
    </ClassAssertion>
    <ClassAssertion>
        <ObjectAllValuesFrom>
            <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
            <Class URI="&owl;Nothing"/>
        </ObjectAllValuesFrom>
        <Individual URI="&ontologies;SSD&amp;Web"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#UliS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#BijanP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Constant
            >Semi-structured Data and the Web</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Constant>COMP60372</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;SSD&amp;Web"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
        <Constant
            >Serial Software &amp; its effects on hardware  
performance</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
        <Constant>1</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;SSW&amp;HWPerf"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >difficult to schedule in concurrency theme</Constant>
        </Annotation>
    </EntityAnnotation>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;ScientificVis"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;ScientificVis"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;ScientificVis"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SteveP"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;ScientificVis"/>
        <Individual  
URI="&ontologies;Ontology1245861313437.owl#MartinT"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;ScientificVis"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;ScientificVis"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;ScientificVis"/>
        <Constant
            >Scientific Visualistion</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;ScientificVis"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;ScientificVis"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >this is the 5th CU in &#39;visual  
computing&#39;...isn&#39;t this too much? And what are its  
prerequisites?</Constant>
        </Annotation>
    </EntityAnnotation>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;TextMining"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;TextMining"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasPotentialLecturer"/>
        <Individual URI="&ontologies;TextMining"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#JohnMN"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;TextMining"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;TextMining"/>
        <Individual URI="&ontologies;OntEng4SW"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#requiresdirectly"/>
        <Individual URI="&ontologies;TextMining"/>
        <Individual URI="&ontologies;NLPPrinc."/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;TextMining"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;TextMining"/>
        <Constant>Textmining</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;TextMining"/>
        <Constant>2</Constant>
    </DataPropertyAssertion>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;W2.04Science"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;W2.04Science"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;W2.04Science"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasCode"/>
        <Individual URI="&ontologies;W2.04Science"/>
        <Constant>COMP6????</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;W2.04Science"/>
        <Constant
            >Web2.0 and Social Networking for Science</Constant>
    </DataPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#taughtInPeriod"/>
        <Individual URI="&ontologies;W2.04Science"/>
        <Constant>3 or 4</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;W2.04Science"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >who teaches this? CaroleG?</Constant>
        </Annotation>
    </EntityAnnotation>
    <ClassAssertion>
        <Class URI="&ontologies;Ontology1245861313437.owl#CourseUnit"/>
        <Individual URI="&ontologies;WebErgonomics"/>
    </ClassAssertion>
    <ClassAssertion>
        <Class URI="&owl;Thing"/>
        <Individual URI="&ontologies;WebErgonomics"/>
    </ClassAssertion>
    <ClassAssertion>
        <DataAllValuesFrom>
            <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#supercedesCUwithCode"/>
            <DataComplementOf>
                <Datatype URI="&xsd;string"/>
            </DataComplementOf>
        </DataAllValuesFrom>
        <Individual URI="&ontologies;WebErgonomics"/>
    </ClassAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLecturer"/>
        <Individual URI="&ontologies;WebErgonomics"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SimonH"/>
    </ObjectPropertyAssertion>
    <ObjectPropertyAssertion>
        <ObjectProperty  
URI="&ontologies;Ontology1245861313437.owl#ownedBy"/>
        <Individual URI="&ontologies;WebErgonomics"/>
        <Individual URI="&ontologies;Ontology1245861313437.owl#SoCS"/>
    </ObjectPropertyAssertion>
    <DataPropertyAssertion>
        <DataProperty  
URI="&ontologies;Ontology1245861313437.owl#hasLongTitle"/>
        <Individual URI="&ontologies;WebErgonomics"/>
        <Constant
            >Web Ergonomics &amp; Accessibility</Constant>
    </DataPropertyAssertion>
    <EntityAnnotation>
        <Individual URI="&ontologies;WebErgonomics"/>
        <Annotation annotationURI="&rdfs;comment">
            <Constant
                >*not* to start in 2010, but in 2011.</Constant>
        </Annotation>
    </EntityAnnotation>
</Ontology>

<!-- Generated by the OWL API (version 2.2.1.1138) http://owlapi.sourceforge.net 
  -->
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://discuss.it.uts.edu.au/pipermail/planetkr/attachments/20110923/e8be5637/attachment-0001.html 