Main Page: Difference between revisions

From formulasearchengine
Jump to navigation Jump to search
← Older editNewer edit →
No edit summary
No edit summary
Line 1: Line 1:
In [[computer science]], '''Communicating Sequential Processes''' ('''CSP''') is a [[specification language|formal language]] for describing [[pattern]]s of [[interaction]] in [[concurrent systems]].<ref name="roscoe">{{cite book|first=A. W.|last=Roscoe|authorlink=Bill Roscoe|title=The Theory and Practice of Concurrency|publisher=[[Prentice Hall]]|isbn = 0-13-674409-5|year=1997}}</ref> It is a member of the family of mathematical theories of concurrency known as process algebras, or [[process calculus|process calculi]], based on [[message passing]] via [[Channel (programming)|channels]]. CSP was highly influential in the design of the [[occam (programming language)|occam]] programming language,<ref name="roscoe"/><ref>{{cite book|last=INMOS|authorlink=INMOS|url=http://www.wotug.org/occam/documentation/oc21refman.pdf|format=PDF|title=occam 2.1 Reference Manual|publisher=SGS-THOMSON Microelectronics Ltd.|date=1995-05-12}}, INMOS document 72 occ 45 03</ref> and also influenced the design of programming languages such as [[Limbo (programming language)|Limbo]]<ref>{{cite web|title=Resources about threaded programming in the Bell Labs CSP style|url=http://swtch.com/~rsc/thread/|accessdate=2010-04-15}}</ref> and [[Go (programming language)|Go]].<ref name="golang">{{cite web |title=Language Design FAQ: Why build concurrency on the ideas of CSP? |url=http://golang.org/doc/go_faq.html#csp}}</ref>
{{Infobox W3C Standard
| title            = OWL Web Ontology Language
| status            = Published
| year_started      = 2002
| editors          = Mike Dean, [[Guus Schreiber]]
| base_standards    = [[Resource Description Framework]], [[RDFS]]
| related_standards =
| abbreviation      = OWL
| domain            = [[Semantic Web]]
| website          = [http://www.w3.org/TR/owl-ref/ OWL Reference]
}}
{{Infobox W3C Standard
| title            = OWL 2 Web Ontology Language
| status            = Published
| year_started      = 2008
| editors          = W3C OWL Working Group
| base_standards    = Resource Description Framework, RDFS
| related_standards =
| abbreviation      = OWL 2
| domain            = Semantic Web
| website          = [http://www.w3.org/TR/owl2-overview/ OWL2 Overview]
}}
The '''Web Ontology Language''' ('''OWL''') is a family of [[knowledge representation]] languages for authoring [[Ontology (computer science)|ontologies]].
The languages are characterised by [[Semantics of programming languages|formal semantics]] and [[Resource Description Framework|RDF]]/[[XML]]-based serializations for the [[Semantic Web]]. OWL is endorsed by the [[World Wide Web Consortium]] (W3C)<ref>{{cite web |url=http://www.w3.org/TR/owl2-overview/ |title=OWL 2 Web Ontology Language Document Overview |date=2009-10-27 |publisher=W3C }}</ref> and has attracted academic, medical and commercial interest.


CSP was first described in a 1978 paper by [[C. A. R. Hoare]],<ref name="hoare1978">{{cite journal|last=Hoare
In October 2007, a new W3C working group<ref>[http://www.w3.org/2007/OWL W3C working group]</ref> was started to extend OWL with several new features as proposed in the OWL 1.1 member submission.<ref>{{cite web |url=http://www.w3.org/Submission/2006/10/ |title=Submission Request to W3C: OWL 1.1 Web Ontology Language |publisher=W3C |date=2006-12-19 }}</ref> W3C announced the new version of OWL on 27 October 2009.<ref name="w3.org">http://www.w3.org/2009/10/owl2-pr</ref> This new version, called OWL 2, soon found its way into semantic editors such as [[Protégé (software)|Protégé]] and [[semantic reasoner]]s such as Pellet,<ref>{{cite doi |10.1016/j.websem.2007.03.004 }}</ref><ref>[http://pellet.owldl.org/ Pellet]</ref> RacerPro,<ref>[http://www.racer-systems.com/ RacerPro]</ref> FaCT++<ref>{{cite doi |10.1007/11814771_26 }}</ref><ref>[http://code.google.com/p/factplusplus/ FaCT++]</ref> and HermiT.<ref>[http://hermit-reasoner.com/ HermiT]</ref>
|first=C. A. R.
 
|authorlink=C. A. R. Hoare
The OWL family contains many species, serializations, syntaxes and specifications with similar names. OWL and OWL2 are used to refer to the 2004 and 2009 specifications, respectively. Full species names will be used, including specification version (for example, OWL2 EL).  When referring more generally, ''OWL Family'' will be used.
|title=Communicating sequential processes
|journal=[[Communications of the ACM]]
|volume=21
|issue=8
|pages=666&ndash;677
|year=1978
|doi=10.1145/359576.359585}}
</ref> but has since evolved substantially.<ref name="25years">{{cite book|last=Abdallah
|first=Ali E.|author2=Jones, Cliff B.|author3= Sanders, Jeff W.
|title=Communicating Sequential Processes: The First 25 Years
|series=[[LNCS]]
|volume=3525
|publisher=Springer
|year=2005
|url=http://www.springer.com/computer/theoretical+computer+science/foundations+of+computations/book/978-3-540-25813-1}}
</ref> CSP has been practically applied in industry as a tool for [[formal specification|specifying and verifying]] the concurrent aspects of a variety of different systems, such as the T9000 [[Transputer]],<ref name="barrett">
{{cite journal|last=Barrett
|first=G.
|title=Model checking in practice: The T9000 Virtual Channel Processor
|journal=[[IEEE]] Transactions on Software Engineering
|volume=21
|issue=2
|pages=69–78
|year=1995
|doi=10.1109/32.345823}}</ref> as well as a secure ecommerce system.<ref name="hall">{{cite journal|last = Hall
|first=A
|coauthors=R. Chapman
|url=http://www.anthonyhall.org/c_by_c_secure_system.pdf
|format=PDF|title=Correctness by construction: Developing a commercial secure system
|journal=[[IEEE]] Software
|volume=19
|issue=1
|pages=18–25
|year=2002
|doi=10.1109/52.976937}}
</ref> The theory of CSP itself is also still the subject of active research, including work to increase its range of practical applicability (e.g., increasing the scale of the systems that can be tractably analyzed).<ref>
{{Cite journal|author=Creese, S.|title=Data Independent Induction: CSP Model Checking of Arbitrary Sized Networks|version=D. Phil.|publisher=[[Oxford University]]|year=2001}}
</ref>


== History ==
== History ==
The version of CSP presented in Hoare's original 1978 paper was essentially a concurrent programming language rather than a [[process calculus]]. It had a substantially different [[syntax]] than later versions of CSP, did not possess mathematically defined semantics,<ref name="hoare">{{cite book|last=Hoare|first=C. A. R.|authorlink=C. A. R. Hoare|title=Communicating Sequential Processes|publisher=Prentice Hall|isbn=0-13-153289-8|year=1985}}</ref> and was unable to represent [[unbounded nondeterminism]].<ref name="clinger1981">{{Cite journal|author=William Clinger|authorlink=William Clinger (computer scientist)|title=Foundations of Actor Semantics|url=https://dspace.mit.edu/handle/1721.1/6935|publisher=MIT|version=Mathematics Doctoral Dissertation|date=June 1981}}</ref> Programs in the original CSP were written as a parallel composition of a fixed number of sequential processes communicating with each other strictly through synchronous message-passing. In contrast to later versions of CSP, each process was assigned an explicit name, and the source or destination of a message was defined by specifying the name of the intended sending or receiving process. For example the process
=== Early ontology languages ===
{{further|Knowledge_representation#History_of_knowledge_representation_and_reasoning}}
There is a long history of [[Ontology (computer science)|ontological]] development in philosophy and computer science. Since the 1990s, a number of research efforts have explored how the idea of [[knowledge representation]] (KR) from [[artificial intelligence]] (AI) could be made useful on the World Wide Web. These included languages based on [[HTML]] (called [[Simple HTML Ontology Extensions|SHOE]]), based on XML (called XOL, later [[Ontology Inference Layer|OIL]]), and various frame-based KR languages and knowledge acquisition approaches.
 
=== Ontology languages for the web ===
 
In 2000 in the United States, [[DARPA]] started development of [[DARPA Agent Markup Language|DAML]] led by [[James Hendler]].<ref name="book:lacy:owl:c10">{{cite book |title=OWL: Representing Information Using the Web Ontology Language |last=Lacy |first=Lee W. |year=2005 |publisher=Trafford Publishing |location=Victoria, BC |isbn=1-4120-3448-5 |chapter=Chapter 10 }}</ref>
In March 2001, the ''Joint EU/US Committee on Agent Markup Languages'' decided that DAML should be merged with OIL.<ref name="book:lacy:owl:c10" />
The ''EU/US ad hoc Joint Working Group on Agent Markup Languages'' was convened to develop [[DAMLplusOIL|DAML+OIL]] as a web ontology language. This group was jointly funded by the DARPA (under the DAML program) and the European Union's [[Information Society Technologies]] (IST) funding project. DAML+OIL was intended to be a thin layer above [[RDFS]],<ref name="book:lacy:owl:c10" />
with [[Semantics of programming languages|formal semantics]] based on a [[description logic]] (DL).<ref name="Baader:2005">{{cite book |title=Mechanizing Mathematical Reasoning: Essays in Honor of Jörg H. Siekmann on the Occasion of His 60th Birthday |editor1-last=Hutter |editor2-last=Stephan |last1=Baader |first1=Franz |authorlink1=Franz Baader |last2=Horrocks |first2=Ian |authorlink2=Ian Horrocks |last3=Sattler |first3=Ulrike |authorlink3=Ulrike Sattler |year=2005 |publisher=Springer Berlin |location=Heidelberg, DE |isbn=978-3-540-25051-7 |chapter=Description Logics as Ontology Languages for the Semantic Web
|url=http://www.springerlink.com/content/mf848ceackyx |chapterurl=http://www.springerlink.com/content/axh20n8l34bc3ecb/ |editor-first=Dieter |editor-last=Hutter |editor-link=Dieter Hutter |editor2-first=Werner |editor2-last=Stephan |editor2-link=Werner Stephan}}</ref>
 
OWL started as a research-based<ref>{{cite web |url=http://www.w3.org/TR/2002/WD-owl-features-20020729/ |title=Feature Synopsis for OWL Lite and OWL: W3C Working Draft 29 July 2002 |publisher=W3C |date=2002-07-29 }}</ref> revision of DAML+OIL aimed at the semantic web.
 
=== Semantic web standards ===
 
{{quote|The Semantic Web provides a common framework that allows data to be shared and reused across application, enterprise, and community boundaries.|World Wide Web Consortium|''W3C Semantic Web Activity''<ref name="semantic_web_activity">{{cite web |url=http://www.w3.org/2001/sw/ |title=W3C Semantic Web Activity |author=World Wide Web Consortium |date=2010-02-06 |work= |accessdate=18 April 2010 }}</ref>}}
 
{{further | Semantic Web}}
 
==== RDF schema ====
 
{{quote|a declarative representation language influenced by ideas from knowledge representation|World Wide Web Consortium|''Metadata Activity''<ref name="metadata.activity">{{cite web |url=http://www.w3.org/Metadata/Activity.html |title=Metadata Activity Statement |author=World Wide Web Consortium |date=2002-08-23 |publisher=World Wide Web Consortium |accessdate=20 April 2010 }}</ref>}}
 
In the late 1990s, the World Wide Web Consortium (W3C) ''Metadata Activity'' started work on [[RDFS|RDF Schema]] (RDFS), a language for [[Resource Description Framework|RDF]] vocabulary sharing. The RDF became a W3C [[web standards|Recommendation]] in February 1999, and RDFS a Candidate Recommendation in March 2000.<ref name="metadata.activity" /> In February 2001, the ''Semantic Web Activity'' replaced the Metadata Activity.<ref name="metadata.activity" /> In 2004 (as part of a wider revision of RDF) RDFS became a W3C Recommendation.<ref>{{cite web |url=http://www.w3.org/Metadata/Activity.html |title=RDF Vocabulary Description Language 1.0: RDF Schema |author=World Wide Web Consortium |date=2002-08-23 | work=RDF Vocabulary Description Language 1.0 |publisher=World Wide Web Consortium |accessdate=20 April 2010 }}</ref>
Though RDFS provides some support for ontology specification, the need for a more expressive ontology language had become clear.<ref name="book:lacy:owl:c9">{{cite book |title=OWL: Representing Information Using the Web Ontology Language |last=Lacy |first=Lee W. |year=2005 |publisher=Trafford Publishing |location=Victoria, BC |isbn=1-4120-3448-5 |chapter=Chapter 9 - RDFS}}</ref>
 
{{further | RDFS}}
 
==== Web-Ontology Working Group ====
 
{{quote|As of Monday, the 31st of May, our working group will officially come to an end. We have achieved all that we were chartered to do, and I believe our work is being quite well appreciated.|James Hendler and Guus Schreiber|''So Long and thanks for all the fish''<ref name="web-ont" />}}
 
The World Wide Web Consortium (W3C) created the ''Web-Ontology Working Group'' as part of their Semantic Web Activity. It began work on November 1, 2001 with co-chairs James Hendler and Guus Schreiber.<ref name="web-ont">{{cite web |url=http://www.w3.org/2001/sw/WebOnt/#L151 |publisher=W3C |title=Web-Ontology (WebOnt) Working Group (Closed) }}</ref> The first working drafts of the [[abstract syntax]], reference and synopsis were published in July 2002.<ref name="web-ont" /> OWL became a formal [[Web standards|W3C recommendation]] on February 10, 2004 and the working group was disbanded on May 31, 2004.<ref name="web-ont" />
 
==== OWL Working Group ====


COPY = *[c:character; west?c → east!c]
In 2005, at the ''OWL Experiences And Directions Workshop'' a consensus formed that recent advances in description logic would allow a more expressive revision to satisfy user requirements more comprehensively whilst retaining good computational properties.
In December 2006, the OWL1.1 Member Submission<ref name="owl1.1">{{cite web |url=http://www.w3.org/Submission/2006/SUBM-owl11-overview-20061219/ |title=OWL 1.1 Web Ontology Language |last1=Patel-Schneider |first1=Peter F. |authorlink1=Peter F. Patel-Schneider |last2=Horrocks |first2=Ian |date=2006-12-19 |publisher=World Wide Web Consortium |accessdate=26 April 2010 }}</ref> was made to the W3C. The W3C chartered the ''OWL Working Group'' as part of the Semantic Web Activity in September 2007. In April 2008, this group decided to call this new language OWL2, indicating a substantial revision.<ref name="grau.2008">{{cite doi |10.1016/j.websem.2008.05.001 }}</ref>


repeatedly receives a character from the process named <code>west</code>, and then sends that character to process named <code>east</code>. The parallel composition
OWL 2 became a W3C recommendation in October 2009. OWL 2 introduces profiles to improve scalability in typical applications.<ref name="w3.org" />


[west::DISASSEMBLE || X::COPY || east::ASSEMBLE]
=== Acronym ===
<!-- This section is linked from [[Owl (Winnie the Pooh)]] -->
{{quote|Why not be inconsistent in at least one aspect of a language which is all about consistency?|Guus Schreiber|''Why OWL and not WOL?''<ref>{{cite web |url=http://www.w3.org/People/Ivan/CorePresentations/RDFTutorial/Slides.html#%28114%29 |title=Why OWL and not WOL? |first=Ivan |last=Herman |authorlink=Ivan Herman |work=Tutorial on Semantic Web Technologies |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>}}


assigns the names <code>west</code> to the <code>DISASSEMBLE</code> process, <code>X</code> to the <code>COPY</code> process, and <code>east</code> to the <code>ASSEMBLE</code> process, and executes these three processes concurrently.<ref name="hoare1978"/>
The natural acronym for ''Web Ontology Language'' would be ''WOL'' instead of ''OWL''. Although the character [[Owl (Winnie the Pooh)|Owl]] from [[Winnie the Pooh]] wrote his name ''WOL'', the acronym ''OWL'' was proposed without reference to that character, as an easily pronounced acronym that would yield good logos, suggest wisdom, and honor [[William A. Martin]]'s ''One World Language'' knowledge representation project from the 1970s.


Following the publication of the original version of CSP, Hoare, [[Stephen Brookes]], and [[Bill Roscoe|A. W. Roscoe]] developed and refined the ''theory'' of CSP into its modern, process algebraic form. The approach taken in developing CSP into a process algebra was influenced by [[Robin Milner]]'s work on the [[Calculus of Communicating Systems]] (CCS), and vice versa. The theoretical version of CSP was initially presented in a 1984 article by Brookes, Hoare, and Roscoe,<ref>{{cite journal|first=Stephen|last=Brookes|coauthors=[[C. A. R. Hoare]] and [[Bill Roscoe|A. W. Roscoe]]|title=A Theory of Communicating Sequential Processes|journal=[[Journal of the ACM]]|volume=31|issue=3|pages=560&ndash;599|year=1984|doi=10.1145/828.833}}</ref> and later in Hoare's book ''Communicating Sequential Processes'',<ref name="hoare"/> which was published in 1985. In September 2006, that book was still the [http://citeseer.ist.psu.edu/articles.html third-most cited] [[computer science]] reference of all time according to [[Citeseer]] (albeit an unreliable source due to the nature of its sampling). The theory of CSP has undergone a few minor changes since the publication of Hoare's book. Most of these changes were motivated by the advent of automated tools for CSP process analysis and verification. Roscoe's ''The Theory and Practice of Concurrency''<ref name="roscoe"/> describes this newer version of CSP.
=== Adoption ===


=== Applications ===
A survey (published in 2006) of ontologies available on the web collected 688 OWL ontologies. Of these, 199 were OWL Lite, 149 were OWL DL and 337 OWL Full (by syntax). They found that 19 ontologies had in excess of 2,000 classes, and that 6 had more than 10,000. The same survey collected 587 RDFS vocabularies.<ref>{{cite doi |10.1007/11926078_49 }}</ref>
An early and important application of CSP was its use for specification and verification of elements of the INMOS T9000 [[Transputer]], a complex superscalar pipelined processor designed to support large-scale multiprocessing. CSP was employed in verifying the correctness of both the processor pipeline, and the Virtual Channel Processor which managed off-chip communications for the processor.<ref name="barrett"/>


Industrial application of CSP to software design has usually focused on dependable and safety-critical systems. For example, the Bremen Institute for Safe Systems and [[DaimlerChrysler Aerospace|Daimler-Benz Aerospace]] modeled a fault management system and avionics interface (consisting of some 23,000 lines of code) intended for use on the International Space Station in CSP, and analyzed the model to confirm that their design was free of deadlock and livelock.<ref>{{cite conference|first=B. |last=Buth|coauthors=M. Kouvaras, J. Peleska, and H. Shi|title=Deadlock analysis for a fault-tolerant system|booktitle=Proceedings of the 6th International Conference on Algebraic Methodology and Software Technology (AMAST’97)| pages = 60–75|date=December 1997}}</ref><ref>{{cite conference|first=B.|last=Buth|coauthors=J. Peleska, and H. Shi|title=Combining methods for the livelock analysis of a fault-tolerant system|booktitle=Proceedings of the 7th International Conference on Algebraic Methodology and Software Technology (AMAST’98)|pages=124– 139|date=January 1999}}</ref> The modeling and analysis process was able to uncover a number of errors that would have been difficult to detect using testing alone. Similarly, [[Praxis High Integrity Systems]] applied CSP modeling and analysis during the development of software (approximately 100,000 lines of code) for a secure smart-card Certification Authority to verify that their design was secure and free of deadlock. Praxis claims that the system has a much lower defect rate than comparable systems.<ref name="hall"/>
== Ontologies ==


Since CSP is well-suited to modeling and analyzing systems that incorporate complex message exchanges, it has also been applied to the verification of communications and security protocols. A prominent example of this sort of application is Lowe’s use of CSP and the [[FDR2|FDR refinement-checker]] to discover a previously unknown attack on the [[Needham-Schroeder protocol|Needham-Schroeder public-key authentication protocol]], and then to develop a corrected protocol able to defeat the attack.<ref>{{cite conference|first=G. |last=Lowe|title=Breaking and fixing the Needham-Schroeder public-key protocol using FDR|booktitle=Tools and Algorithms for the Construction and Analysis of Systems (TACAS)|pages=147–166.|publisher=Springer-Verlag|year=1996|url=http://citeseer.ist.psu.edu/lowe96breaking.html}}</ref>
{{main|Ontology (information science)}}


== Informal description ==
=== Introduction ===
As its name suggests, CSP allows the description of systems in terms of component processes that operate independently, and interact with each other solely through [[message passing|message-passing]] communication. However, the ''"Sequential"'' part of the CSP name is now something of a misnomer, since modern CSP allows component processes to be defined both as sequential processes, and as the parallel composition of more primitive processes. The relationships between different processes, and the way each process communicates with its environment, are described using various [[process calculi|process algebraic]] operators. Using this algebraic approach, quite complex process descriptions can be easily constructed from a few primitive elements.


=== Primitives ===
{{quote|An ontology is an explicit specification of a conceptualization.|[[Tom Gruber]]|'' A Translation Approach to Portable Ontology Specifications''<ref name="TRG93">[[Tom Gruber|Gruber, Tom]] (1993); [http://tomgruber.org/writing/ontolingua-kaj-1993.pdf "A Translation Approach to Portable Ontology Specifications"], in ''Knowledge Acquisition'', 5: 199-199</ref>}}
CSP provides two classes of primitives in its process algebra:
;Events
:Events represent communications or interactions. They are assumed to be indivisible and instantaneous.  They may be atomic names (e.g. ''on'', ''off''), compound names (e.g. ''valve.open'', ''valve.close''), or input/output events (e.g. ''mouse?xy'', ''screen!bitmap'').
;Primitive processes:
:Primitive processes represent fundamental behaviors: examples include ''STOP'' (the process that communicates nothing, also called [[deadlock]]), and ''SKIP'' (which represents successful termination).


=== Algebraic operators ===
The data described by an ontology in the OWL family is interpreted as a set of "individuals" and a set of "property assertions" which relate these individuals to each other. An ontology consists of a set of [[axioms]] which place constraints on sets of individuals (called "classes") and the types of relationships permitted between them. These axioms provide semantics by allowing systems to infer additional information based on the data explicitly provided. A full introduction to the expressive power of the OWL is provided in the W3C's ''OWL Guide''.
CSP has a wide range of algebraic operators. The principal ones are:


;Prefix
=== Example ===
:The prefix operator combines an event and a process to produce a new process. For example,


::<math>a \rightarrow P</math>
An ontology describing families might include axioms stating that a "hasMother" property is only present between two individuals when "hasParent" is also present, and individuals of class "HasTypeOBlood" are never related via "hasParent" to members of the "HasTypeABBlood" class. If it is stated that the individual Harriet is related via "hasMother" to the individual Sue, and that Harriet is a member of the "HasTypeOBlood" class, then it can be inferred that Sue is not a member of "HasTypeABBlood".


:is the process which is willing to communicate <math>\mathit{a}</math> with its environment, and, after <math>\mathit{a}</math>, behaves like the process <math>\mathit{P}</math>.
== Species ==
=== OWL sublanguages ===
The W3C-endorsed OWL specification includes the definition of three variants of OWL, with different levels of expressiveness. These are OWL Lite, OWL DL and OWL Full (ordered by increasing expressiveness). Each of these sublanguages is a syntactic extension of its simpler predecessor. The following set of relations hold. Their inverses do not.


;Deterministic Choice
* Every legal OWL Lite ontology is a legal OWL DL ontology.
:The deterministic (or external) choice operator allows the future evolution of a process to be defined as a choice between two component processes, and allows the environment to resolve the choice by communicating an initial event for one of the processes. For example,
* Every legal OWL DL ontology is a legal OWL Full ontology.
* Every valid OWL Lite conclusion is a valid OWL DL conclusion.
* Every valid OWL DL conclusion is a valid OWL Full conclusion.


::<math>\left(a \rightarrow P\right) \Box \left(b \rightarrow Q\right)</math>
==== OWL Lite ====


:is the process which is willing to communicate the initial events <math>\mathit{a}</math> and <math>\mathit{b}</math>, and subsequently behaves as either <math>\mathit{P}</math> or <math>\mathit{Q}</math> depending on which initial event the environment chooses to communicate. If both <math>\mathit{a}</math> and <math>\mathit{b}</math> were communicated simultaneously the choice would be resolved nondeterministically.
OWL Lite was originally intended to support those users primarily needing a classification hierarchy and simple constraints. For example, while it supports [[cardinality]] constraints, it only permits cardinality values of 0 or 1. It was hoped that it would be simpler to provide tool support for OWL Lite than its more expressive relatives, allowing quick migration path for systems utilizing [[Thesaurus|thesauri]] and other [[Taxonomy|taxonomies]]. In practice, however, most of the expressiveness constraints placed on OWL Lite amount to little more than syntactic inconveniences: most of the constructs available in OWL DL can be built using complex combinations of OWL Lite features.<ref name="grau.2008" /> Development of OWL Lite tools has thus proven almost as difficult as development of tools for OWL DL, and OWL Lite is not widely used.<ref name="grau.2008" />


;Nondeterministic Choice
==== OWL DL ====
:The nondeterministic (or internal) choice operator allows the future evolution of a process to be defined as a choice between two component processes, but does not allow the environment any control over which one of the component processes will be selected. For example,


::<math>\left(a \rightarrow P\right) \sqcap \left(b \rightarrow Q\right)</math>
OWL DL was designed to provide the maximum expressiveness possible while retaining computational [[Complete theory|completeness]] (either φ or ¬φ belong), [[Decidability (logic)|decidability]] (there is an effective procedure to determine whether φ is derivable or not), and the availability of practical reasoning algorithms. OWL DL includes all OWL language constructs, but they can be used only under certain restrictions (for example, number restrictions may not be placed upon properties which are declared to be transitive). OWL DL is so named due to its correspondence with description logic, a field of research that has studied the logics that form the formal foundation of OWL.


:can behave like either <math>\left(a \rightarrow P\right)</math> or <math>\left(b \rightarrow Q\right)</math>. It can refuse to accept <math>\mathit{a}</math> or <math>\mathit{b}</math>, and is only obliged to communicate if the environment offers both <math>\mathit{a}</math> and <math>\mathit{b}</math>. Nondeterminism can be inadvertently introduced into a nominally deterministic choice if the initial events of both sides of the choice are identical. So, for example,
==== OWL Full ====
OWL Full is based on a different semantics from OWL Lite or OWL DL, and was designed to preserve some compatibility with RDF Schema. For example, in OWL Full a class can be treated simultaneously as a collection of individuals and as an individual in its own right; this is not permitted in OWL DL. OWL Full allows an ontology to augment the meaning of the pre-defined (RDF or OWL) vocabulary. OWL Full is undecidable, so no reasoning software is able to perform complete reasoning for it.


::<math>\left(a \rightarrow a \rightarrow STOP\right) \Box \left(a \rightarrow b \rightarrow STOP\right)</math>
=== OWL2 profiles ===


:is equivalent to
In OWL 2, there are three sublanguages of the language. OWL 2 EL is a fragment that has polynomial time reasoning complexity; OWL 2 QL is designed to enable easier access and query to data stored in databases; OWL 2 RL is a rule subset of OWL 2.


::<math>a \rightarrow \left(\left(a \rightarrow STOP\right) \sqcap \left(b \rightarrow STOP\right)\right)</math>
== Syntax ==


;Interleaving
The OWL family of languages supports a variety of syntaxes. It is useful to distinguish ''high level'' syntaxes aimed at specification from ''exchange'' syntaxes more suitable for general use.
:The interleaving operator represents completely independent concurrent activity. The process


::<math>P \;\vert\vert\vert\; Q</math>
=== High level ===


:behaves as both <math>\mathit{P}</math> and <math>\mathit{Q}</math> simultaneously. The events from both processes are arbitrarily interleaved in time.
These are close to the ontology structure of languages in the OWL family.


;Interface Parallel
==== OWL abstract syntax ====
:The interface parallel operator represents concurrent activity that requires synchronization between the component processes &ndash; any event in the interface set can only occur when ''all'' component processes are able to engage in that event. For example, the process


::<math>P \left\vert\left[ \left\{ a \right\} \right]\right\vert Q</math>
This high level syntax is used to specify the OWL ontology structure and semantics.<ref name="owl:spec:semantics_and_syntax">{{cite web |url=http://www.w3.org/TR/2004/REC-owl-semantics-20040210/syntax.html |title=OWL Web Ontology Language Semantics and Abstract Syntax |first1=Peter F. |last1=Patel-Schneider |first2=Ian |last2=Horrocks |first3=Hayes |last3=Patrick J. |authorlink3=Patrick J. Hayes |date=2004-02-10 |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>


:requires that <math>\mathit{P}</math> and <math>\mathit{Q}</math> must both be able to perform event <math>\mathit{a}</math> before that event can occur. So, for example, the process
The OWL abstract syntax presents an ontology as a sequence of ''annotations'', ''axioms'' and ''facts''. Annotations carry machine and human oriented meta-data. Information about the classes, properties and individuals that compose the ontology is contained in axioms and facts only.
Each class, property and individual is either ''anonymous'' or identified by an [[URI|URI reference]]. Facts state data either about an individual or about a pair of individual identifiers (that the objects identified are distinct or the same). Axioms specify the characteristics of classes and properties. This style is similar to [[frame language]]s, and quite dissimilar to well known syntaxes for [[description logic]]s (DLs) and [[Resource Description Framework]] (RDF).<ref name="owl:spec:semantics_and_syntax" />


::<math>\left(a \rightarrow P\right) \left\vert\left[ \left\{ a \right\} \right]\right\vert \left(a \rightarrow Q\right)</math>
Sean Bechhofer, ''et al.'' argue that though this syntax is hard to parse, it is quite concrete. They conclude that the name ''abstract syntax'' may be somewhat misleading.<ref>{{cite web |url=http://owl.man.ac.uk/2003/concrete/20031210/ |title=OWL Web Ontology Language Concrete Abstract Syntax |first1=Sean |last1=Bechhofer |authorlink1=Sean Bechhofer |first2=Peter F. |last2=Patel-Schneider |first3=Daniele |last3=Turi |authorlink3=Daniele Turi |date=2003-12-10 |publisher=[[University of Manchester]] |accessdate=18 April 2010 }}</ref>


:can engage in event <math>\mathit{a}</math>, and become the process
==== OWL2 functional syntax ====


::<math>P \left\vert\left[ \left\{ a \right\} \right]\right\vert Q</math>
This syntax closely follows the structure of an OWL2 ontology. It is used by OWL2 to specify semantics, mappings to exchange syntaxes and profiles.<ref name="owl2:spec:structure">{{cite web |url=http://www.w3.org/TR/2009/REC-owl2-syntax-20091027/ |title= OWL 2 Web Ontology Language Structural Specification and Functional-Style Syntax |last1=Motik |first1=Boris |authorlink1=Boris Motik |last2=Patel-Schneider |first2=Peter F. |last3=Parsia |first3=Bijan |authorlink3=Bijan Parsia |date=2009-10-27 |work=OWL 2 Web Ontology Language |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>


:while
=== Exchange syntaxes ===
{{Infobox file format
| name = OWL RDF/XML Serialization
| icon = [[Image:XML.svg|100px]]
| extension = .owx, .owl, .rdf
| mime = application/owl+xml, application/rdf+xml<ref>{{cite web |url=http://tools.ietf.org/html/rfc3870 |title=application/rdf+xml Media Type Registration |pages=2 |publisher=IETF |date=2004-09 |accessdate=2011-01-08 }}</ref>
| owner = [[World Wide Web Consortium]]
| standard = [http://www.w3.org/TR/owl2-xml-serialization/ OWL 2 XML Serialization] {{release date and age|2009|10|27}},<br/>[http://www.w3.org/TR/owl-ref/#MIMEType OWL Reference] {{release date and age|2004|02|10}}
| free = Yes
}}


::<math>\left (a \rightarrow P\right ) \left\vert\left[ \left\{ a, b \right\} \right]\right\vert \left(b \rightarrow Q\right)</math>
==== RDF syntaxes ====


:will simply deadlock.
Syntactic mappings into [[Resource Description Framework|RDF]] are specified<ref name="owl:spec:semantics_and_syntax" /><ref name="owl2:spec:rdf">{{cite web |url=http://www.w3.org/TR/2009/REC-owl2-mapping-to-rdf-20091027/ |title= OWL 2 Web Ontology Language Mapping to RDF Graphs |last2=Motik |first2=Boris |last1=Patel-Schneider |first1=Peter F. |date=2009-10-27 |work=OWL 2 Web Ontology Language |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>
for languages in the OWL family. Several RDF [[serialization| serialization formats]] have been devised. Each leads to a syntax for languages in the OWL family through this mapping. RDF/XML is normative.<ref name="owl:spec:semantics_and_syntax" /><ref name="owl2:spec:rdf" />


;Hiding
==== OWL2 XML syntax ====
:The hiding operator provides a way to abstract processes, by making some events unobservable. A trivial example of hiding is


::<math>\left(a \rightarrow P\right) \setminus \left\{ a \right\}</math>
OWL2 specifies an [[XML]] serialization that closely models the structure of an OWL2 ontology.<ref name="owl2:spec:xml">{{cite web |url=http://www.w3.org/TR/2009/REC-owl2-xml-serialization-20091027/ |title=OWL 2 Web Ontology Language XML Serialization |last1=Motik |first1=Boris |last2=Parsia |first2=Bijan |last3=Patel-Schneider |first3=Peter F. |date=2009-10-27 |work=OWL 2 Web Ontology Language |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>


:which, assuming that the event <math>\mathit{a}</math> doesn't appear in <math>\mathit{P}</math>, simply reduces to
==== Manchester Syntax ====


::<math>\mathit{P}</math>
The Manchester Syntax is a compact, human readable syntax with a style close to frame languages.
Variations are available for OWL and OWL2. Not all OWL and OWL2 ontologies can be expressed in this syntax.<ref name="ms:note">{{cite web |url= http://www.w3.org/TR/owl2-manchester-syntax/ |title= OWL 2 Web Ontology Language Manchester Syntax |last1=Horridge |first1=Matthew |authorlink1=Matthew Horridge |last2=Patel-Schneider |first2=Peter F. |date=2009-10-27 |work=W3C OWL 2 Web Ontology Language |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>


=== Examples ===
=== Examples ===
One of the archetypal CSP examples is an abstract representation of a chocolate vending machine and its interactions with a person wishing to buy some chocolate. This vending machine might be able to carry out two different events, “coin” and “choc” which represent the insertion of payment and the delivery of a chocolate respectively. A machine which demands payment before offering a chocolate can be written as:


:<math>\textit{VendingMachine} = \textit{coin} \rightarrow \textit{choc} \rightarrow \textit{STOP}</math>
* The W3C OWL 2 Web Ontology Language provides syntax examples.<ref name="owl2.primer">{{cite web |url=http://www.w3.org/TR/2009/REC-owl2-primer-20091027/ |title=OWL 2 Web Ontology Language Primer |last1=Hitzler |first1=Pascal |authorlink1=Pascal Hitzler |last2=Krötzsch |first2=Markus |authorlink2=Markus Krötzsch |last3=Parsia |first3=Bijan |last4=Patel-Schneider |first4=Peter F. |last5=Rudolph |first5=Sebastian |authorlink5=Sebastian Rudolph |date=2009-10-27 |work=OWL 2 Web Ontology Language |publisher=World Wide Wed Consortium |accessdate=2010-04-26 }}</ref>
 
==== Tea ontology ====
 
Consider an ontology for tea based on a Tea class. But first, an ontology is needed. Every OWL ontology must be identified by an [[URI]] (<nowiki>http://www.example.org/tea.owl</nowiki>, say). This is enough to get a flavour of the syntax. To save space below, preambles and prefix definitions have been skipped.
 
OWL2 Functional Syntax <source lang="xml">
Ontology(<http://example.com/tea.owl>
  Declaration( Class( :Tea ) )
)
</source>
 
OWL2 XML Syntax <source lang="xml">
<Ontology ontologyIRI="http://example.com/tea.owl" ...>
  <Prefix name="owl" IRI="http://www.w3.org/2002/07/owl#"/>
  <Declaration>
    <Class IRI="Tea"/>
  </Declaration>
</Ontology>
</source>
 
Manchester Syntax <source lang="xml">
Ontology: <http://example.com/tea.owl>
Class: Tea
</source>
 
RDF/XML syntax
<source lang="xml">
<rdf:RDF ...>
    <owl:Ontology rdf:about=""/>
    <owl:Class rdf:about="#Tea"/>
</rdf:RDF>
</source>
 
RDF/[[Turtle (syntax)|Turtle]] <source lang="xml">
<http://example.com/tea.owl> rdf:type owl:Ontology .
:Tea  rdf:type            owl:Class .
</source>
 
== Semantics ==
 
{{main | Semantics of programming languages}}


A person who might choose to use a coin or card to make payments could be modelled as:
=== Relation to description logic ===


:<math>\textit{Person} = (\textit{coin} \rightarrow \textit{STOP}) \Box (\textit{card} \rightarrow \textit{STOP})</math>
{{quote|In the beginning, IS-A was quite simple. Today, however, there are almost as many meanings for this inheritance link as there are knowledge-representation systems.|[[Ronald J. Brachman]]|''What ISA is and isn't''<ref>Brachman, Ronald J. (1983); ''What ISA is and isn't: An analysis of taxonomic links in semantic networks'', IEEE Computer, vol. 16, no. 10, pp. 30-36</ref>}}


These two processes can be put in parallel, so that they can interact with each other. The behaviour of the composite process depends on the events that the two component processes must synchronise on. Thus,
Early attempts to build large ontologies were plagued by a lack of clear definitions. Members of the OWL family have [[model theory|model theoretic]] formal semantics, and so have strong [[logic]]al foundations.


:<math>\textit{VendingMachine} \left\vert\left[\left\{ \textit{coin}, \textit{card} \right\}\right]\right\vert \textit{Person} \equiv \textit{coin} \rightarrow \textit{choc} \rightarrow \textit{STOP}</math>
[[Description logic]]s (DLs) are a family of logics that are decidable fragments of [[first-order logic]] with attractive and well-understood computational properties. OWL DL and OWL Lite semantics are based on DLs.<ref>{{cite web |url=http://www.cs.man.ac.uk/~horrocks/Publications/download/2003/HoPa03c.pdf |format=PDF |first=Ian |last=Horrocks |first2=Peter F. |last2=Patel-Schneider |title=Reducing OWL Entailment to Description Logic Satisfiability }}</ref>
They combine a syntax for describing and exchanging ontologies, and formal semantics that gives them meaning. For example, OWL DL corresponds to the [[SHOIN (D)]] description logic, while [[OWL2|OWL 2]] corresponds to the [[SROIQ(D)]] logic.<ref>{{cite book |title=Foundations of Semantic Web Technologies |first=Pascal |last=Hitzler |first2=Markus |last2=Krötzsch |first3=Sebastian |last3=Rudolph |publisher=CRCPress |date=2009-08-25 |isbn=1-4200-9050-X |url=http://www.semantic-web-book.org }}</ref> Sound, complete, terminating reasoners (i.e. systems which are guaranteed to derive every consequence of the knowledge in an ontology) exist for these DLs.


whereas if synchronization was only required on “coin”, we would obtain
=== Relation To RDFS ===


:<math>\textit{VendingMachine} \left\vert\left[\left\{ \textit{coin} \right\}\right]\right\vert \textit{Person} \equiv \left (\textit{coin} \rightarrow \textit{choc} \rightarrow \textit{STOP}\right ) \Box \left (\textit{card} \rightarrow \textit{STOP}\right )</math>
OWL Full is intended to be compatible with [[RDF Schema]] (RDFS), and to be capable of augmenting the meanings of existing Resource Description Framework (RDF) vocabulary.<ref>{{cite web |url=http://www.w3.org/TR/2004/REC-owl-features-20040210/ |title=OWL Web Ontology Language Overview |first=Deborah |last=McGuinness |authorlink=Deborah McGuiness |first2=Frank |last2=van Harmelen |authorlink2=Frank van Harmelen |date=2004-02-10 |work=W3C Recommendation for OWL, the Web Ontology Language |publisher=World Wide Web Consortium |accessdate=18 April 2010}}</ref> A [[model theory]] describes the formal semantics for
RDF.<ref>{{cite web |url=http://www.w3.org/TR/2004/REC-rdf-mt-20040210/ |title=RDF Semantics |first=Patrick |last=Hayes |authorlink=Patrick Hayes |date=2004-02-10 |work=Resource Description Framework |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref> This interpretation provides the meaning of RDF and RDFS vocabulary. So, the meaning of OWL Full ontologies are defined by extension of the RDFS meaning, and OWL Full is a [[semantic extension]] of RDF.<ref>{{cite web |url=http://www.w3.org/TR/owl-semantics/rdfs.html |title=OWL Web Ontology Language Semantics and Abstract Syntax Section 5. RDF-Compatible Model-Theoretic Semantics |first=Peter F. |last=Patel-Schneider |first2=Patrick |last2=Hayes |first3=Ian |last3=Horrocks |date=2004-02-10 |work=W3C Recommendation for OWL, the Web Ontology Language |publisher=World Wide Web Consortium |accessdate=18 April 2010 }}</ref>


If we abstract this latter composite process by hiding the “coin” and “card” events, i.e.
=== Open world assumption ===


:<math>\left (\left (\textit{coin} \rightarrow \textit{choc} \rightarrow \textit{STO}P\right ) \Box \left (\textit{card} \rightarrow \textit{STOP}\right )\right ) \setminus \left\{\textit{coin}, card\right\}</math>
{{quote|[The closed] world assumption implies that everything we don’t know is ''false'', while the open world assumption states that everything we don’t know is ''undefined''.|Stefano Mazzocchi|''Closed World vs. Open World: the First Semantic Web Battle''<ref>{{cite web |url=http://www.betaversion.org/~stefano/linotype/news/91/ |title=Closed World vs. Open World: the First Semantic Web Battle |first=Stefano |last=Mazzocchi |authorlink=Setfano Mazzocchi |date=2005-06-16 |accessdate=27 April 2010 }}</ref>}}


we get the nondeterministic process
The languages in the OWL family use the [[open world assumption]]. Under the open world assumption, if a statement cannot be proven to be true with current knowledge, we cannot draw the conclusion that the statement is false.


:<math>\left (\textit{choc} \rightarrow \textit{STOP}\right ) \sqcap \textit{STOP}</math>
==== Contrast to other languages ====


This is a process which either offers a “choc” event and then stops, or just stops. In other words, if we treat the abstraction as an external view of the system (e.g., someone who does not see the decision reached by the person), [[Nondeterministic algorithm|nondeterminism]] has been introduced.
A [[relational database]] consists of sets of [[tuples]] with the same [[Attribute (computing)|attributes]]. [[SQL]] is a query and management language for relational databases. [[Prolog]] is a [[Logic programming|logical programming]] language. Both use the [[closed world assumption]].


== Formal definition ==
== Terminology ==
=== Syntax ===
Languages in the OWL family are capable of creating classes, properties, defining instances and its operations.
The syntax of CSP defines the “legal” ways in which processes and events may be combined. Let <math>\mathit{e}</math> be an event, and <math>\mathit{X}</math> be a set of events. Then the basic [[syntax]] of CSP can be defined as:


:<math>
=== Instances ===
\begin{matrix}
Proc & ::= & \textit{STOP} & \; \\
&|& \textit{SKIP} & \; \\
&|& e \rightarrow \textit{Proc} & (\text{prefixing})\\
&|& \textit{Proc} \;\Box\; \textit{Proc} & (\text{external} \; \text{choice})\\
&|& \textit{Proc} \;\sqcap\; \textit{Proc} & (\text{nondeterministic} \; \text{choice})\\
&|& \textit{Proc} \;\vert\vert\vert\; \textit{Proc} & (\text{interleaving}) \\
&|& \textit{Proc} \;|[ \{ X \} ]| \;\textit{Proc} & (\text{interface} \; \text{parallel})\\
&|& \textit{Proc} \setminus X & (\text{hiding})\\
&|& \textit{Proc} ; \textit{Proc} & (\text{sequential} \; \text{composition})\\
&|& \mathrm{if} \; b \; \mathrm{then} \; \textit{Proc}\; \mathrm{else}\; Proc & (\text{boolean} \; \text{conditional})\\
&|& \textit{Proc} \;\triangleright\; \textit{Proc} & (\text{timeout})\\
&|& \textit{Proc} \;\triangle\; \textit{Proc} & (\text{interrupt})
\end{matrix}
</math>


Note that, in the interests of brevity, the syntax presented above omits the <math>\mathbf{div}</math> process, which represents [[Divergence (computer science)|divergence]], as well as various operators such as alphabetized parallel, piping, and indexed choices.
An ''instance'' is an object. It corresponds to a description logic ''individual''.


=== Formal semantics ===
=== Classes ===
{{Expand section|date=June 2008}}


CSP has been imbued with several different [[Semantics#Computer science|formal semantics]], which define the ''meaning'' of syntactically correct CSP expressions. The theory of CSP includes mutually consistent [[denotational semantics]], [[algebraic semantics (computer science)|algebraic semantics]], and [[operational semantics]].
A ''class'' is a collection of objects. It corresponds to a description logic (DL) ''concept''.  A class may contain individuals, ''instances'' of the class. A class may have any number of instances. An instance may belong to none, one or more classes.


==== Denotational semantics ====
A class may be a ''subclass'' of another, inheriting characteristics from its parent ''superclass''. This corresponds to [[logical]] [[Is-a|subsumption]] and DL ''concept inclusion'' notated <math>\sqsubseteq</math>.
The three major denotational models of CSP are the ''traces'' model, the ''stable failures'' model, and the ''failures/divergences'' model. Semantic mappings from process expressions to each of these three models provide the denotational semantics for CSP.<ref name="roscoe"/>


The ''traces model'' defines the meaning of a process expression as the set of sequences of events (traces) that the process can be observed to perform. For example,
All classes are subclasses of owl:Thing (DL ''[[top type|top]]'' notated <math>\top</math>), the ''root'' class.


:* <math>traces\left(STOP\right) = \left\{ \langle\rangle \right\}</math> since <math>STOP</math> performs no events
All classes are subclassed by owl:Nothing (DL ''[[bottom type|bottom]]'' notated <math>\bot</math>), the ''empty'' class. No instances are members of owl:Nothing. Modelers use owl:Thing and owl:Nothing to assert facts about all or no instances.<ref name="book:lacy:owl:c12">{{cite book |title=OWL: Representing Information Using the Web Ontology Language |last=Lacy |first=Lee W. |year=2005 |publisher=Trafford Publishing |location=Victoria, BC |isbn=1-4120-3448-5 |chapter=Chapter 12 }}</ref>
:* <math>traces\left(a\rightarrow b \rightarrow STOP\right) = \left\{\langle\rangle ,\langle a \rangle, \langle a, b \rangle \right\}</math> since the process <math>(a\rightarrow b \rightarrow STOP)</math> can be observed to have performed no events, the event <math>a</math>, or the sequence of events <math>a</math> followed by <math>b</math>


More formally, the meaning of a process <math>P</math> in the traces model is defined as <math>traces\left(P\right) \subseteq \Sigma^{\ast}</math> such that:
==== Example ====
# <math>\langle\rangle \in traces\left(P\right)</math> (i.e. <math>traces\left(P\right)</math> contains the empty sequence)
For example, Employee could be the subclass of class owl:Thing while Dealer, Manager, and Labourer all subclass of Employee.
# <math>s_1 \smallfrown s_2 \in traces\left(P\right) \implies s_1 \in traces\left(P\right)</math> (i.e. <math>traces\left(P\right)</math> is prefix-closed)
where <math>\Sigma^{\ast}</math> is the set of all possible finite sequences of events.


The ''stable failures model'' extends the traces model with refusal sets, which are sets of events <math>X \subseteq \Sigma</math> that a process can refuse to perform. A ''failure'' is a pair <math>\left(s,X\right)</math>, consisting of a trace <math>s</math>, and a refusal set <math>X</math> which identifies the events that a process may refuse once it has executed the trace <math>s</math>. The observed behavior of a process in the stable failures model is described by the pair <math>\left(traces\left(P\right), failures\left(P\right)\right)</math>. For example,
=== Properties ===
A property is a directed binary relation that specifies class characteristics. It corresponds to a description logic ''role''. They are attributes of instances and sometimes act as data values or link to other instances. Properties may possess logical capabilities such as being transitive, symmetric, inverse and functional. Properties may also have domains and ranges.


:* <math>failures\left(\left(a \rightarrow STOP\right) \Box \left(b \rightarrow STOP\right)\right) = \left\{\left(\langle\rangle,\emptyset\right), \left(\langle a \rangle, \left\{a,b\right\}\right), \left(\langle b \rangle,\left\{a,b\right\}\right) \right\}</math>
==== Datatype properties ====
:* <math>failures\left(\left(a \rightarrow STOP\right) \sqcap \left(b \rightarrow STOP\right)\right) = \left\{ \left(\langle\rangle,\left\{a\right\}\right), \left(\langle\rangle,\left\{b\right\}\right),
\left(\langle a \rangle, \left\{a,b\right\}\right), \left(\langle b \rangle,\left\{a,b\right\}\right) \right\}</math>


The ''failures/divergence model'' further extends the failures model to handle [[divergence (computer science)|divergence]]. The semantics of a process in the failures/divergences model is a pair <math>\left(failures_\perp\left(P\right), divergences\left(P\right)\right)</math> where <math>divergences\left(P\right)</math> is defined as the set of all traces that can lead to divergent behavior and <math>failures_\perp\left(P\right) = failures\left(P\right) \cup \left\{\left(s,X\right) \vert s \in divergences\left(P\right)\right\}</math>.
Datatype properties are relations between instances of classes and RDF literals or XML schema datatypes. For example, modelName (String datatype) is the property of Manufacturer class. They are formulated using ''owl:DatatypeProperty'' type.


== Tools ==
==== Object properties ====


Over the years, a number of tools for analyzing and understanding systems described using CSP have been produced. Early tool implementations used a variety of machine-readable syntaxes for CSP, making input files written for different tools incompatible. However, most CSP tools have now standardized on the machine-readable dialect of CSP devised by Bryan Scattergood, sometimes referred to as CSP<sub>''M''</sub>.<ref>{{Cite journal|author=Scattergood, J.B.|title=The Semantics and Implementation of Machine-Readable CSP|version=D.Phil.|publisher=[[Oxford University Computing Laboratory]]|year=1998}}</ref> The CSP<sub>''M''</sub> dialect of CSP possesses a formally defined [[operational semantics]], which includes an embedded [[functional programming language]].
Object properties are relations between instances of two classes. For example, ownedBy may be an object type property of the Vehicle class and may have a range which is the class Person. They are formulated using ''owl:ObjectProperty''.


The most well-known CSP tool is probably ''Failures/Divergence Refinement 2'' (''[[FDR2]]''), which is a commercial product developed by Formal Systems (Europe) Ltd. FDR2 is often described as a [[model checker]], but is technically a ''refinement'' checker, in that it converts two CSP process expressions into [[Labelled transition system|Labelled Transition System]]s (LTSs), and then determines whether one of the processes is a refinement of the other within some specified semantic model (traces, failures, or failures/divergence).<ref>{{Cite journal|author=A.W. Roscoe|title=Model-checking CSP|version=In ''A Classical Mind: essays in Honour of C.A.R. Hoare''|publisher=Prentice Hall|year=1994|authorlink=Bill Roscoe}}</ref> FDR2 applies various state-space compression algorithms to the process LTSs in order to reduce the size of the state-space that must be explored during a refinement check.
=== Operators ===


The ''Adelaide Refinement Checker'' (''ARC'') <ref>{{cite conference |first=Atanas N. |last=  Parashkevov|coauthors=Jay Yantchev  |title=ARC - a tool for efficient refinement and equivalence checking for CSP |booktitle=IEEE Int. Conf. on Algorithms and Architectures for Parallel Processing ICA3PP '96 |pages= 68–75|year=1996 |url=http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.45.3212 |accessdate=2008-11-26 }}</ref> is a CSP refinement checker developed by the Formal Modelling and Verification Group at [[The University of Adelaide]]. ARC differs from FDR2 in that it internally represents CSP processes as [[Binary decision diagram|Ordered Binary Decision Diagram]]s (OBDDs), which alleviates the state explosion problem of explicit LTS representations without requiring the use of state-space compression algorithms such as those used in FDR2.
Languages in the OWL family support various operations on classes such as union, intersection and complement. They also allow class enumeration, [[cardinality]], and disjointness.


The ''ProB'' project,<ref>{{cite conference| first = Michael |last=Leuschel |coauthors= Marc Fontaine| title = Probing the Depths of CSP-M: A new FDR-compliant Validation Tool| booktitle = ICFEM 2008|publisher = Springer-Verlag|year=2008|url=http://www.stups.uni-duesseldorf.de/publications/main.pdf|format=PDF|accessdate=2008-11-26}}</ref> which is hosted by the Institut für Informatik, Heinrich-Heine-Universität Düsseldorf, was originally created to support analysis of specifications constructed in the [[B method]]. However, it also includes support for analysis of CSP processes both through refinement checking, and [[Linear Temporal Logic|LTL]] model-checking. ProB can also be used to verify properties of combined CSP and B specifications.
== Public ontologies ==
=== Libraries ===
==== Biomedical ====


The ''Process Analysis Toolkit'' (PAT)
* [[Open Biomedical Ontologies|OBO Foundry]]<ref>[http://obofoundry.org OBO Foundry]</ref><ref>[http://www.berkeleybop.org/ontologies/ OBO Download Matrix]</ref>
<ref>{{cite conference|last=Sun |first=Jun|coauthors= Yang Liu and Jin Song Dong|
* [[National Center for Biomedical Ontology|NCBO BioPortal]]<ref>[http://www.bioontology.org/ncbo/faces/pages/ontology_list.xhtml NCBO BioPortal]</ref>
  title    = PAT: Towards Flexible Verification under Fairness |
* [[National Cancer Institute|NCI]] [http://www.cancer.gov/cancertopics/terminologyresources  Enterprise Vocabulary Services]
  booktitle = Proceedings of the 20th International Conference on Computer-Aided Verification (CAV 2009)|
  publisher = Springer |
  series = Lecture Notes in Computer Science |
  volume    = 5643 |
  year      = 2009 | url = http://www.comp.nus.edu.sg/~sunj/Publications/cav09.pdf | accessdate = 2009-06-16}}</ref><ref>{{cite conference|last=Sun |first=Jun|coauthors= Yang Liu and Jin Song Dong|
  title    = Model Checking CSP Revisited: Introducing a Process Analysis Toolkit |
  booktitle = Proceedings of the Third International Symposium on Leveraging Applications of Formal Methods, Verification and Validation (ISoLA 2008)|
  pages    = 307–322 |
  publisher = Springer |
  series = Communications in Computer and Information Science |
  volume    = 17 |
  year      = 2008 | url = http://www.comp.nus.edu.sg/~sunj/Publications/ISoLA08.pdf | accessdate = 2009-01-15}}</ref> is a CSP analysis tool developed in the School of Computing at the [[National University of Singapore]]. PAT is able to perform refinement checking, LTL model-checking, and simulation of CSP and Timed CSP processes. The PAT process language extends CSP with support for mutable shared variables, asynchronous message passing, and a variety of fairness and quantitative time related process constructs such as <code>deadline</code> and <code>waituntil</code>. The underlying design principle of the PAT process language is to combine a high-level specification language with procedural programs (e.g. an event in PAT may be a sequential program or even an external C# library call) for greater expressiveness. Mutable shared variables and asynchronous channels provide a convenient [[syntactic sugar]] for well-known process modelling patterns used in standard CSP. The PAT syntax is similar, but not identical, to CSP<sub>''M''</sub>.<ref>{{cite conference |first=Jun |last=  Sun|coauthors=Yang Liu, Jin Song Dong and Chunqing Chen  |title=Integrating Specifications and Programs for System Specification and Verification |booktitle=IEEE Int. Conf. on Theoretical Aspects of Software Engineering TASE '09 |year=2009 |url=http://www.comp.nus.edu.sg/~sunj/Publications/tase09.pdf |accessdate=2009-04-13 }}</ref> The principal differences between the PAT syntax and standard CSP<sub>''M''</sub> are the use of semicolons to terminate process expressions, the inclusion of syntactic sugar for variables and assignments, and the use of slightly different syntax for internal choice and parallel composition.


''CSPsim''<ref>{{cite conference|last=Brooke|first=Phillip|coauthors=Richard Paige|title=Lazy Exploration and Checking of CSP Models with CSPsim|booktitle=Communicating Process Architectures 2007|year=2007}}</ref> is a lazy simulator. It does not model check CSP, but is useful for exploring very large (potentially infinite) systems.
==== Miscellaneous ====
* [http://www.schemaweb.info/ SchemaWeb]


== Related formalisms ==
=== Standards ===
Several other specification languages and formalisms have been derived from, or inspired by, the classic untimed CSP, including:
* [http://citeseer.comp.nus.edu.sg/61363.html Timed CSP], which incorporates timing information for reasoning about real-time systems
* [http://dx.doi.org/10.1007/BF01178564 Receptive Process Theory], a specialization of CSP that assumes an asynchronous (i.e. [[non-blocking algorithm | nonblocking]]) send operation
* [http://www.wotug.org/paperdb/show_pap.php?f=1&num=394 CSPP]
* [http://www.wotug.org/paperdb/show_pap.php?f=1&num=395 HCSP]
* [[Wright (ADL)|Wright]], an architecture description language
* [http://www.comp.nus.edu.sg/~dongjs/tcoz.html TCOZ], an integration of Timed CSP and [[Object Z]]
* [http://www.cs.york.ac.uk/circus/ Circus], an integration of CSP and [[Z specification language|Z]] based on the [[Unifying Theories of Programming]]
* [http://www.compass-research.eu/approach.html CML] (COMPASS Modelling Language), a combination of [http://www.cs.york.ac.uk/circus/ Circus] and [[VDM specification language|VDM]] developed for the modelling of [[System of systems|Systems of Systems]] (SoS)
* [http://www.cs.swan.ac.uk/~csmarkus/Papers/cspcasl.ps CspCASL], an extension of [[Common Algebraic Specification Language|CASL]] that integrates CSP
* [[Language Of Temporal Ordering Specification|LOTOS]], an international standard<ref>[[Language Of Temporal Ordering Specification|ISO 8807, Language of Temporal Ordering Specification]]</ref> that incorporates features of CSP and [[Calculus of Communicating Systems|CCS]].


== Comparison with the Actor Model ==
* [[Suggested Upper Merged Ontology]]<ref>[http://www.ontologyportal.org/translations/SUMO.owl.txt SUMO download]</ref>
In as much as it is concerned with concurrent processes that exchange messages, the [[Actor model]] is broadly similar to CSP. However, the two models make some fundamentally different choices with regard to the primitives they provide:
* [[TDWG]]<ref>[http://rs.tdwg.org/ontology/voc/ TDWG LSID Vocabularies]</ref>


* CSP processes are anonymous, while actors have identities.
=== Browsers ===


* CSP message-passing fundamentally involves a rendezvous between the processes involved in sending and receiving the message, i.e. the sender cannot transmit a message until the receiver is ready to accept it. In contrast, message-passing in actor systems is fundamentally asynchronous, i.e. message transmission and reception do not have to happen at same time, and senders may transmit messages before receivers are ready to accept them. These approaches may be considered duals of each other, in the sense that rendezvous-based systems can be used to construct buffered communications that behave as asynchronous messaging systems, while asynchronous systems can be used to construct rendezvous-style communications by using a message/acknowledgement protocol to synchronize senders and receivers.
The following tools include public ontology browsers:


* CSP uses explicit channels for message passing, whereas actor systems transmit messages to named destination actors. These approaches may also be considered duals of each other, in the sense that processes receiving through a single channel effectively have an identity corresponding to that channel, while the name-based coupling between actors may be broken by constructing actors that behave as channels.
* [[Protégé (software)|Protégé OWL]]<ref>[http://protege.stanford.edu Protégé web site]</ref>


==See also==
=== Search ===
* [[Occam programming language|occam]] was the first language implementing a CSP model.
* [[Ease programming language]] combines the process constructs of CSP with logically shared data structures.
* [[JCSP]] is a blending of CSP and [[Occam programming language|occam]] concepts in a [[Java (programming language)|Java]] thread support API.
* [[XC Programming Language|XC]] is a language developed by [[XMOS]] which was heavily influenced by CSP and occam
* [[Limbo (programming language)|Limbo]] is a language that implements concurrency inside the [[Inferno (operating system)|Inferno]] operating system, in a style inspired by CSP.
* [[Plan 9 from Bell Labs]] and [[Plan 9 from User Space]] include the libthread library which allows the use of a CSP-inspired concurrency model from [[C (programming language)|C]].
* [[VerilogCSP]] is a set of [[Macro (computer science)|macros]] added to [[Verilog HDL]] to support Communicating Sequential Processes channel communications.
*[[SystemVerilogCSP]]<ref>{{cite conference|first=A. |last=Saifhashemi|coauthors=P. Beerel|title=SystemVerilogCSP: Modeling Digital Asynchronous Circuits Using SystemVerilog Interfaces|booktitle=Proceedings of Communicating Process Architectures 2011 - WoTUG-
33 (CPA2011)| date=June 2011}}</ref> is a package for [[SystemVerilog]] that enables abstract CSP-like communication actions in [[SystemVerilog]].
* [[Trace monoid]] and [[history monoid]], the mathematical formalism of which CSP is an example.
* [[Trace theory]], the general theory of traces.
* [[Go (programming language)|Go]] is a programming language by [[Google]] incorporating ideas from CSP.<ref name="golang"/><ref>[http://www.youtube.com/watch?v=3DtUzH3zoFo Origins of Go concurrency style]. Talk by Rob Pike at OSCON's Emerging Languages Camp 2010.</ref>
*  [http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html Clojure's Core.async] is a library for the Clojure programming language based on CSP principles.
* [[Joyce (programming language)|Joyce]] is a programming language based on the principles of CSP, developed by [[Brinch Hansen]] around 1989.
* [[SuperPascal]] is a programming language also developed by [[Brinch Hansen]], influenced by CSP and his earlier work with [[Joyce (programming language)|Joyce]].
* [[Ada (programming language)|Ada]] implements features of CSP such as the rendezvous.
* [[Haskell (programming language)|Haskell]] MVars are a rendezvous mechanism for synchronizing threads.<ref>[http://hackage.haskell.org/package/base-4.6.0.1/docs/Control-Concurrent-MVar.html]. Control.Concurrent.MVar </ref>
* [[DirectShow]] is the video framework inside [[DirectX]], it uses the CSP concepts to implement the audio and video filters.
* [[OpenComRTOS]] is a formally developed network-centric distributed [[RTOS]] based on a pragmatic superset of CSP.


== Further reading ==
* [[Swoogle]]
* {{cite book |last=Hoare |first=C. A. R. |authorlink=C. A. R. Hoare |title=Communicating Sequential Processes |origyear=1985 |year=2004 |publisher=Prentice Hall International |format=PDF |url=http://www.usingcsp.com/ |isbn=0-13-153271-5}}
** This book has been updated by [[Jim_Davies_(computer_scientist)|Jim Davies]] at the [[Oxford University Computing Laboratory]] and the new edition is available for download as a PDF file at the [http://www.usingcsp.com/ Using CSP] website.


* {{cite book|first=A. W.|last=Roscoe|authorlink=Bill Roscoe|title=The Theory and Practice of Concurrency|publisher=[[Prentice Hall]]|isbn = 0-13-674409-5|year=1997}}
== Limitations ==
** Some links relating to this book are available [http://web.comlab.ox.ac.uk/oucl/publications/books/concurrency/ here]. The full text is available for download as a [http://web.comlab.ox.ac.uk/oucl/work/bill.roscoe/publications/68b.ps PS] or [http://web.comlab.ox.ac.uk/oucl/work/bill.roscoe/publications/68b.pdf PDF] file from Bill Roscoe's [http://web.comlab.ox.ac.uk/oucl/work/bill.roscoe/pubs.html list] of academic publications.
 
* No direct language support for n-ary relationships. For example modelers may wish to describe the qualities of a relation, to relate more than 2 individuals or to relate an individual to a list. This cannot be done within OWL. They may need to adopt a pattern instead which encodes the meaning outside the formal semantics.<ref>{{cite web |url=http://www.w3.org/TR/swbp-n-aryRelations/ |title=Defining N-ary Relations on the Semantic Web |first=Natasha |last=Noy |authorlink=Natasha Noy |first2=Alan |last2=Rector |authorlink2=Alan Rector |date=2006-04-12 |publisher=World Wide Web Consortium |accessdate=17 April 2010 }}</ref>
 
== See also ==
* RDF
* [[Agris: International Information System for the Agricultural Sciences and Technology]]
* [[Bossam (software)|Bossam]]: A rule-based OWL reasoner
* [[Common logic]]
* [[FOAF (software)|FOAF]] + [[Description of a Career|DOAC]]
* [[Enterprise Architect Visual Modeling Platform|Enterprise Architect]] [http://www.sparxsystems.com/enterprise_architect_user_guide/9.3/domain_based_models/mdg_technology_for_odm.html MDG Technology for ODM] (ODM supports OWL and RDF modeling)
* [[Geopolitical ontology]]
* [[IDEAS Group]]
* [[Meta-Object Facility|Meta-Object Facility (MOF)]], a different standard for the [[Unified Modeling Language|Unified Modeling Language (UML)]] of the [[Object Management Group|Object Management Group (OMG)]]
* [[Multimedia Web Ontology Language]]
* [[SKOS]]
* [[SSWAP]]: Simple Semantic Web Architecture and Protocol
* [[Website Parse Template]]


==References==
==References==
{{reflist|2}}
{{Reflist|2}}


==External links==
==External links==
* [http://www.usingcsp.com/ A PDF version of Hoare's CSP book] - Copyright restriction apply, see the page text before downloading.
* [http://www.cs.ox.ac.uk/people/ian.horrocks/Seminars/ Horrocks, Ian] (2010); [http://semtech2010.semanticuniverse.com/ SemTech 2010] tutorial [http://www.comlab.ox.ac.uk/people/ian.horrocks/Seminars/download/Horrocks_Ian_pt1.pdf part 1] and [http://www.comlab.ox.ac.uk/people/ian.horrocks/Seminars/download/Horrocks_Ian_pt2.pdf part 2] on Description Logics and OWL
* [http://www.wotug.org/ WoTUG], a User Group for CSP and occam style systems, contains some information about CSP and useful links.
* [http://www.semantic-web-book.org/page/ESWC09_Tutorial ESWC09 Tutorial] including an introduction to OWL 2
* [http://citeseerx.ist.psu.edu/search?q=communicating+sequential+processes&submit=Search&sort=rlv&t=doc CSP Citations from CiteSeer]
* [http://www.visualmodeling.com/VisualOWL.htm Visual OWL] Visual Modeling Forum page dedicated to graphic notations for OWL
* [https://github.com/loyso/LuaCSP LuaCSP], a framework that allows you to create CSP Occam-like Lua-based programming language embeddable in your application.
* [http://www.cs.man.ac.uk/~horrocks/ISWC2003/Tutorial/ Tutorial on OWL] at [http://www.cs.man.ac.uk/ the University of Manchester Computer Science Department]
* [http://www.inf.unibz.it/~franconi/dl/course/ ''Introduction to Description Logics'' DL course] by Enrico Franconi, Faculty of Computer Science, Free University of Bolzano, Italy
* [http://www.co-ode.org/ Cooperative Ontologies (CO-ODE) web site] includes OWL tutorial materials and software.
* [http://diplom.ooyoo.de/ UML2OWL - XSLT scripts to transform UML class diagrams into valid OWL DL ontologies / modelling OWL DL ontologies with UML]
* [http://owlapi.sourceforge.net/ OWL API] API for Using OWL 2, at SourceForge
* [http://rowlex.nc3a.nato.int/ ROWLEX Toolkit] NATO C3 Agency Semantic Interoperability Relaxed OWL Experience Toolkit for .NET
* [http://viziquer.lumii.lv ViziQuer] a tool that allows to browse a SPARQL endpoint ontology and construct SPARQL queries
 
{{Semantic Web}}
{{W3C Standards}}
 
[[Category:World Wide Web Consortium standards]]
[[Category:Resource Description Framework]]
[[Category:School of Computer Science, University of Manchester]]
[[Category:XML-based standards]]
[[Category:Declarative programming languages]]
[[Category:Ontology languages]]
[[Category:Semantic Web]]


{{DEFAULTSORT:Communicating Sequential Processes}}
[[ca:OWL]]
[[Category:1978 introductions]]
[[da:Web Ontology Language]]
[[Category:1978 in computer science]]
[[de:Web Ontology Language]]
[[Category:Process calculi]]
[[es:OWL]]
[[Category:Concurrent computing]]
[[eu:OWL]]
[[fa:زبان هستی‌شناسی وب]]
[[fr:Web Ontology Language]]
[[it:Web Ontology Language]]
[[hu:Web Ontology Language]]
[[nl:Web Ontology Language]]
[[ja:OWL]]
[[pl:Web Ontology Language]]
[[pt:OWL]]
[[ru:Web Ontology Language]]
[[fi:OWL]]
[[th:Web Ontology Language]]
[[tr:Web Ontoloji Dili]]
[[uk:Web Ontology Language]]
[[zh:网络本体语言]]

Revision as of 01:41, 11 August 2014

Template:Infobox W3C Standard Template:Infobox W3C Standard The Web Ontology Language (OWL) is a family of knowledge representation languages for authoring ontologies. The languages are characterised by formal semantics and RDF/XML-based serializations for the Semantic Web. OWL is endorsed by the World Wide Web Consortium (W3C)[1] and has attracted academic, medical and commercial interest.

In October 2007, a new W3C working group[2] was started to extend OWL with several new features as proposed in the OWL 1.1 member submission.[3] W3C announced the new version of OWL on 27 October 2009.[4] This new version, called OWL 2, soon found its way into semantic editors such as Protégé and semantic reasoners such as Pellet,[5][6] RacerPro,[7] FaCT++[8][9] and HermiT.[10]

The OWL family contains many species, serializations, syntaxes and specifications with similar names. OWL and OWL2 are used to refer to the 2004 and 2009 specifications, respectively. Full species names will be used, including specification version (for example, OWL2 EL). When referring more generally, OWL Family will be used.

History

Early ontology languages

47 year-old Podiatrist Hyslop from Alert Bay, has lots of hobbies and interests that include fencing, property developers in condo new launch singapore and handball. Just had a family trip to Monasteries of Haghpat and Sanahin. There is a long history of ontological development in philosophy and computer science. Since the 1990s, a number of research efforts have explored how the idea of knowledge representation (KR) from artificial intelligence (AI) could be made useful on the World Wide Web. These included languages based on HTML (called SHOE), based on XML (called XOL, later OIL), and various frame-based KR languages and knowledge acquisition approaches.

Ontology languages for the web

In 2000 in the United States, DARPA started development of DAML led by James Hendler.[11] In March 2001, the Joint EU/US Committee on Agent Markup Languages decided that DAML should be merged with OIL.[11] The EU/US ad hoc Joint Working Group on Agent Markup Languages was convened to develop DAML+OIL as a web ontology language. This group was jointly funded by the DARPA (under the DAML program) and the European Union's Information Society Technologies (IST) funding project. DAML+OIL was intended to be a thin layer above RDFS,[11] with formal semantics based on a description logic (DL).[12]

OWL started as a research-based[13] revision of DAML+OIL aimed at the semantic web.

Semantic web standards

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

47 year-old Podiatrist Hyslop from Alert Bay, has lots of hobbies and interests that include fencing, property developers in condo new launch singapore and handball. Just had a family trip to Monasteries of Haghpat and Sanahin.

RDF schema

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

In the late 1990s, the World Wide Web Consortium (W3C) Metadata Activity started work on RDF Schema (RDFS), a language for RDF vocabulary sharing. The RDF became a W3C Recommendation in February 1999, and RDFS a Candidate Recommendation in March 2000.[14] In February 2001, the Semantic Web Activity replaced the Metadata Activity.[14] In 2004 (as part of a wider revision of RDF) RDFS became a W3C Recommendation.[15] Though RDFS provides some support for ontology specification, the need for a more expressive ontology language had become clear.[16]

47 year-old Podiatrist Hyslop from Alert Bay, has lots of hobbies and interests that include fencing, property developers in condo new launch singapore and handball. Just had a family trip to Monasteries of Haghpat and Sanahin.

Web-Ontology Working Group

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

The World Wide Web Consortium (W3C) created the Web-Ontology Working Group as part of their Semantic Web Activity. It began work on November 1, 2001 with co-chairs James Hendler and Guus Schreiber.[17] The first working drafts of the abstract syntax, reference and synopsis were published in July 2002.[17] OWL became a formal W3C recommendation on February 10, 2004 and the working group was disbanded on May 31, 2004.[17]

OWL Working Group

In 2005, at the OWL Experiences And Directions Workshop a consensus formed that recent advances in description logic would allow a more expressive revision to satisfy user requirements more comprehensively whilst retaining good computational properties. In December 2006, the OWL1.1 Member Submission[18] was made to the W3C. The W3C chartered the OWL Working Group as part of the Semantic Web Activity in September 2007. In April 2008, this group decided to call this new language OWL2, indicating a substantial revision.[19]

OWL 2 became a W3C recommendation in October 2009. OWL 2 introduces profiles to improve scalability in typical applications.[4]

Acronym

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

The natural acronym for Web Ontology Language would be WOL instead of OWL. Although the character Owl from Winnie the Pooh wrote his name WOL, the acronym OWL was proposed without reference to that character, as an easily pronounced acronym that would yield good logos, suggest wisdom, and honor William A. Martin's One World Language knowledge representation project from the 1970s.

Adoption

A survey (published in 2006) of ontologies available on the web collected 688 OWL ontologies. Of these, 199 were OWL Lite, 149 were OWL DL and 337 OWL Full (by syntax). They found that 19 ontologies had in excess of 2,000 classes, and that 6 had more than 10,000. The same survey collected 587 RDFS vocabularies.[20]

Ontologies

Mining Engineer (Excluding Oil ) Truman from Alma, loves to spend time knotting, largest property developers in singapore developers in singapore and stamp collecting. Recently had a family visit to Urnes Stave Church.

Introduction

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

The data described by an ontology in the OWL family is interpreted as a set of "individuals" and a set of "property assertions" which relate these individuals to each other. An ontology consists of a set of axioms which place constraints on sets of individuals (called "classes") and the types of relationships permitted between them. These axioms provide semantics by allowing systems to infer additional information based on the data explicitly provided. A full introduction to the expressive power of the OWL is provided in the W3C's OWL Guide.

Example

An ontology describing families might include axioms stating that a "hasMother" property is only present between two individuals when "hasParent" is also present, and individuals of class "HasTypeOBlood" are never related via "hasParent" to members of the "HasTypeABBlood" class. If it is stated that the individual Harriet is related via "hasMother" to the individual Sue, and that Harriet is a member of the "HasTypeOBlood" class, then it can be inferred that Sue is not a member of "HasTypeABBlood".

Species

OWL sublanguages

The W3C-endorsed OWL specification includes the definition of three variants of OWL, with different levels of expressiveness. These are OWL Lite, OWL DL and OWL Full (ordered by increasing expressiveness). Each of these sublanguages is a syntactic extension of its simpler predecessor. The following set of relations hold. Their inverses do not.

  • Every legal OWL Lite ontology is a legal OWL DL ontology.
  • Every legal OWL DL ontology is a legal OWL Full ontology.
  • Every valid OWL Lite conclusion is a valid OWL DL conclusion.
  • Every valid OWL DL conclusion is a valid OWL Full conclusion.

OWL Lite

OWL Lite was originally intended to support those users primarily needing a classification hierarchy and simple constraints. For example, while it supports cardinality constraints, it only permits cardinality values of 0 or 1. It was hoped that it would be simpler to provide tool support for OWL Lite than its more expressive relatives, allowing quick migration path for systems utilizing thesauri and other taxonomies. In practice, however, most of the expressiveness constraints placed on OWL Lite amount to little more than syntactic inconveniences: most of the constructs available in OWL DL can be built using complex combinations of OWL Lite features.[19] Development of OWL Lite tools has thus proven almost as difficult as development of tools for OWL DL, and OWL Lite is not widely used.[19]

OWL DL

OWL DL was designed to provide the maximum expressiveness possible while retaining computational completeness (either φ or ¬φ belong), decidability (there is an effective procedure to determine whether φ is derivable or not), and the availability of practical reasoning algorithms. OWL DL includes all OWL language constructs, but they can be used only under certain restrictions (for example, number restrictions may not be placed upon properties which are declared to be transitive). OWL DL is so named due to its correspondence with description logic, a field of research that has studied the logics that form the formal foundation of OWL.

OWL Full

OWL Full is based on a different semantics from OWL Lite or OWL DL, and was designed to preserve some compatibility with RDF Schema. For example, in OWL Full a class can be treated simultaneously as a collection of individuals and as an individual in its own right; this is not permitted in OWL DL. OWL Full allows an ontology to augment the meaning of the pre-defined (RDF or OWL) vocabulary. OWL Full is undecidable, so no reasoning software is able to perform complete reasoning for it.

OWL2 profiles

In OWL 2, there are three sublanguages of the language. OWL 2 EL is a fragment that has polynomial time reasoning complexity; OWL 2 QL is designed to enable easier access and query to data stored in databases; OWL 2 RL is a rule subset of OWL 2.

Syntax

The OWL family of languages supports a variety of syntaxes. It is useful to distinguish high level syntaxes aimed at specification from exchange syntaxes more suitable for general use.

High level

These are close to the ontology structure of languages in the OWL family.

OWL abstract syntax

This high level syntax is used to specify the OWL ontology structure and semantics.[21]

The OWL abstract syntax presents an ontology as a sequence of annotations, axioms and facts. Annotations carry machine and human oriented meta-data. Information about the classes, properties and individuals that compose the ontology is contained in axioms and facts only. Each class, property and individual is either anonymous or identified by an URI reference. Facts state data either about an individual or about a pair of individual identifiers (that the objects identified are distinct or the same). Axioms specify the characteristics of classes and properties. This style is similar to frame languages, and quite dissimilar to well known syntaxes for description logics (DLs) and Resource Description Framework (RDF).[21]

Sean Bechhofer, et al. argue that though this syntax is hard to parse, it is quite concrete. They conclude that the name abstract syntax may be somewhat misleading.[22]

OWL2 functional syntax

This syntax closely follows the structure of an OWL2 ontology. It is used by OWL2 to specify semantics, mappings to exchange syntaxes and profiles.[23]

Exchange syntaxes

Template:Infobox file format

RDF syntaxes

Syntactic mappings into RDF are specified[21][24] for languages in the OWL family. Several RDF serialization formats have been devised. Each leads to a syntax for languages in the OWL family through this mapping. RDF/XML is normative.[21][24]

OWL2 XML syntax

OWL2 specifies an XML serialization that closely models the structure of an OWL2 ontology.[25]

Manchester Syntax

The Manchester Syntax is a compact, human readable syntax with a style close to frame languages. Variations are available for OWL and OWL2. Not all OWL and OWL2 ontologies can be expressed in this syntax.[26]

Examples

  • The W3C OWL 2 Web Ontology Language provides syntax examples.[27]

Tea ontology

Consider an ontology for tea based on a Tea class. But first, an ontology is needed. Every OWL ontology must be identified by an URI (http://www.example.org/tea.owl, say). This is enough to get a flavour of the syntax. To save space below, preambles and prefix definitions have been skipped.

OWL2 Functional Syntax 

Ontology(<http://example.com/tea.owl>
  Declaration( Class( :Tea ) )
)

OWL2 XML Syntax 

 <Ontology ontologyIRI="http://example.com/tea.owl" ...>
   <Prefix name="owl" IRI="http://www.w3.org/2002/07/owl#"/>
   <Declaration>
     <Class IRI="Tea"/>
   </Declaration>
 </Ontology>

Manchester Syntax 

Ontology: <http://example.com/tea.owl>
Class: Tea

RDF/XML syntax 

<rdf:RDF ...>
    <owl:Ontology rdf:about=""/>
    <owl:Class rdf:about="#Tea"/>
</rdf:RDF>

RDF/Turtle 

 <http://example.com/tea.owl> rdf:type owl:Ontology .
 :Tea  rdf:type            owl:Class .

Semantics

Mining Engineer (Excluding Oil ) Truman from Alma, loves to spend time knotting, largest property developers in singapore developers in singapore and stamp collecting. Recently had a family visit to Urnes Stave Church.

Relation to description logic

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

Early attempts to build large ontologies were plagued by a lack of clear definitions. Members of the OWL family have model theoretic formal semantics, and so have strong logical foundations.

Description logics (DLs) are a family of logics that are decidable fragments of first-order logic with attractive and well-understood computational properties. OWL DL and OWL Lite semantics are based on DLs.[28] They combine a syntax for describing and exchanging ontologies, and formal semantics that gives them meaning. For example, OWL DL corresponds to the SHOIN (D) description logic, while OWL 2 corresponds to the SROIQ(D) logic.[29] Sound, complete, terminating reasoners (i.e. systems which are guaranteed to derive every consequence of the knowledge in an ontology) exist for these DLs.

Relation To RDFS

OWL Full is intended to be compatible with RDF Schema (RDFS), and to be capable of augmenting the meanings of existing Resource Description Framework (RDF) vocabulary.[30] A model theory describes the formal semantics for RDF.[31] This interpretation provides the meaning of RDF and RDFS vocabulary. So, the meaning of OWL Full ontologies are defined by extension of the RDFS meaning, and OWL Full is a semantic extension of RDF.[32]

Open world assumption

31 year-old Systems Analyst Bud from Deep River, spends time with pursuits for instance r/c cars, property developers new condo in singapore singapore and books. Last month just traveled to Orkhon Valley Cultural Landscape.

The languages in the OWL family use the open world assumption. Under the open world assumption, if a statement cannot be proven to be true with current knowledge, we cannot draw the conclusion that the statement is false.

Contrast to other languages

A relational database consists of sets of tuples with the same attributes. SQL is a query and management language for relational databases. Prolog is a logical programming language. Both use the closed world assumption.

Terminology

Languages in the OWL family are capable of creating classes, properties, defining instances and its operations.

Instances

An instance is an object. It corresponds to a description logic individual.

Classes

A class is a collection of objects. It corresponds to a description logic (DL) concept. A class may contain individuals, instances of the class. A class may have any number of instances. An instance may belong to none, one or more classes.

A class may be a subclass of another, inheriting characteristics from its parent superclass. This corresponds to logical subsumption and DL concept inclusion notated .

All classes are subclasses of owl:Thing (DL top notated ), the root class.

All classes are subclassed by owl:Nothing (DL bottom notated ), the empty class. No instances are members of owl:Nothing. Modelers use owl:Thing and owl:Nothing to assert facts about all or no instances.[33]

Example

For example, Employee could be the subclass of class owl:Thing while Dealer, Manager, and Labourer all subclass of Employee.

Properties

A property is a directed binary relation that specifies class characteristics. It corresponds to a description logic role. They are attributes of instances and sometimes act as data values or link to other instances. Properties may possess logical capabilities such as being transitive, symmetric, inverse and functional. Properties may also have domains and ranges.

Datatype properties

Datatype properties are relations between instances of classes and RDF literals or XML schema datatypes. For example, modelName (String datatype) is the property of Manufacturer class. They are formulated using owl:DatatypeProperty type.

Object properties

Object properties are relations between instances of two classes. For example, ownedBy may be an object type property of the Vehicle class and may have a range which is the class Person. They are formulated using owl:ObjectProperty.

Operators

Languages in the OWL family support various operations on classes such as union, intersection and complement. They also allow class enumeration, cardinality, and disjointness.

Public ontologies

Libraries

Biomedical

Miscellaneous

Standards

Browsers

The following tools include public ontology browsers:

Search

Limitations

  • No direct language support for n-ary relationships. For example modelers may wish to describe the qualities of a relation, to relate more than 2 individuals or to relate an individual to a list. This cannot be done within OWL. They may need to adopt a pattern instead which encodes the meaning outside the formal semantics.[40]

See also

References

43 year old Petroleum Engineer Harry from Deep River, usually spends time with hobbies and interests like renting movies, property developers in singapore new condominium and vehicle racing. Constantly enjoys going to destinations like Camino Real de Tierra Adentro.

External links

Template:Semantic Web Template:W3C Standards

ca:OWL da:Web Ontology Language de:Web Ontology Language es:OWL eu:OWL fa:زبان هستی‌شناسی وب fr:Web Ontology Language it:Web Ontology Language hu:Web Ontology Language nl:Web Ontology Language ja:OWL pl:Web Ontology Language pt:OWL ru:Web Ontology Language fi:OWL th:Web Ontology Language tr:Web Ontoloji Dili uk:Web Ontology Language zh:网络本体语言

  1. ↑ Template:Cite web
  2. ↑ W3C working group
  3. ↑ Template:Cite web
  4. ↑ 4.0 4.1 http://www.w3.org/2009/10/owl2-pr
  5. ↑ Template:Cite doi
  6. ↑ Pellet
  7. ↑ RacerPro
  8. ↑ Template:Cite doi
  9. ↑ FaCT++
  10. ↑ HermiT
  11. ↑ 11.0 11.1 11.2 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.

    My blog: http://www.primaboinca.com/view_profile.php?userid=5889534
  12. ↑ 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.

    My blog: http://www.primaboinca.com/view_profile.php?userid=5889534
  13. ↑ Template:Cite web
  14. ↑ 14.0 14.1 Cite error: Invalid <ref> tag; no text was provided for refs named metadata.activity
  15. ↑ Template:Cite web
  16. ↑ 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.

    My blog: http://www.primaboinca.com/view_profile.php?userid=5889534
  17. ↑ 17.0 17.1 17.2 Template:Cite web
  18. ↑ Template:Cite web
  19. ↑ 19.0 19.1 19.2 Template:Cite doi
  20. ↑ Template:Cite doi
  21. ↑ 21.0 21.1 21.2 21.3 Template:Cite web
  22. ↑ Template:Cite web
  23. ↑ Template:Cite web
  24. ↑ 24.0 24.1 Template:Cite web
  25. ↑ Template:Cite web
  26. ↑ Template:Cite web
  27. ↑ Template:Cite web
  28. ↑ Template:Cite web
  29. ↑ 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.

    My blog: http://www.primaboinca.com/view_profile.php?userid=5889534
  30. ↑ Template:Cite web
  31. ↑ Template:Cite web
  32. ↑ Template:Cite web
  33. ↑ 20 year-old Real Estate Agent Rusty from Saint-Paul, has hobbies and interests which includes monopoly, property developers in singapore and poker. Will soon undertake a contiki trip that may include going to the Lower Valley of the Omo.

    My blog: http://www.primaboinca.com/view_profile.php?userid=5889534
  34. ↑ OBO Foundry
  35. ↑ OBO Download Matrix
  36. ↑ NCBO BioPortal
  37. ↑ SUMO download
  38. ↑ TDWG LSID Vocabularies
  39. ↑ Protégé web site
  40. ↑ Template:Cite web
Retrieved from "https://en.formulasearchengine.com/index.php?title=Main_Page&oldid=39775"