You are currently browsing the category archive for the ‘Semantic Web’ category.

SWRL:

SWRL is a Semantic Web Rule Language, which combines OWL and RuleML

An OWL ontology in the abstract syntax contains a sequence of axioms and facts. Axioms may be of various kinds, e.g., subClass axioms and equivalentClass axioms. It is proposed to extend this with rule axioms.

axiom ::= rule

A rule axiom consists of an antecedent (body) and a consequent (head), each of which consists of a (posibly empty) set of atoms. A rule axiom can also be assigned a URI reference, which could serve to identify the rule.

rule ::= 'Implies(' [ URIreference ] { annotation } antecedent consequent ')'
antecedent ::= 'Antecedent(' { atom } ')'
consequent ::= 'Consequent(' { atom } ')'

Informally, a rule may be read as meaning that if the antecedent holds (is “true”), then the consequent must also hold. An empty antecedent is treated as trivially holding (true), and an empty consequent is treated as trivially not holding (false). Rules with an empty antecedent can thus be used to provide unconditional facts; however such unconditional facts are better stated in OWL itself, i.e., without the use of the rule construct. Non-empty antecedents and consequents hold iff all of their constituent atoms hold, i.e., they are treated as conjunctions of their atoms. As mentioned above, rules with conjunctive consequents could easily transformed into multiple rules each with an atomic consequent. This principles leads to an atomistic approach, similar to Symbolic Analysis.

OWL’s atom is like this:

atom ::= description '(' i-object ')'
	 | dataRange '(' d-object ')'
	 | individualvaluedPropertyID '(' i-object i-object ')'
	 | datavaluedPropertyID '(' i-object d-object ')'
	 | sameAs '(' i-object i-object ')'
	 | differentFrom '(' i-object i-object ')'
	 | builtIn '(' builtinID { d-object } ')'
builtinID ::= URIreference

Let’s see AHO to compare it into the atom of Symbolic Analysis.

Comparing RuleML and Prolog

Prolog:

discount(customer,product1,’5.0 percent’) :-
premium(customer),regular(product).

The corresponding XML-query in RuleML:

<imp>
<_head>
<atom>
<_opr><rel>discount</rel></_opr>
<var>customer</var>
<var>product</var>
<ind>5.0 percent</ind>
</atom>
</_head>
<_body>
<and>
<atom>
<_opr><rel>premium</rel></_opr>
<var>customer</var>
</atom>
<atom>
<_opr><rel>regular</rel></_opr>
<var>product</var>
</atom>
</and>
</_body>
</imp>

Example:

A simple use of these rules would be to assert that the combination of the hasParent and hasBrother properties implies the hasUncle property. Informally, this rule could be written as:

hasParent(?x1,?x2) and hasBrother(?x2,?x3) ==> hasUncle(?x1,?x3)

In the abstract syntax the rule would be written like:

Implies(Antecedent(hasParent(I-variable(x1) I-variable(x2))
		   hasBrother(I-variable(x2) I-variable(x3)))
	Consequent(hasUncle(I-variable(x1) I-variable(x3))))

From this rule, if John has Mary as a parent and Mary has Bill as a brother then John has Bill as an uncle.

In RuleML it is:

<ruleml:imp>
  <ruleml:_rlab ruleml:href="#example1"/>
  <ruleml:_body>
    <swrlx:individualPropertyAtom  swrlx:property="hasParent">
      <ruleml:var>x1</ruleml:var>
      <ruleml:var>x2</ruleml:var>
    </swrlx:individualPropertyAtom>
    <swrlx:individualPropertyAtom  swrlx:property="hasBrother">
      <ruleml:var>x2</ruleml:var>
      <ruleml:var>x3</ruleml:var>
    </swrlx:individualPropertyAtom>
  </ruleml:_body>
  <ruleml:_head>
    <swrlx:individualPropertyAtom  swrlx:property="hasUncle">
      <ruleml:var>x1</ruleml:var>
      <ruleml:var>x3</ruleml:var>
    </swrlx:individualPropertyAtom>
  </ruleml:_head>
</ruleml:imp>

In Prolog it is:

hasUncle(X1, X3):-

hasParent(X1, X2), hasBrother(X2, X3).

Comparison: Semantics of Semantic Web and Symbolic Analysis

Some differences between the Semantic Web policy and the one of Symbolic Analysis.

Atom Condition on Interpretation
C(x) S(x) ∈ EC(C)
D(z) S(z) ∈ EC(D)
P(x,y) <S(x),S(y)> ∈ ER(P)
Q(x,z) <S(x),L(z)> ∈ ER(Q)
sameAs(x,y) S(x) = S(y)
differentFrom(x,y) S(x) ≠ S(y)
builtIn(r,z1,…,zn) <S(z1),…,S(zn)> ∈ D(f)

In Symbolic Analysis all definitions are clauses. The clause has its Prolog-based syntax, being a fact. However, the principles and the main goal have many similar features.

Some links

OBS:

Atom is a system for distribution of information on the web (see http://semtext.org/atom/atom-semweb.htm). It is also a project that aims to create weblog and syndication formats and APIs that the developers can unite behind, allowing future progress in these fields without the political and technical problems that have plagued developers over recent years. The project was initiated by Sam Ruby, and is being developed collaboratively on a Wiki.

Semantics is the study of meaning, usually in language. The word “semantics” itself denotes a range of ideas, from the popular to the highly technical. It is often used in ordinary language to denote a problem of understanding that comes down to word selection or connotation.

In computer science semantics reflects the meaning of programs or functions. It is considered as an application of mathematical logic,

In this regard, semantics permits programs to be separated into their syntactical part (grammatical structure) and their semantic part (meaning). For instance, the following statements use different syntaxes, but issue the same instructions:

Generally these operations would all perform an arithmetical addition of ‘y’ to ‘x’ and store the result in a variable called ‘x’.

Semantics for computer applications falls into many categories. The most relevant ones are:

  1. Operational semantics: The meaning of a construct is specified by the computation it induces when it is executed on a machine. In particular, it is of interest how the effect of a computation is produced.
  2. Denotational semantics: Meanings are modelled by mathematical objects that represent the effect of executing the constructs. Thus only the effect is of interest, not how it is obtained.
  3. Axiomatic semantics: Specific properties of the effect of executing the constructs as expressed as assertions. Thus there may be aspects of the executions that are ignored.
  4. Action semantics is a framework for the formal specification of semantics of programming languages (Watt & Mosses) being a mixture of denotational, operational and algebraic semantics.
  5. Algebraic semantics is a formal semantics based on algebras.
  6. Natural semantics is a specification method for interpretations.

Problems with Many Different Notations

Different semantics presentations cause much trouble for students and practicians.  It is not possible for a typical Joe Programmer to read semantics specifications for languages or complex models. Therefore, in a long run, there is a strong need to create a unified semantics for computer programs and languages and models.

In order to be able to express (almost) all possible information considering computer science, the notation should be very flexible, complete, consistent and declarative to allow practicians to easily understand the meaning of each term and expression. The selected unified semantics should be able to connect the features typical for algebra (A), language terms (L), operational features (O), and natural notation (N).

Atomistic Semantics is a Step Towards a Unified Semantics

Atomistic Semantics (Laitila) is a hybrid construction, which uses an algebraic notation when connecting symbols with each other and predicate logic to connect axiomatic features for each symbol. It describes the operational features by using a state transition table-mechanism, whose semantics is a very easy to be read and understood. It contains the original features of source code captured from programs and abstracted in a higher notation language, called Symbolic.  There is no need to use denotational semantics to extend atomistic semantics, because the lower level computational features of the symbolic atomistic model are predicates and clauses of the run method of each symbol. The lowest level can be specified by Prolog and be programmed, too. As a sugar, atomistic semantics is capable of expressing Semantic Web implementations, too.

Some links:

The Semantic Web is an evolving development of the World Wide Web in which the meaning (semantics) of information and services on the web is defined, making it possible for the web to understand and satisfy the requests of people and machines to use the web content. It derives from World Wide Web Consortium director Sir Tim Berners-Lee‘s vision of the Web as a universal medium for data, information, and knowledge exchange. His vision was:

I have a dream for the Web [in which computers] become capable of analyzing all the data on the Web – the content, links, and transactions between people and computers. A ‘Semantic Web’, which should make this possible, has yet to emerge, but when it does, the day-to-day mechanisms of trade, bureaucracy and our daily lives will be handled by machines talking to machines. The ‘intelligent agents’ people have touted for ages will finally materialize.

Tim Berners-Lee, 1999

Its architecture is, unfortunately, complex to be implemented.

According to Albert Einstein, Everything should be made as simple as possible, but not simpler.

Semantic_Web_Layers_And_The_Atom

In the left side there is the architecture of the Semantic Web, and on the right-hand-side the one of the atomistic model.

Some links:

Erkki Laitila, PhD (2008) computer engineer (1977)