\documentclass{svmult}

\usepackage{makeidx}         % allows index generation
\usepackage{graphicx}        % standard LaTeX graphics tool
\usepackage{multicol}        % used for the two-column index
\usepackage[bottom]{footmisc}% places footnotes at page bottom
\usepackage{amssymb}

\makeindex             % used for the subject index
                       % please use the style sprmidx.sty with
                       % your makeindex program

\renewcommand{\abstractname}{Abstract.}

\newcommand{\DL}{\mbox{$\mathcal{SHOINK}(\mathbf{D})$}}
\newcommand*{\Subtran}{%
   \mathrel{%
     \rlap{\raisebox{1.5pt}{\small\ensuremath{\,\ast}}}%
          {\ensuremath{\mathop{\sqsubseteq}}}%
   }%
}

\begin{document}

\title*{Modeling ORM Schemas in Description Logics}
% Use \titlerunning{Short Title} for an abbreviated version of
% your contribution title if the original one is too long
\author{Thi Dieu Thu NGUYEN\thanks{Tel: +33 (0)492942743; Fax: +33 (0)492942898; Email:
\texttt{tnguyen@i3s.unice.fr}}\and Nhan LE THANH and TA Le PHAM}
% Use \authorrunning{Short Title} for an abbreviated version of
% your contribution title if the original one is too long
\institute{I3S laboratory (CNRS - UNSA), Les Algorithmes - Euclide B Building,
2000 Route des Lucioles -- B.P. 121, F-06903 Sophia Antipolis Cedex, France.}
%
% Use the package "url.sty" to avoid
% problems with special characters
% used in your e-mail or web address

\maketitle \vspace{-1cm}
%\thanks{This work is completed thanks to the scholarship of Vietnamese Government.}
\begin{abstract}
In recent years, there has been a growing interest in integration of
semantics into the Semantic Web environment, whose goal is to
access, relate and combine information from multiple sources. With
regard to this tendency, our work studies a mechanism to model ORM
schemas in the Description Logic language $\DL$, the underpinning of
a Web ontology language. This mechanism meets the key feature
required by ORM schemas (i.e. identification and functional
dependency constraints). It can be applied to integrate information
not only from systems described in ORM schemas but also from
relational databases into the Semantic Web environment.

\keywords{Information integration, object role modeling (ORM),
description logics (DLs), web ontology language, semantic web.}
\end{abstract}

\section{Introduction}

In recent years, the problem of interoperability and semantic
integration of heterogeneous information sources in the Semantic Web
environment has triggered various research
\cite{Use_Onto_in_SW_Survey, kalfoglou-2005, Natalya1041421}.
Besides the universal environment of the WWW (World Wide Web), this
is thanks to the expressivity of Web ontology languages that deals
with the problem of heterogeneity of sources and to their
well-formalized annotations which can be used in automated reasoning
\cite{citeulike:956280}. These features are provided by underlying
description logic (DL) languages, a family of knowledge
representation formalisms based on First-Order Logic (FOL)
\cite{FOL95}, e.g. $\mathcal{SHOIN}(\mathbf{D})$ \cite{IanSHOQ,
IanSHOIQ}.

One of the most popular information modeling approaches nowadays is
ORM (Object Role Modeling) \cite{HalpThesis, halpin-objectrole}. It
facilitates modeling, transforming, and querying information using
\emph{facts} and \emph{constraints}, which may be verbalized in a
close-to-natural language. This increases the ease of use, specially
toward non-technical users. Unlike Entity-Relationship (ER) modeling
\cite{ER555645} and Unified Modeling Language (UML) \cite{UMLbook},
ORM is attribute-free. The latter avoids the problems caused by
instability in ER and UML as clearly shown in \cite{businessRule}.
Moreover, for information modeling, ORM graphical notations are far
more expressive than those of ER and UML. It provides procedures for
mapping to other database schemas (e.g. ER, UML). ORM has been fully
formalized in FOL \cite{HalpThesis}, so that its semantics is very
close to that of DLs.

Hence, with the aim of integrating information systems into the Web
Semantics, we introduce a formalization of ORM schemas in terms of a
DL. In particular, we show how ORM schema semantics can be captured
in Web Semantics thanks to the expressivity of the DL $\DL$
\cite{RcisSHOINKD, rapportSHOINK}, which in its turn is the
underpinning of a Web ontology language \cite{rapportOWLK}.

Several formalizations of ORM schemas have been proposed in the
literature \cite{JarrFranORMDLR, DBLP:conf/ekaw/SpynsAWJL04}. They
have been proved very useful with respect to establishing a common
understanding of the formal meaning of ORM schemas. However, to the
best of our knowledge, none of them has the explicit goal of
building a framework to integrate information into the Semantic Web
environment.

The rest of the paper is organized as follows. Section 2 briefly introduces the
$\DL$ language. In section 3, we show how ORM schemas can be formalized in this
DL. Section 4 will conclude the paper with some future perspectives.

\section{Description Logic $\DL$}

\subsection{Concrete Datatypes}

Concrete datatypes are used to represent literal values such as
numbers or strings. They compose a \emph{concrete domain}
$\mathbf{D}$, as introduced for $\mathcal{SHOQ}(\mathbf{D})$
\cite{IanSHOQ}. Each datatype $d \in \mathbf{D}$ is associated with
a set $d^\mathbf{D} \subseteq \Delta_{\mathbf{D}}$, where
$\Delta_{\mathbf{D}}$ is the domain of interpretation of all
datatypes. For example, a datatype $\geq_{21}$ in $\mathbf{D}$
defines a set ${\geq_{21}}^{\mathbf{D}}$ of \emph{integer} values
greater than or equal to 21.

\subsection{$\mathcal{SHOINK}(\mathbf{D})$ Syntax and Semantics}

$\DL$, presented in \cite{RcisSHOINKD, rapportSHOINK}, is an
extension of $\mathcal{SHOIN}(\mathbf{D})$ with a decidable
inference by adding identification constraints (ICs), which are
one-to-one relations between an identifying and the identified part.

As a DL language, the basic syntactic building blocks of $\DL$ are
atomic \emph{concepts}, atomic \emph{roles}, and individuals
(constants). Concepts are interpreted as sets of individuals
(subsets of the interpretation domain) and roles as sets of pairs of
individuals. Expressions are then built from these basics by using
several kinds of constructors. For example, the \emph{conjunction}
$C \sqcap D$ denotes the set of individuals obtained by intersecting
the sets of individuals of $C$ and $D$. In FOL, this expression can
be described as $C(x) \wedge D(x)$, where the variable ranges over
all individuals in the interpretation domain and $C(x) \wedge D(x)$
is true for those belonging to the concept $C$ and $D$.

Syntax and Semantics of $\DL$ can be seen in table
\ref{tab:SyntaxSemantic}, where $C, D$ are concept descriptions; $o$
is nominal, i.e. singleton concept; $R, R_1, ... ,R_n$, $S$ are
roles; $\textbf{R}_{+}$ is the set of transitive roles; $\sharp$
denotes cardinality; $\mathcal{I}$ is the interpretation function;
$\Delta^{\mathcal{I}}$ is the interpretation domain disjoint from
$\Delta_{\mathbf{D}}$, the concrete interpretation domain. Further
details of $\DL$ can be found in \cite{RcisSHOINKD, rapportSHOINK}.

\vspace{-0.4cm}
\begin{table*}
\caption{\label{tab:SyntaxSemantic} $\mathcal{SHOINK}(\mathbf{D})$ Syntax and
Semantics}
\begin{center}
\begin{tabular}{p{3.7cm}p{2.3cm}p{5.4cm}}
  \hline
  \textbf{Construct name} & \textbf{Syntax} & \textbf{Semantics}\\
  \hline
  atomic abstract role & $R$ & $R^{\mathcal{I}} \subseteq \Delta^{\mathcal{I}} \times \Delta^{\mathcal{I}}$ \\

  concrete role & $U$ & $U^{\mathcal{I}} \subseteq \Delta^{\mathcal{I}} \times \Delta^{\mathcal{I}}_{\mathbf{D}}$ \\

  transitive role & $R \in {\textbf{R}}_+$ & $R^{\mathcal{I}} = {R^{\mathcal{I}}}^+$ \\

  inverse abstract role & $R^-$ & $\{\langle x,y \rangle | \langle y,x \rangle \in
  R^{\mathcal{I}}\}$ \\

  role hierarchy & $R \sqsubseteq S$ & $R^{\mathcal{I}} \subseteq S^{\mathcal{I}}$ \\

  \hline
  atomic concept & $A$ & $A^{\mathcal{I}} \subseteq \Delta^{\mathcal{I}}$ \\
%% concept universel & $\top$ & $\top^{\mathcal{I}} = \Delta^{\mathcal{I}}$ \\
%% concept vide & $\bot$ & $\emptyset$ \\
    datatype & $d$ & $d_{\mathbf{D}} \subseteq \Delta^{\mathcal{I}}_{\mathbf{D}}$ \\

    concrete value & $v$ & $v^{\mathcal{I}} = v^{\mathbf{D}}$ \\

  negation  & $\neg C$ & $\Delta^{\mathcal{I}}\backslash C^{\mathcal{I}}$ \\
  conjunction & $C \sqcap D$ & $C^{\mathcal{I}} \cap D^{\mathcal{I}}$ \\
  disjunction & $C \sqcup D$ & $C^{\mathcal{I}} \cup D^{\mathcal{I}}$ \\
  exists restriction & $\exists R.C$ & $\{x \in \Delta^{\mathcal{I}}| \exists y.\langle x,y \rangle \in R^{\mathcal{I}} \wedge y \in
  C^{\mathcal{I}}\}$ \\
  value restriction & $\forall R.C$ & $\{x \in \Delta^{\mathcal{I}} | \forall y.\langle x,y \rangle \in
  R^{\mathcal{I}} \rightarrow y \in C^{\mathcal{I}}
  \}$ \\

  concrete exists restriction & $\exists R.d$ & $\{x \in \Delta^{\mathcal{I}}| \exists y.\langle x,y \rangle \in R^{\mathcal{I}} \wedge y \in
  d^{\mathbf{D}}\}$ \\
  concrete value restriction & $\forall R.d$ & $\{x \in \Delta^{\mathcal{I}} | \forall y.\langle x,y \rangle \in
  R^{\mathcal{I}} \rightarrow y \in d^{\mathbf{D}}
  \}$ \\
  atleast restriction & $\geq nR$ & $\{x \in \Delta^{\mathcal{I}} | \sharp \{y.\langle x,y \rangle \in R^{\mathcal{I}}
\} \geq n
  \}$ \\
  atmost restriction & $\leq nR$ & $\{x \in \Delta^{\mathcal{I}} | \sharp \{y.\langle x,y \rangle \in R^{\mathcal{I}}
\} \leq
  n \}$ \\

  nominal & $o$ & $\sharp \{o^{\mathcal{I}} \} = 1$ \\

 subsumption & $C \sqsubseteq D $ & $C^{\mathcal{I}} \subseteq D^{\mathcal{I}}$ \\
  \hline

  identification constraint & ($R_1, ..., R_n$ $\qquad \qquad \qquad \mathbf{Idfor} \, C$) & $\mathcal{I} \models (R_1, ...,
R_n \, \mathbf{Idfor} \, C$) iff $\forall s,s' \in C^\mathcal{I}$ and $\langle
s,t_i \rangle, \langle s', t'_i \rangle \in R^{\mathcal{I}}_i \, \forall 1 \leq
i
\leq n$, $t_i=t'_i \, \forall 1 \leq i \leq n$ then $s=s'$ \\
  \hline
\end{tabular}
\end{center}
\end{table*}
\vspace{-0.3cm} As shown in table \ref{tab:SyntaxSemantic}, $\DL$
concept descriptions can be specified as logical combinations
(conjunction, disjunction, or negation) of others, as nominals or as
restrictions on a particular role so that all the values filling the
role have to belong to a certain concept (or datatype); or at least
one value must come from a certain concept (or datatype); or there
is at least or at most a certain number of distinct values. Concept
descriptions and roles can also be organized in a subsumption
(subclass) hierarchy. $\DL$ can also state whether a role is
transitive, or the inverse of another.

\section{Modeling ORM in $\DL$}
Example \ref{ex:ORMschema} is an illustration of modeling ORM
schemas in $\DL$. We use the ORM formalization and syntax as found
in \cite{HalpThesis, halpin-objectrole, ORM2notation}, but, limiting
it to binary predicates\footnote{It has been proved that n-ary
predicates can be transformed to binary ones \cite{Win90}}. In this
work, we consider the critical constraints that are indispensable in
designing ORM schemas and we do not support nested-fact types and
derivation constraints (the latter are not part of the ORM graphical
notation).
\begin{example}\label{ex:ORMschema}
Fig. \ref{fig:exORMschema} describes in ORM graphical notation
\cite{ORM2notation} the information of the students who attended an
International meeting of the best students in the world. Each
country, coded by \textsf{CountryId}, had only one student per
subject (which is coded by \textsf{SubjectId}) who was elected to
represent his/her country in this discipline. For social events,
each student could attend many groups, each of which has only one
topic. Different groups can share the same topic, but the student
can only attend groups having different topics. These descriptions
can be expressed in $\DL$ as shown in Table \ref{tab:ORMDLmapping}.
\end{example}
\vspace{-0.3cm}
\begin{figure}[!htp]
\centering
\includegraphics[height=2.8cm]{ExORMSchema.eps}
\caption{ORM schema example} \label{fig:exORMschema}
\end{figure}
\vspace{-0.1cm}

The principle components of ORM are object types, which include
entities (e.g. \textsf{Student}, \textsf{Country}) and values (e.g.
\textsf{Topic}, \textsf{CountryId}), and roles (e.g.
\textsf{contain}, \textsf{represent}). Object types are connected by
the roles they play, composing the fact types. Two roles in a fact
type make up its binary predicate. Constraints are applied to roles
to create the population of a database and restrict the data
permitted in it. We here focus on the representation of the
mandatory ($\bullet$), internal uniqueness (---) and external
uniqueness ($\circleddash$) constraints. We briefly explain the
formalization shown in Table \ref{tab:ORMDLmapping}, where $C_1,
C_2, ..., C_n$ are entity names; $R_1, R_2, ..., R_n$ are role
names; ($C R_{i}/R_{inv(i)} C_i$) are fact types, $R_{inv(i)}$ is
the inverse of $R_{i}$, $C$ is an entity name and $1 \leq i \leq n$;
C(Id) is the reference scheme of $C$; $R_{id}$ is a role name used
to translate a reference scheme; $C_{fd}$ and $R_{fd}$ are
respectively an entity and a role name used to translate a
functional dependency.

The basic process is to go through a given schema, just as an
automated system would do, looking for the following descriptions in
the schema:
\begin{enumerate}
    \item Object types (entities and values)
    \item Reference schemes
    \item Roles
    \item Constraints
    \begin{enumerate}
        \item Identification constraints on one role
        \item Identification constraints on many roles
        \item Functional dependencies on many roles
        \item Other constraints
    \end{enumerate}
\end{enumerate}
It is obvious that this mapping is polynomial w.r.t the number of
elements in the schema.

\subsection{Mapping Fact Types}

Since constraints are applied to fact types, first of all, object types and
roles must be formalized.

Values are object types that cannot be defined by others. They are either
strings or numbers, which exactly correspond to datatypes in $\DL$. Entities
can be defined by other entities and/or values. When defined by values, they
can be seen as atomic concepts in $\DL$. Otherwise, constraints must be used to
describe them (see section \ref{sec:constraint}).

A role can attribute a value to an entity (attributive role, e.g.
\textsf{hasTopic}) or connect one entity to another (e.g.
\textsf{represent}). The former corresponds to a concrete role while
the latter corresponds to an abstract role in $\DL$. In any case,
the instances assisting a given fact compose a set subsumed by their
entity. So that we can model the context of the role they play as an
axiom where the set generated by \emph{atleast} restriction by 1 on
the role is subsumed by the entity playing the role (e.g. $\geq 1
\textsf{hasTopic} \sqsubseteq \textsf{Group}$). Besides, whenever
the entity plays its role, the object it plays with is defined by
the role. So we can formalize this expression by an axiom specifying
that the \emph{value} restriction on the role subsumes the universe
(e.g. $\top \sqsubseteq \forall \textsf{hasTopic.Topic}$). In binary
predicates, one role needs to be the inverse of the other. Hence,
for a given fact type, two predefined non-attributive roles are
mapped as the inverse of each other (e.g. \textsf{attend} $\equiv
\textsf{contain}^-$).

%\vspace{-0.3cm}
\begin{table}
 \centering \caption{Modeling ORM schemas in $\DL$}\label{tab:ORMDLmapping}
\begin{tabular}{lll} %l}
\hline%\noalign{\smallskip}
  \textbf{ORM} & \textbf{$\DL$ }& \textbf{Example} \\ %& Same elements applied in Example \ref{ex:ORMschema} \\%& OWL-K abstract syntax \\
\noalign{\smallskip}\hline\noalign{\smallskip}
  Value \textsf{C}$_{i}$  & Datatype $C_i$ & \textsf{Topic} \\%& \textsf{CountryId}, \textsf{SubjectId}\\

  Entity \textsf{C}$_{i}$ & Concept $C_i$  & \textsf{Group} \\%& \textsf{Student}, \textsf{Country}, \textsf{Subject}\\

  Role \textsf{R}$_i$ & $\geq 1 \textsf{$R_i$} \sqsubseteq \textsf{$C$}$ & $\geq 1 \textsf{contain} \sqsubseteq \textsf{Group}$ \\%& \textsf{represent}, \\
   &$\top \sqsubseteq \forall \textsf{$R_i.C_i$}$ & $\top \sqsubseteq \forall
   \textsf{contain.Student}$ \\%& \textsf{hasTopic}, \textsf{bestAt} \\

  Inverse role \textsf{$R_{inv(i)}$} & \textsf{$R_{inv(i)} \equiv {R_i}^-$} & \textsf{attend} $\equiv \textsf{contain}^-$ \\%&\\
\hline
  MC on \textsf{R}$_i$ & \textsf{$C \sqsubseteq \exists \, R_i.C_i$} & \textsf{Student} $\sqsubseteq$ \, $\exists$
   \textsf{bestAt}.\textsf{Subject} \\%& \textsf{hasTopic}, \textsf{represent} \\

 IUC on \textsf{R}$_i$ & \textsf{C $\sqsubseteq$ $\leq 1$ R$_i$} & \textsf{Group $\sqsubseteq$ \, $\leq 1$ hasTopic} \\%& \textsf{represent}, \textsf{bestAt}\\

\hline

Reference scheme  & $\geq 1$ \textsf{R}$_{id} \sqsubseteq$ \textsf{C} & $\geq 1
\textsf{idForCountry} \sqsubseteq
   \textsf{Country}$ \\%& \textsf{Subject(SubjectId)}\\
\textsf{C(Id)}                  &$\top \sqsubseteq \forall$
                                \textsf{R}$_{id}$.\textsf{Id} & $\top \sqsubseteq \forall
                                \textsf{idForCountry.CountryId}$ \\%&\\
(simple IC)                    & \textsf{(R}$_{id}$ \textbf{Idfor} C) &
\textsf{(idForCountry \textbf{Idfor}
                                Country)} \\%& \\

\hline
EUC on (\textsf{R}$_{1}{^{-}}$,..., \textsf{R}$_{n}{^{-}}$) &
(\textsf{R}$_{1}$,..., \textsf{R}$_{n}$ \textbf{Idfor} \textsf{C}) &
($\textsf{represent}, \textsf{bestAt} \, \textbf{Idfor} \,
\textsf{Student}$) \\%&\\
(IC for \textsf{C}) & & \\%&\\

\hline
EUC on & $\geq 1 \textsf{$R_{fd}$} \sqsubseteq \textsf{$C_{fd}$}$ &
$\geq 1
\textsf{specGroup} \sqsubseteq \textsf{StudentTopic}$ \\%& \\

(\textsf{R}$_1{^{-}}$, \textsf{R}$_2{^{-}}$, ..., \textsf{R}$_n{^{-}}$) & $\top
\sqsubseteq \forall \textsf{$R_{fd}$.C}$ & $\top
\sqsubseteq \forall \textsf{specGroup.Group}$ \\%&\\

(FD for \textsf{C})& \textsf{$C_{fd}$ $\sqsubseteq$ $\leq 1 R_{fd}$} &
\textsf{StudentTopic
$\sqsubseteq$ \, $\leq 1$ specGroup} \\%& \\

& (\textsf{R}$_{1}$,...,\textsf{R}$_{n}$ \textbf{Idfor} \textsf{C}$_{fd}$) &
($\textsf{contain}, \textsf{hasTopic} \, \textbf{Idfor} \,
\textsf{StudentTopic}$) \\%& \\

\noalign{\smallskip}\hline
\end{tabular}
\end{table}
%\vspace{-0.1cm}

\subsection{Mapping Constraints} \label{sec:constraint}

\emph{A mandatory constraint (MC)} on a role specifies that all
instances of an object type must play the role. For example, it is
applied on the role \textsf{represent} in Example \ref{ex:ORMschema}
to show that every student must represent some country. This
constraint is equally expressed by the existence restriction in
$\DL$.

\emph{Uniqueness constraints (UCs)} are used to express that each
instance of an object type plays a set of roles at most once. These
constraints make think of \emph{atmost} restrictions in $\DL$.
However, \emph{atmost} restrictions are applied to a single role
only. UCs in this case (e.g. on \textsf{represent}, \textsf{bestAt})
can thus be described by \emph{atmost} restrictions by 1.

In case UCs are applied to a set of two roles of the same predicate (e.g.
\textsf{contains/attend}), the two objects are in a n-n relationship (in
Example \ref{ex:ORMschema}, the objects are \textsf{Group} and
\textsf{Student}). Implicitly, a binary relation is n-n without condition. So
that there is no need to make a translation for this case. \vspace{-0.1cm}
\begin{figure}[!htp]
\centering
\includegraphics[height=0.9cm]{exScheme.eps} % \label{fig:SchemeCountry}
\caption{Description of the reference scheme \textsf{Country(CountryId)}}
\label{fig:SchemeCountry}
\end{figure}
%\vspace{-0.2cm}

In Fig. \ref{fig:exORMschema}, we also see entities as so called
\emph{reference schemes}, e.g. \textsf{Country(CountryId)}. The
latter specifies that \textsf{CountryId} identifies uniquely
\textsf{Country}. Essentially, reference schemes can be explained by
adding an attributive role, imposing an MC and two UCs on both the
two roles in the predicate (see Fig. \ref{fig:SchemeCountry}).
However, the inverse of an attributive role cannot be represented in
$\DL$ (see Table \ref{tab:SyntaxSemantic}). Nevertheless, ICs in
$\mathcal{SHOINK}(\mathbf{D})$ allow us to represent this ORM
formalization, e.g. (\textsf{idForCountry} \textbf{IdFor}
\textsf{Country}).

This combination of constraints can also be described explicitly in ORM schemas
as ICs. In such cases, the same mapping mechanism is applied.

The UCs discussed above are applied to roles in a single predicate.
They are called \emph{internal uniqueness constraints} (IUCs). In
case applied to the roles in different predicates, these
constraints, the so-called \emph{external uniqueness constraints}
(EUCs), are used to express unique identification and functional
dependency (FD) relationships:

\begin{itemize}

\item \emph{Using EUCs to describe unique identifications.} In Example \ref{ex:ORMschema},
the EUC on the two inverse roles of \textsf{represent} and
\textsf{bestAt}, combined with the IUCs and the MCs on the two
latter roles, describe that students are uniquely identified by
their country and their subject at which they were the best. Hence,
the combination of these constraints can be interpreted as an IC in
$\mathcal{SHOINK}(\mathbf{D})$, i.e., ($\textsf{represent},
\textsf{bestAt} \, \textbf{Idfor} \, \textsf{Student}$).

\item \emph{Using EUCs to describe FDs}. Except the case described
above, the application of EUCs results in FDs. For example, the EUC
on \textsf{attend} and the inverse of \textsf{hasTopic} specifies
that \textsf{Group} is functionally dependent on the couple
(\textsf{Student},\textsf{Topic}). Note that in $\DL$, constructors,
except for ICs, are applied to one role only. In that way, it is not
capable of expressing FDs nor ICs on many roles \cite{650667}.
However, observe that an FD of an object A on two objects B and C
can be described as an FD of A to an object A', which is uniquely
identified by the couple (B,C). Hence, we make use of this idea to
formalize this kind of EUCs. For example, modeling the given EUC on
\textsf{attend} and the inverse of \textsf{hasTopic}, we create an
entity \textsf{StudentTopic} which is uniquely identified by the
couple (\textsf{Student},\textsf{Topic}). A new role,
\textsf{specGroup}, is created to set the functional dependency of
\textsf{Group} on \textsf{StudentTopic}. The two ORM schemas in Fig.
\ref{fig:exEquivschema} are equivalent.
\end{itemize}
\vspace{-0.3cm}
\begin{figure}[!htp]
\centering
\includegraphics[height=4cm]{exEquivschema.eps}
\caption{Equivelent schemas for an FD in Example \ref{ex:ORMschema}}
\label{fig:exEquivschema}
\end{figure}
\vspace{-0.9cm}

\section{Conclusion and Perspectives}

We have proposed a new formalization of ORM schemas in the DL $\DL$,
which meets the key feature required by the schemas (i.e.,
identification and functional dependency constraints). Exploiting
such a formalization, one can integrate information into the
Semantic Web environment from systems described in ORM schemas as
well from relational databases. Furthermore, the DL used here is
decidable \cite{RcisSHOINKD, rapportOWLK}. So this formalization
allows for automated reasoning on ORM schemas as well (e.g.,
detecting constraint conflicts or implications).

Our future work will include the mapping of other types and
constraints in ORM to $\DL$ and the implementation of the
formalization. With the perspective to construct a methodology of
integration of information sources into the Semantic Web
environment, our next phase will be the automated translation of
requests from a DL to SQL by using this formalization.

\bibliographystyle{plain}
\bibliography{paper}

\end{document}
