- One of the central concerns of the multi-level modelling (MLM) community is the hierarchy of classifications that appear in conceptual models; what these are, how they are linked and how they should be organised into levels and modelled. Though there has been significant work done in this area, we believe that it could be enhanced by introducing a systematic way to investigate the ontological nature and requirements that underlie the frameworks and tools proposed by the community to support MLM (such as Orthogonal Classification Architecture and Melanee). In this paper, we introduce a key component for the investigation and understanding of the ontological requirements, an ontological sandbox. This is a conceptual framework for investigating and comparing multiple variations of possible ontologies - without having to commit to any of them - isolated from a full commitment to any foundational ontology. We discuss the sandbox framework as well as walking through an example of how it can be used to investigate a simple ontology. The example, despite its simplicity, illustrates how the constructional approach can help to expose and explain the metaphysical structures used in ontologies, and so reveal the underlying nature of MLM levelling.
One of the central concerns of the multi-level modelling (MLM) community is the hierarchy of classifications that appear in conceptual models; what these are, how they are linked and how they should be organised into levels and modelled [1]. It has been recognized that these levels are sometimes ontological [2] and, where they are, that this introduces constraints, such as anti-cyclicity. There have also been attempts to characterise classification and how it differs from generalisation [3-5] that include consideration of their different ontological natures. Though there has been significant work done in this area, we believe that it could be enhanced by introducing a systematic way to investigate the ontological nature and requirements that underlie the levels and so inform the frameworks and tools proposed by the community to support MLM (such as Orthogonal Classification Architecture and Melanee).
In the long term, we aim to provide support for the investigation and understanding of the ontological requirements and so guide the design of ontologies including those used in MLM frameworks and tools. In this paper, we introduce a key component of this, an ontological sandbox. This is a conceptual framework for investigating and comparing multiple variations of possible ontologies – without having to commit to any of them – isolated from a full commitment to any foundational ontology. The sandbox helps to expose and explain the metaphysical structures of the candidate ontologies, the differences between them as well as suggesting potential alternatives. This makes it useful for assessing different architectural choices.
Here we aim to provide a sketch of the sandbox based upon
a constructional approach outlined in [6, 7]. We discuss the
sandbox framework as well as walking through an example of
how it can be used to investigate a simple ontology. The
example, despite its simplicity, illustrates how the
constructional approach can help to expose and explain the
metaphysical structures found in ontologies, and so reveal the
underlying nature of MLM levelling. It illustrates how
metaphysical choices [
We look at how to use these metaphysical structures to derive, and so help to explain the kinds of levelled structures frequently found in conceptual modelling; including taxonomic structures such as the Linnaean hierarchy and component breakdowns common in engineering. This reveals a common underlying foundation for the levelled structures that suggests there may be a wider application for MLM techniques.
We look at the MLM structures themselves. We use the example as a foundation for characterising the family of formal structures associated with MLM classification and generalisation. We show how understanding the way they are derived from fundamental structures helps to explain what they are and how different derivations give rise to the variety of members of the family.
The sandbox adopts the algebraic constructional ontological framework outlined by Fine in [6] and further developed, with a focus on wholes and parts, in [7]. Fine sees the advantage of his framework is that it naturally reveals the underlying metaphysical structure of reality. As an example, he comments on levels: “there is an intuitive distinction between wholes which are like sets in being hierarchically organised and those which are like sums in being ‘flat’, or without an internal division into levels. The distinction, under the operational approach, can be seen to turn on whether repeated applications of the operation are capable of yielding something new” [7]. (One can see the same flat/hierarchy distinction made in the literature between generalisation and classification – a topic we return to below). In the same paper, he talks about its power and beauty; its ability to provide a single and elegant account of a variety of structures. One cannot see this in the logical characterisation to these hierarchies, such as [9]. This makes it a better tool for the task of investigating the metaphysical structure of possible ontologies as well as the ontological content of MLM’s levels.
Here we outline, with some minor clarifications, the relevant portion of Fine’s framework. This is not intended to be a detailed exposition; this can be found in Fine’s papers. We broadly follow Fine’s notation, with some amendments to make this short exposition clearer. We divide the outline into two sections; the first dealing with the general ontological framework and the second with the general composition framework.
Fine’s general framework has two theories; a core theory about ontologies and an extended theory for ontological spaces containing ontologies.
Fine’s core theory deals with constructional ontologies. (From now on we will feel free to drop the qualification ‘constructional’ from ontology – as all ontologies discussed here will be constructional in the Finean sense). In these ontologies, objects are accepted into the ontology on the grounds that they are constructed from elements already in the ontology; where a constructor is applied to the constructees to produce constructs. An ontology can also contain given or basic elements that are just accepted.
Hence an ontology can be divided into three domains (see Acronym B C
E
The basis and constructed domains combine to form a domain whose members are called elements. All three domains combine to form the ontology’s universe, whose members are called items.
The core theory uses ontological principles to show that one can generate all the constructed elements (the constructed domain) from the basis and the constructor domains. As Fine notes, this means we do not need to use the constructed domain, E, to characterise an ontology, we can just use the couple < B, C>; E can then be generated from B and C. Though the order of analysis may well be the opposite; where one starts with the elements and works out what the constructors are and so the bases.
This generation of E relies upon an exhaustive application of the constructors; where anything that can be generated is generated. In our approach, we find it useful to ‘construct’ this process. We call this the ontology’s ONTOGENESIS and characterise the ontology as the couple < B, C > plus ONTOGENESIS; so, in a sense, ONTOGENESIS stands in for E.
Fine’s extended theory is about how ontologies fit into an ontological space; where this is a nonempty collection of ontologies that conforms to certain principles. It shows how, given ontologies in a space, similar ontologies with permutations of basis and constructor domains also exist in the space. We extend this to permutations of the individual constructors in the domain.
This provides a framework for an incremental sandbox approach to explaining and understanding an ontology. If one wishes to understand an ontology (the target), these principles allow one to initially pick out from the ontological space ontologies that contain just the basis domain or just a single constructor from the target ontology and examine these. One can then pick and examine richer combinations, seeing how these lead to richer structures, until one arrives at the target ontology.
Using this general ontological framework, in [7] Fine sketches a general unified framework for composition; the ways in which one object can be a part of another.
It is distinctive in several ways (all of which suit our
current purpose). It takes a very liberal notion of part that
encompasses both traditional mereological relations as well as
others, such as set-membership, that are not usually thought of
as whole-part relations; in other words, for Fine
setmembership in another kind of whole-part. (The term
mereological whole-part will be reserved for the traditional
mereological relations). The formulation of the framework
takes the operation of composition (and decomposition) as
primitive rather than the more familiar relation of whole-part.
These primitive operations are then treated as constructors
within the general ontological framework; where each
fundamental constructor generates a different kind of
wholepart. As noted in Bennett [
Fine formulates his framework in terms of compositional principles; which act like axioms. His first broad division is formal and material. Formal principles can be further divided into those that deal with conditions of application and those that provide identity conditions. Material principles provide, for example, conditions for the presence of a whole or part in space and time or at a world.
Fine develops a simple way of characterising the formal identity principles for summative identity (identity for the mereological sum operation) based upon a notion of regular identity conditions (the reader can find the details in [7]). The result is the four CLAP principles in Table II, so-called because of their initials.
A constructor’s formal identity can be characterised by whether these principles or the counter-principles hold for it – one can summarise this into a CLAP profile, with a mnemonic where the appropriate letter is struck through when the counterprinciple holds. Its application is also characterised by its direction of generation. Table III gives examples of constructors for each CLAP profile and direction.
The composition constructors construct elements – the constructed elements. They also map out the composition structure; how wholes are related to parts and by which kind of whole-part. However, not every application of a constructor constructs new elements; some of these non-generational constructions map new composition structures (others neither construct new elements or new mappings). Sum provides us with a good example of this. If we start with a molecule abc of three atoms as the only given, then a single sum-decomposition into all its parts will construct new elements; a, b, c as well as the molecules ab, ac, and bc. It also give us the composition mapping for abc; the relations between abc and all its parts. If we apply sum-decomposition to ab we get a and b – but these are not new, they are in a sense re-constructed as they were newly constructed in the first decomposition. However, it gives us a new composition mapping for ab, something that was not given in the first decomposition. It also shows, in some sense, ab is prior to a and b. To capture these characteristics, we call the initial types of construction generative. The second decomposition does some work, as it shows that ab is composed of a and b, so we call this type of construction compositional. Earlier we introduced the process ONTOGENESIS, which exhausts the ontology’s generative power. However, as the example shows, this may not exhaust the compositional power. To do this we extend ONTOGENESIS to cover all the possible compositional relations, and call this ONTOGENESIS+. This is needed to extract the full power of the constructors.
Generative Hierarchies. The generative power of constructors provides a way of organising elements into levels within hierarchies. Every constructed element is constructed by a sequence of generative constructions. This provides a simple way to organise them into a hierarchy: each level is characterised by the number of times the constructor has been applied. The additional compositional constructions are not considered here.
One can also see this as a form of ONTOGENESIS, where one is given a START collection and a constructor, and elements are constructed by repeatedly applying the constructor. One needs to be clear what the constructor is being repeatedly applied to. For this it is useful to introduce the notion of stage and to help define it the notion of generation. A generation is all the (new) elements generated at a level–this excludes cases where the element is re-constructed. And a stage is all the elements in a level’s generation and all the prior levels’ generations. Then a stage level hierarchy is generated by repeatedly applying the constructor to stages.
We can make the process a little more formal; we need to account for the cases where the START collection has multiple elements and there are multiple ways to choose the collections to which the constructor is applied. For this we define an operation POWER that takes a collection and selects all the possible sub-collections from this (in our example, we do not need to take account of sensitivity to duplications and permutations). In the case of sets, there is a connection with the set-theoretic powerset axiom. Then, given a constructor, one can create a stage level hierarchy in steps (using constructor and start variables) – where any element that can possibly be generated from the constructor will be generated at some level - as follows: where N is unbounded and the constructor variable ranges over all the constructors (this is needed where there is more than one constructor). For this example, we do not need to consider actual infinite or transfinite recursion. Note that this hierarchy is mixed in the sense that its component parts can be from multiple levels.
There is a variant hierarchy based upon generations rather
than stages - a generation level hierarchy. This is of interest
because the multi-level hierarchies considered in some
multilevel modelling seem to be of this type – see, for example, the
‘level respecting’ principle in [
A generation level hierarchy is one where the next level is generated by applying the constructor to the previous level’s generation. Each step of the generation level hierarchy only considers the preceding level’s generation and so ignores any earlier levels. This means it does not use the full generative power of the constructor. We can formalise this by replacing stage with generation in the earlier process as follows: Generation N+1: constructor (POWER (Generation N))
Note that this hierarchy is pure (that is, unmixed) in the sense that its component parts at each level are from a single level.
There are a few points that we clarify as scene-setting for the sandbox example; kinds and unique decomposition.
Constructed elements are linked to the constructor that constructs them; this can form the basis for kinds. SETBUILDER is a good example. An element is of the kind set if and only if it is constructed by SET-BUILDER. One can also base kinds of whole-parts upon the constructor from which they emerge – so set membership is the kind of whole-part that emerges from SET-BUILDER; relating the (whole–set) constructs with the (parts–members) constructees. Kinds are useful in defining the application scope of the constructor operations; for example, SUM-BUILDER does not apply to elements of the kind set – nor does it construct elements of this kind.
In the case of sets, strings and sequences, there is a unique collection of parts that compose the wholes – the principles merely regulate the permutations and duplicates of the parts and the levelling of the constructors. In standard mereology, which is based upon the mereological whole-part relation, sums work in a different way. There are multiple ways in which a whole can be a sum of its parts. Our framework starts with composition (and de-composition) rather than whole-part and this provides us with a way to ensure a unique decomposition. One can decompose a sum uniquely into a collection of parts. A good illustration of how this would work is a universe of mereological atoms. All the wholes that are sums of mereological atoms would be the sum of a unique collection of these atoms. If one did not want to assume mereological atoms, one can take the decomposition to be all the parts. We adopt this latter approach for the example.
We now describe a simple example ontology, called (unsurprisingly) SIMPLE. The SIMPLE ontology is intended to illustrate how our approach is useful in explaining the formal requirements for metaphysical structures in models. Given this goal, we aim to make the example as simple as possible while still being able to illustrate how the structural whole-part patterns emerge, with a focus on the hierarchies and levels (such as generation and stage level hierarchies) within the patterns.
As noted earlier, in the Finean ontology framework, we can characterise an ontology in terms of its basis and constructor domains, which we now do. Our full example ontology, called SIMPLE, has a non-empty basis domain and a constructor domain containing two constructors (SET-BUILDER and SUM-DECOMPOSER).
Under our approach, based upon the Finean Extended Theory, we construct an ontological space with ontologies that take us in small incremental steps from the NULL ontology to the final SIMPLE ontology. This is essentially all the permutations of basis domain and individual constructors (as Table IV shows). Some of the permutations are not illuminating, so are not visited in the analysis – these are marked in Table IV.
One could regard the other ontologies as partial versions of the SIMPLE ontology, or subontologies of it. We start the analysis with the Simple Basis Only (Sub-)Ontology.
Simple Basis Only (SB) Ontology. From a metaphysical
viewpoint, the choice of bases typically involves important
architectural commitments [
To keep things simple, we follow the priority monism route
and have a basis domain consisting of a single object – a
pluriverse of possible worlds [
We can now define the ontology as SB = < (PV), () >. As there are no constructors in this ontology then ONTOGENESIS is the NULL process – and PV is the only element (and item) in the ontology. From a hierarchy perspective, this is a limit case. There is a single object which can be regarded (pathologically) as a stage level hierarchy.
SET-BUILDER Only (SET) Ontology. This ontology has an empty basis domain and a single constructor SETBUILDER, mentioned earlier, so SET = < (), (SET-BUILDER) >. This constructor is introduced in [6] and described in detail in [7]. We mentioned SET-BUILDER earlier in Table IV, noting it is formally a SET constructor where the direction of generation is part to whole and its form of identity is CLAP; it works as follows: • It has the associated kind, sets. An element is a set if and only if it is constructed by SET-BUILDER. • It is presented with a collection (possibly empty) of elements (parts) and it constructs a set (the whole). • If presented with a collection of zero elements it generates the empty set, {}. • Its CLAP profile means that if presented with a nonzero collection of elements it generates the set of those elements, ignoring duplicates and order.
This provides us with sufficient resources to develop a good example of generation and stage level hierarchies. Using the process schema defined earlier, we can create SET’s generation level hierarchy in steps as follows:
The first four levels’ generations and stages are shown in Table V.
This provides us with an example of the point made earlier, that the generation level hierarchy is not necessarily the whole constructed domain as, at each level, the constructor is only applied to the previous generation. For example, at stage 2, the universe contains both generation 1 and 2 elements, but SETBUILDER is only applied to the generation 2 elements.
Of course, we could take a related constructor GENERATION-SET-BUILDER whose application is restricted to generation collections of elements, then the hierarchy would cover the domain. However, we would then have to metaphysically justify the choice of this constructor.
We can reinforce this incompleteness point by generating the corresponding stage level hierarchy by replacing generation with stage as noted earlier, giving:
SET-BUILDER (POWER (Stage N))
The first three levels are shown in Table VI. The full process exhausts the generative power of the basis domain and constructors and so; ONTOGENESIS (SET): SET-BUILDER Stage Level Hierarchy.
Every application of the SET-BUILDER is generative, so there is no difference between ONTOGENESIS (SET) and ONTOGENESIS+ (SET).
Simple Basis plus SUM-DECOMPOSER (SB+SUM) Ontology. This ontology is an extension of the Simple Basis Only Ontology with the SUM-DECOMPOSER constructor, so; SB+SUM = < (PV), (SUM-DECOMPOSER) >. We see from Table IV, that SUM-DECOMPOSER is a SUM constructor where the direction of generation is whole to part and its form of identity is CLAP. It works as follows: • It has the associated kind, material elements. PV is a material element, all the elements constructed by SUMDECOMPOSER are also material elements and these are the only material elements. • It is presented with a single material element (the whole) and it constructs a collection of material elements (parts). • Its CLAP profile means that it generates a collection of elements with no duplicates or order.
The choice of this constructor naturally complements the choice of PV as a basis. Given the super-substantival choice for PV, SUM-DECOMPOSER takes a material element and uniquely decomposes it into all its material, spatiotemporal parts. One can see the constructor as establishing the parts of which the whole is composed.
This ontology has a simple two level hierarchy, with PV as generation 0 and all its parts as generation 1. And only one application of the constructor gives all the constructed elements; the parts of the whole PV. So: ONTOGENESIS (SB+SUM): SUM-DECOMPOSER (PV). ONTOGENESIS+ (SB+SUM) needs to consider these parts as wholes and establish their parts, and this is achieved by applying sumdecomposer to each of them. We specify this process using an iterative FOR EACH component process – as follows: (PV) SUM-DECOMPOSER (PV) FOR EACH X in Generation 1 (SUM
DECOMPOSER (X))
The two generations exhaust the compositional power of the constructor.
The SIMPLE Ontology. This ontology is Simple Basis plus SET-BUILDER and SUM-DECOMPOSER, so SIMPLE = < (PV), (SET-BUILDER, SUM-DECOMPOSER) >. It is a combination of all of the earlier ontologies, where the basis domain and constructors were defined and much of the analysis done.
This is the first ontology with multiple constructors. For the single constructor situations, we had two simple levelling schemes based upon the number of applications of the constructor; we combine these for multiple constructors to give us ONTOGENESIS, as follows:
SUM-DECOMPOSER (PV) + SETBUILDER (POWER (PV)) SET-BUILDER (POWER (Stage 1))
The ONTOGENESIS hierarchies do not have the same symmetry as the cumulative set hierarchy. For example, the standard cumulative set hierarchy all the singleton sets are at the same level (see SET above). However, as shown in Table VII (where p1, p2, … are the parts of PV), the combination of the two constructors produce, at level 1, not only all the parts of PV but also the empty set and singleton PV – and produces at level 2 singletons of the empty set and the parts of PV as well as singleton-singleton PV.
This suggests another way to construct hierarchies; by calculating the levels using a single constructor. In this case, by only considering the generative applications of SETBUILDER– ignoring SUM-DECOMPOSER. This recaptures the symmetrical hierarchy.
The example shows how fundamental multi-level hierarchies emerge from the pattern of construction. However, this is not the only way that these hierarchies, multi-level or otherwise, can emerge. The fundamental structures can be used to derive other types of compositions and their associated hierarchies.
One of these derived types of composition is subset or setinclusion. For our purposes, it makes sense to do this using a derived constructor SUBSET-DECOMPOSER (set) that works as follows: • Its direction of generation is whole to parts. • Its form of identity (like SUM-DECOMPOSER) is CLAP, which means that it generates a collection of elements with no duplicates or order. • It is presented with a single set element (the whole) and it constructs a collection of set elements (the subset parts) – hence it can only be applied to elements of kind set and it constructs elements of the same kind.
Applying this constructor to a set will produce a collection of all its subsets. This can be regarded as the initial stage in the set-theoretic power set axiom. To formalise this, we specify the inverse of SET-BUILDER; SET-DECOMPOSER (set) which takes a set and produces a collection of its members. Using this we can specify; SUBSET-DECOMPOSER (set) = SETBUILDER (POWER (SET-DECOMPOSER (set))). This, when given a set takes its members and constructs sets from them, constructing all its subsets. As with SUMDECOMPOSER, one then needs to apply the same operation to each of the parts to establish the full subset composition mapping, as shown below.
One can begin to see the structural similarities between
SUBSET-DECOMPOSER and ordinary
SUMDECOMPOSER noted in [
One can derive a new hierarchy by subsumption from a whole-part hierarchy – and this can be levelled in ways that the original hierarchy is not. Taxonomies, including ones such as the Linnaean classification, and component breakdowns, in so far as they are ontological, are good examples. The procedure is simple. One chooses a subset of the elements and then a subset of their whole-part compositions so that the result conforms to the desired whole-part structure; if one wants a levelled structure, then one ensures the structure conforms to the right CLAP principles – typically that it does not adhere to levelling.
Consider (one version of) the Linnaean classification hierarchy that has ‘Natural Things’ at the top and is divided and sub-divided through the levels until reaching ‘Felis leo’ and ‘Felis tigris’ as the bottom. Within the SIMPLE example, ‘Natural Things’ is a set of (spatiotemporally extended) material elements and the other classifications are subsets of it [5]. This collection of classifications are the elements used in the hierarchy. These can be derived using SUBSETDECOMPOSER and a filter, FILTER-LC, that given a collection selects those elements that are Linnaean classifications; LINNAEAN-C: FILTER-LC (SUBSETDECOMPOSER (Natural Things)).
Traditionally, the classification structure is levelled by taking a transitive reduction of the underlying whole-part hierarchy. We can derive the LINNAEAN-SUBSETDECOMPOSER constructor for this by taking a constrained version of SUBSET-DECOMPOSER that can only be applied to Linnaean classifications and when applied only reruns the next level – other levels are filtered out. This gives us a natural generation level hierarchy LC, which is defined as having ‘Natural Things’ as its base and LINNAEAN-SUBSETDECOMPOSER as its sole constructor – and;
Of course, the classification structure is richer; which means more constructors are needed. For example, the levels (e.g. Kingdoms) are explicit as ranks (this is described in [5]), so a RANKER constructor is required. However, this skeleton outline should be sufficient to indicate how this could be done.
The same derivation process can be used on other kinds of
whole-parts. Component breakdown structures (such as car X
breaks down into body and engine components and engine into
so on) would be based upon mereological whole-part and
SUM-DECOMPOSER [
This ability to derive levelled hierarchies from the fundamental structures not only helps to explain (ontologically) what these hierarchies are but also suggests there may be new areas for MLM tools to be deployed.
Analyses of classification and generalisation have noted the
similarities with, respectively, set-membership and subset [3].
A common point made is that generalisation (like subset) is
transitive and does not have levels whereas classification (like
set-membership) is anti-transitive and has levels [
However, classification is not plain set-membership nor generalisation plain subset – and the differences can guide us on how to build the appropriate derived constructors. One key difference is that the conceptual models typically restrict their relations to a sub-domain of interest. As with the taxonomies above, this can be captured by a filter on the constructor – where the filter clearly delineates the scope of the domain.
In UML and MLM there are many varieties of generalisation. In some MLM contexts, the generalisation hierarchy is, like in taxonomies above, restricted to a transitive reduction. This is also common in conceptual modelling contexts, where typically only the transitive reduction is modelled, and the transitive closure is rarely if ever mandatory. In some contexts, the hierarchy is restricted to a tree-structure, whereas in others it is more usual to allow lattice (multiple inheritance) hierarchies. Submitting these different structures to a sandbox analysis would capture their different commitments in derived constructors (typically using filters) with their appropriate CLAP profile – as well as their common underpinnings.
Similarly, there are varieties of classification. As noted
earlier, [
It also gives rise to natural enquires as the motivations for the choices; for example, are they adopted for metaphysical/ontological or pragmatic reasons, and if so, what are these reasons? So, for example, it makes clear that adopting a GENERATED-SET-BUILDER (as strict metamodelling does) filters out mixed sets. One can ask what the motivation for this is and whether the cost of excluding them is worthwhile.
We have provided an outline of the underlying framework upon which the ontological sandbox is built and indicated where further details can be found [6, 7]. We have used the example SIMPLE ontology to show how one can use this sandbox to build up an understanding of the target ontology in steps through ontological space. We have shown how the constructional approach exposes the underlying compositional metaphysical structures of ontologies; for example, how, in the SIMPLE ontology at least, the set-inclusion hierarchy is derived from the fundamental set-membership hierarchy’s constructor. We have shown how understanding the CLAP principles of composition can expose the architectural choices made and suggest alternatives. We have shown how familiar hierarchical structures, such as taxonomies and component breakdowns, can be derived from more fundamental structures. We have shown how the same techniques can be applied to MLM classification and generalisation structures. We have provided a clear picture of the trade-off between order and expressiveness that drives the choice of strict metamodelling (effectively a generation level hierarchy) – as well as an alternative – stage level hierarchy. Hopefully, this is sufficient to provide a good idea of the potential for this sandbox to help us understand and improve the ontological underpinnings of conceptual models.
This paper provides an outline of the ontology sandbox. A lot more work needs to be done showing how it can be used. One area where we think it will be fruitful to develop the approach is investigating the range of possible ontological commitments of existing MLM frameworks and tools. This could not only suggest possible ontologies (and so semantics) for the frameworks but also identify possible ontologically driven improvements.
REFERENCES