Jump to ContentJump to Main Navigation
Show Summary Details
More options …

Open Engineering

formerly Central European Journal of Engineering

Editor-in-Chief: Ritter, William

1 Issue per year


CiteScore 2017: 0.70

SCImago Journal Rank (SJR) 2017: 0.211
Source Normalized Impact per Paper (SNIP) 2017: 0.787

Open Access
Online
ISSN
2391-5439
See all formats and pricing
More options …

A logical specification language for ontologies in the system “Binary Model of Knowledge”

Gerald Plesniewicz / Baurzhan Karabekov / Dmitry Masherov
Published Online: 2018-05-31 | DOI: https://doi.org/10.1515/eng-2018-0017

Abstract

We describe the language LLS-1 for logical specifying ontologies written in “Binary Model of Knowledge” (BMK). BMK is the system intended for specifying heavy-weight ontologies by means of conceptual-type languages. The language LLS-1 has a user-friendly syntax in style of the Manchester syntax for OWL. We also determine a deduction method for LLS-1.

Keywords: knowledge bases; ontologies; specification languages; conceptual-type languages; logical specification languages; deduction

1 Introduction

Ontologies are seen as the key technology used to describe the semantics of information. An ontology is a formal description (in terms of concepts, entities, their properties and relationships) of knowledge for solving a given class of problems [1, 5].

“Binary Model of Knowledge” (BMK) is a platform intended for specifying ontologies by means of conceptual-type languages and for manipulating ontologies, in particular, for deduction and query answering over ontologies [3]. BMK is under development in the National Research University “MPEI”, Applied Mathematics Department (Moscow, Russia) and in the Institute of Information and Computing Technologies (Almaty, Kazakhstan). The architecture of BMK includes the ontology editor and knowledge management system Protégé 5.0 with plugins to it, that defines the functionality of BMK.

Semantics of BMK languages is defined using formal concepts. A formal concept is constructed of names which are members of the data type Name (subtype of the standard type String), and has the following components:

  • name C;

  • universe UC – the set of all possible names for instances of the concept C;

  • set ΓC of all points of reference – they can be interpreted as worlds, states of affaire, contexts, timepoints, and so on;

  • subset EC γ⊆ UC for each point γΓC – the set of all names for instances of C at the point of reference γ;

  • coreferentiality relation ~Cγ⊆ EC γ XEC γ for each point γΓC – two names are coreferential if they denote the same object of modelled problem domain.

The pair (EC γ,~C γ) is the extension ExtC γ of the concept C at the point of reference γ. The family ExtC γ = {ExtC γ | γΓC} is the full extension of C.

It is clear that coreferentiality is an equivalence relation, and the quotient EC γ/~C γ is in one-to-one correspondence with the set of the objects – instances of C. We will assume that every equivalence class contains, as a representative, some surrogate (or OID – object identifier). So, there is in BMK the data type Surr = {#1, #2, #3,…} of surrogates.

A concept system is a finite set of formal concepts with same points of reference. An ontology is a specification of a concept system.

Let O be any ontology and Ostr, Olog, Otran be its parts such that

  • statements of Ostr specify the universes of the concepts i.e. factually the concepts structure;

  • statements of Olog specifies the extensions of the concepts uniformly and independently of points of reference;

  • statements of Otran specify the changes EC γ Δ EC δ = (EC γ \EC δ) ∪ (EC δ \EC γ) for (γ,γ) ∈ R where R is some binary relation on ΓC.

For writing Ostr, Olog and Otran languages for structural, logical and transitional specification are used (respectively).

In BMK, there are several specification languages. In particular, there is the language LSS for structural specification and the language LLS-1 for logical specification. The main goal of the present paper is to describe the language LLS-1 and to present a method deduction for this language.

There are two types of concepts that can be specified by means of LSS – classes and links (binary relations). For example, consider the following LSS statements determining the universes of the classes and link

Employee[Name:String,Position:String, Works_at:Department],Project[ID:String,Budget:Integer, Supervisor:Employee,  Team:Employee(*)], (Employee Works_for Project)[Starts:Date],Department[Name:String,From:University].(1.1)

The statement (1.1) determines the universe UProject as the set of all tuples [ID:x, Budget:y, Supervisor:s, Team: {s1, s2,…, sn}]united with the set Surr = {#1,#2,…} of surrogates (OIDs – object identifiers) and the set IName of individual object names. Here x ∈ String, y ∈ Integer and s, s1, s2, …, sn ∈ Surr (n = 0, 1, 2,…).

We can define new concepts using constrains on attributes. For example, the following term defines the class of all employees from the department “Applied mathematics” that work for a project with the budget less than 200000 dollars:

Employee(Works_at='applied mathematics'; Works_for.Project.Budget=<200000).

This term can be considered as composite name of that class.

We use statements of logical specification languages for defining concept extensions. Also we can specify directly some tuples as instances or counter-instances of a given concept; for this purpose the tabular representation is used in BMK. For example, the head of tables for the link Works_for has the standard attributes Por (point of reference), Surr (surrogate), Coref (list of coreferential names), Sign (signs “+” and “–” for truth and false) and the specific attributes Employee, Project and Starts.

If the table for Works_for contains the row

(por2,#210,-,#17,#107,?)(1.2)

then at point of reference por2 we have that

#210[Employee:#17,Project:107, Starts:?](1.3)

and these two coreferential names don’t belong to the extension EWorks_for of the link Works_for. Informally (1.2) and (1.3) means that at the point of reference por2 the employee with the surrogate #17 don’t work for the project with the surrogate.

Remark

We aimed at such definition of syntax for LLS-1 that this syntax would be close to the Manchester syntax for OWL [2]. (The “Mancherster syntax” is a compact, user-friendly syntax with a style close to frame languages.)

In Section 2 we will take the known problem “Steamroller” and will write it as an ontology in the language LLS-1. In Section 3 we will describe exactly syntax and semantics of LLS-1. In Section 4 the deduction method for LLS-1 ontologies is presented.

2 Problem “Steamroller”

In 1978, Leonard Schubert set up the following problem for logical proving [6]. The name “Steamroller” of the problem is caused by the fact that in spite of its apparent simplicity, it turned out to be too hard for existing resolution-based theorem provers.

  1. Wolves, foxes, birds, caterpillars, and snails are animals.

  2. There are some of each of them.

  3. Grains are plants.

  4. There are some grains.

  5. Every animal either likes to eat all plants or all animals much smaller than itself that like to eat some plants.

  6. Caterpillars and snails are much smaller than birds, which are much smaller than foxes, which in turn are much smaller than wolves.

  7. Wolves do not like to eat foxes or grains, while birds like to eat caterpillars but not snails.

  8. Caterpillars and snails like to eat some grains. Therefore,

  9. There is an animal that likes to eat a grain-eating animal.

The problem “Steamroller” is to prove automatically that (a), (b),…, (g) logically imply (i).

Beginning to write “Steamroller” in the language LSL-1, we introduce the following concept names: Animal, Plant, Wolf, Fox, Bird, Caterpillar, Snail, Grain (for classes) and LikesToEat, MuchSmaller (for binary relations). All these classes have no structure, and so we do not write for them any LSL-1 statements besides the following two SSL statements defining the binary relations:

(Animal LikeToEat Animal| Plant). (Animal Smaller Animal).

We formalize the sentences (a) – (i) by the following LSL-1 statements.

  1. Wolf ISA Animal.(2.1)

     Fox ISA Animal.(2.2)

     Bird ISA Animal.(2.3)

     Caterpillar ISA Animal. (2.4)

     Snail ISA Animal. (2.5)

  2. EXIST Wolf.(2.6)

    EXIST Fox.(2.7)

    EXIST Bird.(2.8)

    EXIST Caterpillar. (2.9)

    EXIST Snail.(2.10)

  3. Grain ISA Plant.(2.11)

  4. EXIST Grain. (2.12)

  5. EACH Animal:S LikesToEat SOME Plant OR LikesToEat EACHAnimal THAT Smaller S ANDLikesToEat SOME Plant. (2.13)

  6. EACH Caterpillar Smaller EACHBird.(2.14)

    EACH Bird Smaller EACH Fox. (2.15)

    EACH Fox Smaller EACH Wolf. (2.16)

  7. EACH Wolf NOT LikesToEat EACH(Caterpilar OR Plant). (2.17)

    EACH Bird (LikeToEat EACHCaterpillar AND NOT LikeToEatEACH Snail).(2.18)

  8. EACH (Caterpillar OR Snail)LikesToEat SOME Plant.(2.19)

  9. EXIST Animal THAT LikeToEat SOMEAnimal THAT LikeToEatSOME Grain.(2.20)

Here, in (2.13), the symbol S indicates on sameness of concept instances: S denotes the same instance of Animal.

We consider the set of statements {(2.13), (2.13),…,(2.13)} as an example of an ontology written in the language LLS-1.

The solution of the problem “Steamroller” consists in the proof that (2.13) logically follows from {(2.13), (2.13),…,(2.13)}. This is equivalent that the ontology {(2.13), (2.13),…,(2.13), ~(2.13)} is inconsistent, where ~(2.13) denotes negation of the statement (2.13) i.e.

NULL Animal THAT LikeToEat SOME Animal THAT LikeToEat SOME Grain.(2.21)

3 Syntax and semantic of the language LLS-1

We introduce three types of terms in LLS-1: C-terms, L-terms and P-terms.

C-terms denote classes of objects. They are interpreted as subsets of the set Surr of surrogates. The examples of C-terms are

Wolf,Animal,Animal:S,NOTWolf,WolfORFox,

Animal THAT LikesToEat SOME Plant.

L-terms denote binary relations (links). They are interpreted as subsets of Surr X Surr. The examples of L-terms are

MuchSmaller,LikesToEat,NOTLikesToEat,MuchSmallerANDNOTLikesToEat.

P-terms denote unary predicates defined on the set Surr. Here are the examples of P-terms:

Smaller,Smaller EACH(WolfFox),LikesToEat SOME Plant.

Describing syntax and semantics of the language LSL-1, we will use the following syntactic classes:

  • c for individual objects;

  • N for concept names;

  • C, D, Ci for C-terms (i = 1, 2, 3,…);

  • L, M, Li for L-terms;

  • P, Q, Pi for P-terms;

  • S, T for sentences;

  • I for sameness indicators S, S1, S2,….

By “α” denote the value of an expression α of LSL-1 under an arbitrary fixed interpretation “_”.

  • SYNTAX of C-terms

    C1 :: = NOT C1 | (C1 AND C1)| (C1 OR C1)| N;

    C :: = C1 | C1 THAT P | THOSE P | C1: I

  • SEMANTICS of C-terms

    C ” ⊆ Surr, “NOT C ” = Surr\“C ”, “C:V ” = “C ”,

    C AND D” = “C” ⋂ “D”, “C OR D” = “C ” ∪ “D”,

    C THAT P” = {x ∈ “C” | “P”(x)}, “THOSE P” = {x | “P”(x)}.

  • SYNTAX of L-terms

    L1 :: = NOT L1 |L1 AND L1 || L1 OR L1 |N;

    L :: = L1 | INV(L1);

  • SEMANTICS of L-terms

    L” ⊆ Surr X Surr, “NOT L= Surr X Surr\“L”,

    L AND M” = “L” ∩ “M ”, “C OR D” = “C ” ∪ “D”,

    “INV(M)” = {(x,y) | (y,x)“M”}.

  • SYNTAX of P-terms

    P1 :: = NOT P1 | (P1 AND P1) | P1 OR P1 | N

    P :: = P1 | L SOME C | L EACH C | L ONLY C | (L I) | (L c).

  • SEMANTIC of P-terms

    “(x P)” ⟺ “P”(x), “(x NOT Q)”⟺ “Q”(x),

    “(x P AND Q)” ⟺ “P”(x) /\“Q”(x),

    “(x P OR Q)” ⟺ “P ”(x) \/ “Q ”(x),

    “(x L SOME C)” ⟺ (∃yC ”) (x,y)“L

    “(x L EACH C)” ⟺ (∀yC ”) (x,y)“L”,

    “(x L ONLY C)” ⟺∀y[(x,y)“L”→ yC”],

    “(x (L V))” ⟺ (x,“I ”) “L”,

    “(x (L c))” ⟺(x,“c”) “L”.

  • SYNTAX of statements

    S, T :: = NOT T | S AND T | S OR T | S IMP T |

    S = T | EXIST C | EXIST L | NULL C |

    NULL L | C ISA D | L ISA M | C = D |

    L = M | C = NOT D | L = NOT M |

    EACH C P | SOME C P.

  • SEMANTICS of statements

    “NOT T ” ⟺ “T ”, “S AND T ” ⟺“S ” /\ “T ”,

    S OR T ” ⟺“S ” \/ “T ”, “S IMP T ” ⟺“S ” $→$ “T ”,

    S = T” ⟺ “S ” ↔ “T ”, “EXIST C ” ⟺ “C ” ≠ ∅,

    “EXIST L” ⟺ “L” ≠ ∅, “NULL C ” ⟺ “C= ∅,

    “NULL L” ⟺ “L= ∅, “C ISA D” ⟺ “C ”⊆“D”,

    L ISA M ” ⟺ “L”⊆“M ”, “C = D” ⟺“C” = “D”,

    C = NOT D” ⟺ “C ” = Surr\“D”,

    L = NOT M ” ⟺ “L” = Surr X Surr\“M ”,

    “EACH C P ” ⟺ (∀x ∈ “C”) “P ”(x),

    “SOME C P ” ⟺ (∃yC ”) “P”(x).

We consider the following expressions as patterns for simple statements that consist of no more than three simple names (i.e. members of the data type Name):

  • EXIST C, NULL C, EXIST L, NULL L, C ISA D,

    C = D, C = NOT D, C = D AND E, C = D OR E,

    C = D THAT P, C = THOSE P, L = M, L = NOT M,

    L = M AND N, L = M OR N, L = INV (M), P = Q,

    P = NOT Q, P = Q AND Q’, P = Q OR Q’, P = L SOME C,

    P = L EACH C, P = L ONLY C, P = (L V), P = (L c),

    S = T, S = NOT T, S = T AND T’, S = T OR T’,

    S = T IMP T’, S = (T = T’), S = EXIST C,

    S = NULL C, S = EXIST L, S = NULL L, S = C ISA D,

    S = (C = D), S = (L = M), S = (P = Q).

Particular simple statements are obtained from patterns by replacing the parameters C, D, E, L, M,N, P, Q, Q’, S, T,T’ with simple names from Name. The names chosen for the parameters C, D and E are interpreted as classes; the names chosen for the parameters L, M and N are interpreted as binary relations; the names chosen for the parameters P, Q and Q’ are interpreted as classes; the names chosen for the parameters S, T and T’ are interpreted as classes,

As every logic, LLS-1 have the relation “| = ” of logical consequence. Let O be an ontology in LLS-1 (i.e. a finite set of statements from LLS-1) and φ is a LLS-1 statement. Then φ logically follows from O, O | = φ, if and only if there is no interpretation such that all statements from O are true and the statement φ is false.

A fact for an ontology O is an expression of one of the forms

+:S,:S,+u:C,u:C,+u:L:v,u:L:v

where u, v ∈ Surr ∪ Name ∪ Var. Facts with signs “+” and “–” are called positive and negative (correspondingly). For any interpretation “_” we define:

+u:CuC,u:Cu‘̸C,u:L:v(u,v)L,u:L:v(u,v)‘̸L.

A fact base for O is a finite set F of facts for O. A knowledge base is a set K = OF where F is a fact base for O. The relation “|=” of logical consequence is extended to fact bases and knowledge bases.

3.1 Equivalence of ontologies

Two ontologies O and O’ are equivalent if for any interpretation, all statements from O are true if and only if all statements from O’ are true.

It is easy to see that each LLS-1 ontology is equivalent to an ontology consisting of only simple statements. Consider an example.

Example 1

Take the statement.

NULL Animal THAT LikesToEat SOMEAnimal THAT LikesToEat SOME Grain.

Let us define:

P1=LikesToEat SOME Grain,(3.1)

C1=Animal THAT P1,(3.2)

P2=LikesToEat SOME C1,(3.3)

C2=Animal THAT P2,(3.4)

NULL C2.(3.5)

Clearly, two ontologies {(3.20)} and {(3.1), (3.2), (3.3), (3.4), (3.5)} are equivalent.

In general, let O be any LSS-1 ontology, and let us transform its statements to simple statements as we did it for statement (3.20). By O* denote the resulting ontology.

Example 2

Let O-St be the ontology for the Steamroller problem, O-St = {(2.1), (2.2),…, (2.19), (2.21)}. Then we obtain

  • O-St*={ (2.1)

    Wolf ISA Animal,

  • (2.2)

    Fox ISA Animal,

  • (2.3)

    Bird ISA Animal,

  • (2.4)

    Caterpillar ISA Animal,

  • (2.5)

    Snail ISA Animal,

  • (2.6)

    EXIST Wolf,

  • (2.7)

    EXIST Fox,

  • (2.8)

    EXIST Bird,

  • (2.9)

    EXIST Caterpillar,

  • (2.10)

    EXIST Snail,

  • (2.11)

    Grain ISA Plant,

  • (2.12)

    EXIST Grain,

  • (2.13)

    P1 = LikesToEat SOME Plant,

    P2 = Smaller X,

     P3 = P1 AND P2,

     C1 = Animal THAT P3,

    P4 = LikesToEat EACH C1,

    P5 = LikesToEat SOME Plant,

    P6 = P4 OR P5,

    EACH Animal:X P6,

  • (2.14)

    P7 = Smaller EACH Bird,

    EACH Caterpillar P7,

  • (2.15)

    P8 = Smaller EACH Fox,

    EACH Bird P8,

  • (2.16)

    P9 = Smaller EACH Wolf,

     EACH Fox P9,

  • (2.17)

    C2 = Caterpillar OR Plant,

    P10 = LikesToEat EACH C2,

     P11 = NOT P10,

    EACH Wolf P11,

  • (3.18)

    P12 = LikeToEat EACH

     Caterpillar,

    P13 = LikeToEat EACH Snail,

     P14 = NOT P13,

    P15 = P12 AND P14,

    EACH Bird P15,

  • (3.19)

    C3 = Caterpillar OR Snail,

    P16 = LikesToEat SOME Plant,

    EACH C3 LikesToEat P16,

  • (3.20)

    P17 = LikesToEat SOME Grain,

    C4 = Animal THAT P17,

     P18 = LikesToEat SOME C4,

    C5 = Animal THAT P18,

     NULL C5}.

4 Deduction for the language LLS-1

We define a deduction method based on applying productions to fact bases of LLS-1 ontologies.

A production has the form α = > β where α and β are conjunctions of facts (possibly, with variables). Below is the list of patterns with associated productions for the language LLS-1.

We associate productions with each pattern. Below is the list of these productions. It easy to prove that the productions are sound. For example, take the pattern 13: C = D OR E. Clearly, for any surrogate s : (i) if s ∈ “C” and s ∉ “D” then s ∈ “E”; (ii) if s ∈ “C” and s ∉ “E” then s ∈ “D”; (iii) if s ∉ “C” then s ∉ “D” and s ∉ “E”; (iv) if s ∉ “D” and s ∉ “E” then s ∉ “C” ; (v) if s ∈ “D” then s ∈ “C” ; (v) if s ∈ “E” then s ∈ “C”. Thus, all productions for the pattern 13 are sound.

  1. Pattern EXIST C.

    => +sj: C

    Here sj is new Skolem’s constant.

  2. Pattern NULL C.

    => -vj: C

    Here vj is new vriable.

  3. Pattern EXIST L.

    => +sj: L: +s(j+1)

    Here sj and s(j+1) are new Skolem’s constants.

  4. Pattern NULL L.

    => +vj: L: +v(j+1)

    Here vj and v(j+1) are new variables.

  5. Pattern C ISA D.

    +X: C => +X: D, –X: D => –X: C,

  6. Pattern L ISA M.

    +X: L: Y => +X: M: Y, –X: M: Y => –X: L: Y,

  7. Pattern C = D.

    +X: C => +X: D, –X: D => –X: C,

    +X: D => +X: C, –X: C => –X: D.

  8. Pattern L = M.

    +X: L: Y => +X: M: Y, –X: M: Y => –X: L: Y,

    +X: M: Y => +X: L: Y, –X: M: Y => –X: L: Y.

  9. Pattern EACH C P

    +X: C => +(X P), –(X P) => -X: C

  10. Pattern SOME C P

    => +sj: C ; +(sj P)

  11. Pattern C = NOT D.

    +X: C => –X: D, –X: D => +X: C,

    +X: D => –X: C, –X: C => +X: D.

  12. Pattern L = NOT M.

    +X: L: Y => –X: M: Y, –X: M: Y => +X: L: Y,

    +X: M: Y => –X: L: Y, –X: M: Y => +X: L: Y.

  13. Pattern L = INV(M).

    +X: L: Y => +Y: M: X, –X: L: Y => –Y: M: X.

  14. Pattern C = D AND E.

    +X: C => +X: D ; +X: E, +X: D ; +X: E => +X: C,

    –X: C ; +X: D => –X: E, –X: C ; +X: E => –X: D,

    –X: D => –X: C, –X: E => –X: C.

  15. Pattern C = D OR E.

    +X: C ; –X: D => +X: E, +X: C ; –X: E => +X: D,

    –X: C => –X: D ; –X: E, –X: D ; –X: E => –X: C,

    +X: D => +X: C, +X: E => +X: C.

  16. Pattern Lj = L AND M.

    +X: Lj: Y => +X: L: Y ; +X: M: Y,

    +X: L: Y ; +X: M: Y => +X: Lj: Y,

    –X: Lj: Y ; +X: L: Y => –X: M: Y,

    –X: Lj: Y ; +X: M: Y => –X: L: Y,

    –X: L: Y => –X: Lj: Y, –X: M: Y => –X: Lj: Y.

  17. Pattern Lj = L OR M.

    –X: Lj: Y => –X: L: Y; –X: M: Y,

    –X: L: Y; –X: M: Y => –X: Lj: Y

    +X: Lj: Y ; –X: L: Y => +X: M: Y,

    +X: Lj: Y ; –X: M: Y => +X: L: Y,

    +X: L: Y => +X: Lj: Y, +X: M: Y => +X: Lj: Y.

  18. Pattern Cj = C THAT P.

    +X: Cj => +X: C ; +(X P),

    +X: C ; +(X P) => +X: Cj,

    –X: Cj ; +X: C => – (X P),

    –X: Cj ; +(X P) => – X: C,

    –X: C => –X: Cj,

    – (X P) => –X: Cj.

  19. Pattern Pj = L SOME C.

    +(X Pj) =>+X: L: sk ; +sk: C,

    –(X Pj); +Y: C => –X:L:Y,

    –(X Pj) ; +X: L: Y => –Y: C.

  20. Pattern Pj = L EACH C.

    +(X Pj); +Y: C => +X:L:Y,

    +(X Pj) ; –X:L:Y => –Y: C,

    –(X Pj) => –X: L: sk ; +sk: C.

  21. Pattern Pj = L ONLY C.

    +(X Pj) ; +X:L:Y => +Y: C, +(X Pj) ;

    –X: L:Y => –Y: C,

    –(X Pj) => +X: L: sk ; –sk: C.

  22. Pattern Lj = INV(L).

    +X: L: Y => +Y: L: X,

    –X: L: Y => –Y: L: X.

    +(X Q) => +(X P),

    –(X P) => –(X Q).

  23. Pattern R = P AND Q.

    +(X R) => +(X P) ; +(X Q),

    –(X R) ; +(X P) => –(X Q),

    –(X R) ; +(X Q) => –(X P),

    –(X P) => –(X R),

    –(X Q) => –(X R).

  24. Pattern R = P OR Q

    –(X R) => –(X P) ; –(X Q),

    +(X R) ; –(X P) => +(X Q),

    +(X R) ; –(X Q) => +(X P), +(X P) => +(X R),

    –(X Q) => –(X R).

  25. Pattern P = (L V)

    +(X P) => +X: L: V.

    Here V is a variable.

  26. Pattern P = (L c)

    +(X P) => +X: L: c.

  27. Pattern S = T

    +: S => +: T, –: T => –: S, +: T => +: S,

    –: S => –: T.

  28. Pattern S = T AND T1

    +: S => +: T ; +: T1, –: S ; +: T => –: T1

    –: S ; +: T1 => –: T, –: T => –: S, –: T1 => –: S.

  29. Pattern S = T OR T1

    –: S => –: T ; –: T1, +: S ; –: T => +: T1,

    +: S ; –: T1 => +: T, +: T => +: S, +: T1 => +: S.

  30. Pattern S = T IMP T1

    –: S => +: T ; –: T1, +: S ; –: T => +: T1,

    +: S ; –: T1 => +: T, +: T => +: S, +: T1 => +: S.

  31. Pattern S = EXIST C.

    +: S => +sj: C, –: S => –vj: C, +c: C => +: S,

    v: C = > –: S.

    Here sj is new Skolem’s constant, vj is new variable, c is an object constant, v is a variable,

  32. Pattern S = EXIST L

    +: S => +sk: L: s(k+1), –: S => –vk: L: v(k+1),

    +c: L: d => +: S, –u: L: v = > –: S.

    Here sk and s(k+1) are new Skolem’s constants, vk and v(k+1) are new variables, c and d are object constants, u and v are variables.

  33. Pattern S = NULL C

    +: S => –vk: C, –: S => +sk: C, +v: C => +: S,

    +c: C => –: S.

    Here sk is new Skolem’s constant, vk is new variable, c is an object constants, v is a variable.

  34. Pattern S = NULL L

    +: S => –vk: L: v(k+1), –: S => +sk: L: s(k+1),

    + u: L: v => +: S, – c: L: d => –: S.

    Here, c and d are object constants, u and v are variables.

  35. Pattern S = C ISA D

    +: S ; +X: C => +X: D, +: S ; –X: D => –X: C,

    –: S => –cj: C ; +cj: D, –v: C => +: S,

    +v: D => +: S, +c: C ; –c: D => –: S.

  36. Pattern S = L ISA M.

    +: S ; +X: L => +X: M, +: S ; –X: M => –X: L,

    –: S => –sj : L: c(j+1) ; +cj:M:c(j+1),

    u: L: v => +: M, +u: M: v => +: S,

    +c: C ; –c: D => –: S.

  37. Pattern S = EACH C P

    +: S => +vj : C ; +(+vj P), –: S => +cj : C ; +(+cj P).

  38. Pattern S = SOME C P

    +: S => +cj : C ; +(+cj P)

  39. Pattern S = (C = D).

    +: S ; +X: C => +X: D, +: S ; –X: D => –X: C,

    –: S => –cj: C ; +cj: D, –v: C => +: S, +v: D => +: S,

    +c: D ; –c: C => –: S, +: S ; +X: D => +X: C,

    +: S ; –X: C => –X: D, –: S => –cj: D ; +cj: C,

    v: D => +: S, +v: C => +: S,

    +c: D ; –c: C => –: S.

  40. Pattern S = (L = M).

    +: S ; +X: L => +X: M, +: S ;

    –X: M => –X: L,

    –: S => –cj: L: c(j+1) ; +cj: M: c(j+1),

    u: L: v => +: S, +u: M: v => +: S,

    +c: C ; –c: D => –: S, +: S ; +X: M => +X: L,

    +: S ; –X: L => –X: M, –u: M: v => +: S

    –: S => –cj: M: c(j+1) ; +cj: L: c(j+1),

    +u: L: v => +: S, +c: C ; –c: D => –: S.

  41. Pattern S = (P = Q).,

    +: S ; +(P X) => +(Q X),

    +: S ; –(Q X) => –(P X),

    –: S => –(P cj); +(Q cj),

    –(P v:) => +: S,

    +(Q v) => +: S, +(Q c) ; –(P c) => –: S,

    +: S ; +(Q X) => +(P X), +: S ; –(P X) => –(Q X),

    –: S => –(Q cj) ; +(P cj), –v: D => +: S,

    +(P v) => +: S, +(Q c) ; –(P c) => –: S.

Deduction from a given ontology includes the application of productions. Consider, by example, how deduction proceeds.

Example 3

Take the ontology

O={EXIST Bird,P1 = LikesToEat SOME Plant,EACH Bird P1,NULL Plant}.

The statements from O correspond to patterns 1 (EXIST C), 19 (Pj = L SOME C), 9 (EACH C P) . Unifying these patterns with the statements of O and writing out the associated productions, we obtain the following set of productions:

P={=>+s1:Bird,(4.1)

+(XP1)=>+X:LikeToEat:s2;+s2:Plant,(XP1);+Y:Plant=>X:LikeToEat:Y,(XP1);+X:LikeToEat:Y=>Y:Plant,(4.2)

+X:Bird=>+(XP1),(XP)=>X:Bird,(4.3)

=>vj:Plant}.(4.4)

In Table 1, it is shown the sequence of fact bases obtained by application of productions P. Every fact base Fj is written in the j-th row of the table. The initial fact base F0 is empty. At step 1 the productions (4.1) and (4.4) are applied, and we obtain

F1={+s1:Bird,v1:Plant}.

Table 1

Deduction for the ontology from Example 3

At step 2 the production (4.3) is applied, and we obtained

F2={+s1:Bird,v1:Plant,+s1:P1}.

At step 3 the production (4.2) is applied, and we obtain

F3={+s1:Bird,v1:Plant,+s1:P1,+s2:Plant,+s1:LikeToEat:s2}.

We see that F3 contains the facts -v1:Plant and +s2:Plant which give the contradiction -v1:Plant and +s2:Plant when substituting v1: = s2. Thus, the fact base is inconsistent,

We have applied the deduction method to the ontology O-St for the problem “Steamroller”. The deduction had 11 steps before receiving a contradiction.

4.1 About implementation of the deduction method for LLS-1

For an implementation of the deduction method for LLS-1, we used the languages RDF, RDFS and SPARQL [1].

In the system BMK, there is the translator of LSS ontologies and fact bases into RDF schemes and RDF graphs. For example, information contained in (1.2) and (1.3) is written in RDF (in Turtle notation) as follows

@prefix ex:<http://#>@prefix rdf: < http://www.w3.org/1999/02/-rdf-syntax-ns#>ex:#210 rdf:type ex:Project ;ex:Por :#por2 ;ex:Sign:;ex:Employee :#17 ;ex:Project :#101 ;ex:Starts :? .

Let us outline how statements of the language LLS-1 and facts are translated to RDFS. It is sufficient to consider primitive statements. Take, for example, the statement

P1 = LikesToEat SOME Plant.

This statement can be unify with the pattern 17: Pj = L SOME C. Thus, we have the productions

+(X P1)=>+X:LikesToEat:sk ; +sk:Plant,(X P1); +Y:Plant =>X:LikesToEat:Y,(X P1); +X:LikesToEat:Y=>Y:Plant.

These productions are translated to PDFS as follows:

  • CONSTRUCT (:LikesToEat :sign :+)

     (:LikesToEat :first ?X).

     (:LikesToEat :second :sk).

     (:Plant :sign :+).

     (:Plant :member :sk).

  • WHERE (:P1 :pred ?X)

     (:P1 :sign :+).

  • CONSTRUCT (:LikesToEat :sign :-)

     (:LikesToEat :first ?X).

     (:LikesToEat :second ?Y).

  • WHERE (:P1 :pred ?X)

     (:P1 :sign :-).

     (:Plant :sign :+).

     (:Plant :member ?Y).

  • CONSTRUCT (:Plant :sign :-)

     (:Plant :member ?Y).

  • WHERE (:P1 :pred ?X)

     (:P1 :sign :-).

     (:LikesToEat :sign :+).

     (:LikesToEat :first ?X).

     (:LikesToEat :second ?Y).

5 Conclusion

We have described briefly the language LLS-1 for logical specification of ontologies in the system “Binary Model of Knowledge” (BMK). BMK is a platform intended for specifying ontologies by means of conceptual-type languages and for manipulating ontologies, in particular, for deduction and query answering over ontologies. We will implement BMK as the set of plugins to the system Protégé 5.0 [4].

Acknowledgement

This work was supported by Russian Foundation for Basic Research (project 14-07-0387) and Ministry of Education and Science of Kazakhstan (project 0115 RK 00532).

References

  • [1]

    D. Allemang, J. Hendler. “Semantic Web for Working Ontologists”, Morgan Kaufmann Publ., 2011. Google Scholar

  • [2]

    M. Horridge and P. F. Patel-Schneider. “OWL 2 web ontology language manchester syntax”. W3C Working Group Note, 2009. Google Scholar

  • [3]

    G.S. Plesniewicz and B.S. Karabekov. “Ontologies in the “Binary Model of Knowledge”, Programmnye produkty i sistemy (Software systems), 1 (105), 2014, 76-81. Google Scholar

  • [4]

    Protege Desktop User Documentation – http://protegewiki.stanford.edu/wiki/ProtegeDesktopUserDocs 

  • [5]

    S. Staab S, R. Studer (eds.) “Handbook on Ontologies”, Springer, 2003. Google Scholar

  • [6]

    C. Walter. “A mechanical solution of Schubert’s by many-sorted resolution”, Artificial Intelligence, 2 (26), 1985, 217-224. Google Scholar

About the article

Received: 2017-06-28

Accepted: 2017-11-10

Published Online: 2018-05-31


Citation Information: Open Engineering, Volume 8, Issue 1, Pages 132–139, ISSN (Online) 2391-5439, DOI: https://doi.org/10.1515/eng-2018-0017.

Export Citation

© 2018 Gerald Plesniewicz et al.. This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 License. BY-NC-ND 4.0

Comments (0)

Please log in or register to comment.
Log in