Ontology design is known to be a difficult task, requiring much more than expertise in an area; legal ontology design, due to the complexity of its domain, makes those difficulties worse. That may be partly due to poor requirement analysis in existing tools, but there is also an inherent gap between the purely logical constructs and methods that are expected to be used, and the actual competences and thought habits of domain experts. This paper presents some solutions, based on content ontology design patterns, which are intended to make life of legal ontology designers easier. An overview of the typical tasks and services for legal knowledge is presented, the notion of ontology design pattern is introduced, and some excerpts of a reference ontology (CLO) and its related patterns are included, showing their utility in a simple legal modeling case
A new breed of semantically-explicit applications is getting momentum
through the Semantic Web programme and beyond. Legal practice can
take advantage from them e.g. in the form of dynamically integrated
Semantic Web Services (SWS)
The core of semantically-explicit applications is constituted by socalled ontologies, which are strongly-typed logical theories that formalize the assumptions underlying various kinds of knowledge, including physical and social objects, as well as legal procedures, norms, roles, contracts, etc. Ontologies are usually expressed in first-order languages or fragments of them, although some typical modal and meta-level primitives are usually added to them, e.g. in description logics like OWL(DL) (McGuinness and van Harmelen (editors), 2004).
Ontologies can be designed by means of various methodologies (e.g.
The legal domain is very complex compared to others, because it
involves knowledge of the physical and social worlds, as well as typical
legal knowledge that actually creates a novel layer over the social world
Due to the autonomy (on one hand) and dependence (on the other hand) of the legal knowledge on both physical and social knowledge, legal reasoning tasks have evolved in a peculiar way, which include e.g. the norm structure based on CODePs like Requirement→Consequence (if the factual knowledge is P, then the legal knowledge is Q), Obligation→Right (if A has an obligation towards B, then B has a right towards A), Norm↔Case (if a situation fulfils a the conditions for violating a norm, it becomes a legal case), CrimeScenario (a crime is committed by a perpetrator and comes to the attention of authorities that pursue a criminal process), etc. The CODePs that are assumed by legal experts can be formalized by specializing or composing other existing patterns for the social world.
This work introduces some use cases for legal ontologies, as well as
some CODePs that can be specialized to support ontology-driven
solutions to those use cases. The CODePs have been defined on top of the
DOLCE foundational ontology library
In section 1. some ontology design/engineering use cases in the legal domain are introduced. In section 2. the CODeP idea is presented. In section 3. The Core Legal Ontology is briefly summarized and some more legal CODePs sketched with an example on a use case.
Within ICT, ontology design is dependent on (ontology) engineering
applications, which involve the statement of functionalities and their
implementation as techniques and tools. For a comprehensive
framework of ontology design, and its relations to content, related data,
formal languages, design patterns, social practices, organizations, teams,
and functionalities, see
Ontology engineering deals with designing, managing, and
exploiting ontologies (to be intended as strongly-typed logical theories) within
information systems. Ontologies are usually hybridated with other
components in order to build semantically-explicit applications; e.g., when
used jointly with:
− theorem provers, consistency checking can be performed to
logically validate the set of assumptions encoded in an ontology
− subsumption and instance classifiers against a logical language of
known and manageable complexity, like OWL (in the Lite and
DL species), automatic inferences can be derived from taxonomical
reasoning as well as for the classification of instances and facts
Ontology engineering techniques are exploited in the context of “generic use cases” defined for a domain of application. The main types of use cases that can be implemented or assisted by means of semanticallyexplicit applications in the legal domain (Fig. 1) are summarized in the following.
Definition: the task of getting consensus (or of discovering disagreement) about the intended meaning of a legal term, legal text unit, etc. Approach: the formal encoding of (part of) the intended meaning assumed by each of the parties involved in the task.
Issues: given the traditional practices of consensus reaching in Law, this task is usually considered intrusive, and could require a mindset shifting in order to acquire some relevance. Nonetheless, encoding intended meaning of a legal text is preliminary to all other tasks presented here. This observation seems paradoxical, since, if we cannot consider the formal encoding of legal meaning as an interpretation with legal validity, all the other tasks result to be based on an arbitrary (in the worst case) or a weak (in the best case) set of assumptions. Due to the current state of legal ontology, most tasks are carried out as if that formal encoding had legal validity, thus providing results that can be considered only as heuristical means for legal professionals or citizens.
Definition: the process of extracting concepts, relations, named entities, and complex knowledge patterns from a database, a document, or a corpus.
Approach: data- and text-mining, machine-learning, and NLP
algorithms that can extract linguistic objects from a corpus, and
semiautomated methods that match them to semantic objects.
Issues: this task is highly incremental, because the approaches need
a training phase or an extensive data entry procedure, so that the
extracted knowledge can be used to build a repository of patterns that
can be used to improve further extraction processes. Best results can
be achieved on very large corpora (for statistical reasons), or on
welldelimited, possibly semi-structured corpora and tasks; for example,
typical expressions that are found in legal drafting can be used to
formalize expectation patterns in corpora consisting of homogeneous
texts
Definition: the task aimed at verifying if a social situation (known in some way compliant with legal regulations) satisfies a legal description (norm, principle, regulation, etc.). In the generalized case, also situations already known to be legally relevant for some reason (e.g. a crime situation) can be checked for conformity against a further legal description (e.g. an appeal judgment procedure).
Approach: the representation of social or legal situations as well as of
legal regulations. Reasoners to cluster/classify/abstract situations.
Issues: Reasoning: the typical inferences supported by semantic web
engines for OWL (McGuinness and van Harmelen (editors), 2004) (e.g.
FaCT++ (Horrocks, )) currently include only concept subsumption and
instance classification. The expressivity is also limited so that e.g. fact
classification (also called materialization) is only performed by some
engines (e.g. Pellet (Sirin et al., 2007)). Moreover, compositions
between facts cannot be inferred unless an additional rule engine is added
(extensions for rule languages supporting fact composition are
provided by additional languages: SWRL(Horrocks et al., 2005), SPARQL
(Prud’hommeaux et al., 2005), F-Logic
Representation: a homogeneous language to represent both situations
and the constraints from a legal description is highly desirable,
otherwise a higher-order logic would be required to express constraints on
contraints on constraints etc. on situations. The proposal in
Definition: the investigation of the relations between legal cases and common sense situations.
Approach: subsumption/instantiation classification, or case-based reasoning.
Issues: in large scale applications, legal advice involves crucial problems such as causality and responsibility assessment, open-textured concepts, interpretation aspects, which are still being investigated from an ontological perspective. A typical scope for legal ontology design is to encode only weak constraints for terminological clarification. Legal advice requires more than that.
Definition: the matchmaking between different norms. Norm
comparison includes tasks such as: (i) normative conflict checking and handling
between norms about a same situation type, (ii) discovery of implicit
relations between a norm and other norms from a known corpus.
Approach: approximate classification algorithms (i-ii), including legal
text annotation and classification on large corpora (ii).
Issues: in Civil Law corpora, the task (ii) is sometimes relevant as much as in Common Law corpora, because of the stratification of laws that do not explicitly delete or even refer to previous ones (e.g. in Italy). In Common Law, implicit relations can be discovered more easily, because case abstraction has always a clear reference to a case, while in Civil Law, implicit relations appear at the purely normative level.
Definition: expression of norms’ content in different terms, which can be
either translations in a different natural language, or in a different form
within a same natural language, e.g. for the purpose of popularization.
Approach: translation between different languages requires a
preliminary mapping between terms, like the EuroWordNet-oriented work
performed in the LOIS project
Definition: a service assisting parties in the tasks of managing contract
agreement and definition, and of following contract execution.
Approach: the semantic specification of contract content, as well as
algorithms to manage the matching of parties’ constraints and preferences,
and a planning algorithm for the generation of optimal obligations that
parties could undertake
Approach: in the legal domain, these tasks require the semantic specification of services with reference to the legal knowledge involved in the execution of the service. Appropriate reasoners and planners are required.
Semantically-explicit applications in the legal domain present us with
conceptual analysis and integration problems that require appropriately
designed legal formal ontologies. Part of the design problems can be
simplified by creating or extracting “Conceptual Ontology Design Patterns”
(CODeP) for a domain of application
Mapping and composition of patterns require a reference ontology, in order to check the consistency of the composition, or to compare the sets of axioms that are to be mapped. Operations on CODePs depend on operations on the reference ontologies. However, for a pattern user, these operations should be (almost) invisible. − A CODeP can be represented in an ontology representation language whatsoever (depending on its reference ontology), but its intuitive and compact visualization is an essential requirement. It requires a critical size, so that its diagrammatical visulization is aesthetically acceptable and easily memorizable. For example, the N orm ↔ Case CODeP only includes eight classes, with several, systematic relations between them: this makes it dense, but manageable. − A CODeP can be an element in a partial order, where the ordering relation requires that at least one of the classes or relations in the pattern is specialized. A hierarchy of CODePs can be built by specializing or generalizing some of the elements (either classes or relations). For example, the participation pattern (of an object in an event) can be specialized to the taking part in a public enterprise pattern (of an agent in a social activity with public relevance). − A CODeP should be intuitively exemplified, and should catch relevant, “core” notions of a domain. Independently of the generality at which a CODeP is singled out, it must contain the central notions and best practices that “make rational thinking move” for an expert in a given domain for a given task.
A CODeP can be often built from informal or simplified schemata
used by domain experts, together with the support of other reusable
CODePs or reference ontologies, and a methodology for domain
ontology analysis. Typically, experts spontaneously develop schemata
to improve their business, and to store relevant know-how. These
schemata can be reengineered with appropriate methods (e.g.
A CODeP can be similar to a database schema, but a pattern is
defined wrt to a reference ontology, and has a general character,
independently of system design. In this sense, it is closer to so-called
data modelling patterns
Conceptual Ontology Design Patterns (CODePs) are a resource and design method for engineering ontology content over the Semantic Web.
A template (Fig. 2, also available in OWL from (CODeP, )) can be used to annotate CODePs as sub-theories of reference ontologies, in order to share them in pre-formatted documents, as well as to describe, visualize, and make operations over them them appropriately.
The CODeP template consists of: − Two slots for the generic use case, and the local use cases, which includes a description of context, problem, and constraints/requirements. − Two slots for the addressed logic, and the reference ontologies used as a background for the pattern. − Two slots for -if any- the specialized pattern and the composed patterns (by inheritance, and inverse inheritance, it’s possible to obtain the closure of specialized and expanding patterns). − Two slots for the maximal relation that encodes the case space, and its intended axiomatization: a full first-order logic with meta-level is assumed here, but the slot can be empty without affecting the functionality of a CODeP frame. − Two slots for explanation of the approach, and its encoding in the logic of choice. −
A last slot for a class diagram that visually reproduces the approach.
The template can be easily encoded in XSD or in richer frameworks,
like semantic web services
CODePs can also be used to generate intuitive, friendly UIs, which can present the user with only the relevant pattern diagram, avoiding the awkward, entangled graphs currently visualized for medium-to-large ontologies.
The advantages of CODePs for ontology lifecycle over the Semantic Web are straightforward: firstly, patterns make ontology design easier for both knowledge engineers and domain experts (imagine having a menu of pre-built, formally consistent components, pro-actively suggested to the modeller); secondly, patterned design makes it easier ontology mapping - perhaps the most difficult problem in ontology engineering. For example, the time-indexed participation presented in this paper requires non-trivial knowledge engineering ability to be optimally represented and adapted to a use case: a CODeP within an appropriate ontology management tool can greatly facilitate such representation.
The CODeP examples and the related frame and methods introduced
in this paper have been applied for two years (some of them even before)
in several administration, business and industrial projects, e.g. in fishery
information systems
Current work focuses on building a tool that assists development,
discussion, retrieval, and interchange of CODePs over the Semantic
Web, and towards establishing the model-theoretical and operational
foundations of CODeP manipulation and reasoning. In particular, for
CODePs to be a real advantage in ontology lifecycle, the following
functionalities should be available:
− Categorization of CODePs, based either on the use cases they
support, or on the concepts they encode.
− Pattern-matching algorithms for retrieving the CODeP that best
fits a set of requirements, e.g. from a natural language specification,
or from a draft ontology.
− Support for specialization and composition of CODePs. A CODeP
p2 specializes another p1 when at least one of the classes or
properties from p2 is a sub-class or a sub-property of some class resp.
property from p1, while the remainder of the CODeP is identical.
A CODeP p2 expands p1 when p2 contains p1, while adding some
other class, property, or axiom. A CODeP p3 composes p1 and p2
when p3 contains both p1 and p2. The formal semantics of these
operations is ensured by the underlying (reference) ontology for the
patterns. Notice that CODePs –differently from “knowledge
patterns” in
A rich set of metadata for CODeP manipulation and exploitation within applications.
The need for an extended typology of legal entities is becoming a
pressure, even from traditionally “bottom-up” approaches. For example, the
need to pair case-based reasoning with an ontology of first-principles
should be investigated in order to represent the two kinds of
structures employed in reasoning: abstraction from cases, and satisfaction of
constraint sets (e.g. norms)
The level of granularity is also a core issue in developing formal
ontologies, specially because a decentralized architecture is emerging
for ontologies as well: how to compare/integrate/transform two
ontologies about a close domain, but with a different detail encoded in their
vocabulary and axioms?
The Core Legal Ontology (CLO)
The two pillars of CLO as a plugin to DOLCE+ are: stratification and reification.
Based on the stratification principle, CLO provides types and
relation for the heterogeneous entities from the legal domain, be it about
the physical, cognitive, social, or properly legal worlds (cf.
In DOLCE, the solution includes a very general pattern, expressed
as a disjointness axiom between the class of physical vs. social
objects, whereas legally-relevant entities are mostly in the social realm
(see Fig.s 5,6,7,8,9, which also include some use of CLO for the
JurWordNet lexical ontology
Based on the reification principle, CLO enables an ontology engineer
to quantify either on legal rules or relations (type reification)
A reification-based pattern models the structure of an intensional
specification, called Description in
In order to describe some of the ontological expressiveness of CLO, a complex CODeP is introduce here which has CLO as its reference ontology. This is is the N orm ↔ Case CODeP (Fig. 4): it is used as a pattern for representing legal cases, is specialized for types of norms and cases, e.g. for crime investigation, and is composed with other patterns, e.g. for norm conflict checking.
In the following template (Tab. I, see Fig. 2 for its datamodel), the Limit ↔ V iolationCase CODeP is compactly introduced as a specialization of the generic N orm ↔ Case CODeP:
Logic addressed
OWL, DL species Specialized CODeP Composed CODePs Formal relation Sensitive axioms Explanation OWL(DL) encoding (abstract syntax) Class diagram
Value use
Legal situations to be checked for (non)conformity to existing norms that establish limits.
Legally-defined roles, functions, and parametric values exist to control the social life of a country. When talking about agents and social action, there is a network of senses implying a dependence on roles, functions (or tasks), and parametrized value ranges within a normative description. Intended meanings include the possible roles played by certain objects and agents, the actual actions occurring during social life, as well as parametric limits over value types, such as age limits, speed limits, etc. Therefore, both class- and instance-variables are present in the maximal relation for this pattern.
DOLCE-Lite-Plus, Core Legal Ontology Norm ↔ Case Time-Indexed-Participation, Concept↔Description, Description↔Situation CaseConformsToLimitViolation(ϕ,ψ,χ,x,y,z,t,c1,c2,c3,d,s), where φ(x) is an agent class, ψ(y) is a process class, χ(z) is a class of values within a value range, t is a time interval, c1, c2 and c3 are three reified intensional concepts, d is a reified intensional relation, and s is a reified extensional relation.
CaseConformsToLimitViolation(s,d) =df ∀x, y, z(ϕ(x) ∧ ψ(y) ∧ χ(z)∧ participantIn(x,y,t) ∧ locationOf(z,y,t) ∧ (Object(x) ∨ Agent(x)) ∧ Action(y) ∧ Speed(z) ∧ TimeInterval(t)) ↔ ∃c1,c2,c3(CF(x,c1,t) ∧ MT(c1,c2) ∧ CF(y,c2,t) ∧ ¬CF(z,c3,t) ∧ REQ(c3,c2) ∧ (DF(d,c1) ∧ DF(d,c2) ∧ DF(d,c3) ∧ ∀s(SAT(s,d) ↔ (SETF(s,x)∧ SETF(s,y) ∧ SETF(s,t))) Since OWL(DL) does not support relations with >2 arity, reification is required. The Description↔Situation pattern provides typing for such reification. Since OWL(DL) does not support classes in variable position, we need reification for class-variables. The Concept Description pattern provides typing for such reification. Similarly, since participation is time-indexed, we need the time-indexed-participation pattern, which is here merged with the previous two patterns (time indexing appears in the setting of the general normative situation).
An overview of the relevance of ontology patterns for legal knowledge engineering (LKE) has been presented.
For some generic LKE use cases (conflict checking, information extraction, etc.), some solutions and issues, both on the reasoning and (content) modelling sides, have been mentioned. While the reasoning side of LKE is a fast-moving target, with interesting solutions coming from e.g. hybridating different inference engines and classifiers, the modelling side is far less developed, despite the huge literature that focuses on legal and jurisprudential content, let alone the work in formal ontology and beyond. This is not surprising. Currently, very few ontologies are actually reused, against the great expectations that have been grown in the field of reusability of semantic components.
In the past, the need for structures that grant systematicity to content modelling have mainly focused on so-called top-level ontologies, but the power of a small set of categories is not enough for realistic ontology projects like those presented to LKE. A top-level can even be a problem when its categories are brittle with respect to the domain task.
A more sophisticated approach, which ensures a much higher level of cognitive interoperability, is constituted by foundational ontologies like DOLCE. Nonetheless, although their rich axiomatization makes foundational ontologies ideally suited for building a partial-order of reference ontologies, they require a substantial cognitive load to be accessed and then successfully reused.
A new dimension of reusability has been introduced in ontology engineering (and here extended to LKE) which revisits some good practices from AI (knowledge patterns) and databases (data model patterns), by providing a meta-model, some operations, and a generalized characterization to conceptual ontology design patterns (CODePs). A foundation to CODePs is supposed to enhance the construction of tools for ontology design, as e.g. envisaged in the NeOn project (NeOn, ), and to facilitate the collaborative and distributed negotiation of meaning across the members of a same or of sufficiently close communities.
For LKE, CODePs appear slightly more complex than in other domains, mostly because the use cases in LKE involve a layering of meaning (from the physical to the social, cognitive, and finally legal realms), which also require an extended reification of entities such as norms, contracts, cases, legal text corpora, etc. A complex network of dependencies between roles and tasks, agents, normative positions, validity parameters, assumed goals, cognitive attitudes, etc. makes the modelling task in LKE harder than elsewhere. A few steps toward the creation of a repository of legal CODePs have been sketched, together with some possible directions for further development.