The IFF Ontology (meta) Ontology (IFF-ONT)
provides a metalevel axiomatic framework for object-level ontologies. The second term “Ontology” in the title refers
to the fact that this is a meta-ontology – an ontology located in the
IFF metalevel. The first term “Ontology” in the title refers to the
fact that this is about object-level ontologies. The
documentation for the IFF-ONT consists of three parts: this
introductory HTML document that gives a brief intuitive overview of
the IFF-ONT, a metatheory PDF document that gives an IFF
upper metalevel abstraction for the IFF-ONT, and four namespace PDF
documents
that give the IFF-ONT axiomatization.
|
Namespaces |
|
Metatheory |
|
| Languages |
(95 pages) |
Category
Theory of Ontologies |
(61 pages) |
| Theories |
(49 pages) |
||
| Models |
(36 pages) |
||
| Logics |
(14 pages) |
Here are the page and term statistics for the documentation of the IFF-ONT.
A total of 270 pages are used to describe and axiomatize the IFF-ONT. This introduction document (HTML) is 15 pages long, the metatheory document (PDF) is 61 pages long, and the four namespace documents (PDF) have a total of 194 pages. The latter breaks down as follows: the language namespace document is 95 pages, the theory namespace document is 49 pages, the model namespace document is 36 pages, and the logic namespace document is 14 pages.
A total of 681 terms are introduced to describe and axiomatize the IFF-ONT. This introduction document contributes no terminology. The metatheory document has 49 terms for naming the categories, functors, natural transformations, adjunctions and monads needed to link the IFF-ONT with the IFF upper metalevel axiomatization. This terminology can be regarded as part of the IFF upper metalevel. That leaves a total of 632 terms that are introduced in the four namespace documents. This total breaks down as follows. The type language namespace document introduces 328 terms: 96 terms are basic or special, 39 terms are used for expressions, 20 terms for interpretations, 123 terms for language colimits, and 50 terms for the truth concept lattice of theories for languages. The theory namespace document introduces 172 terms: 39 terms are basic or special, 96 terms are used for theory colimits, and 37 terms are used for the truth concept lattice of theories for theories. The model namespace document introduces 88 terms. Finally, the logic namespace document introduces 44 terms, where 27 terms are for prologics and 17 terms are for logics.
It is clear that the more basic areas
of the IFF-ONT, such as languages, receive most of the description and
axiomatization. This is natural, since the current version of the
IFF-ONT offers only a baseline axiomatization for the metalogic of
object-level ontologies. Further more detailed axiomatizations, needed
for applications such as semantic integration, will probably be
concentrated more at the higher levels, such as logics.
|
generalized
inverse |
|
| ω | free (power) model |
|
| υ | free prologic |
|
| ρ | restriction |
|
| λ | integration |
|
| π | projection |
|
| μ | semantics |
|
It has been the opinion of many that
the best way to handle the multivalent relations in ontologies is with
hypergraphs. A first order IFF type language
is a kind of aligned
hypergraph. It consists of sets for variables, entity types
corresponding to hypergraph nodes, and relation types corresponding to
hyperedges, and functions for defining the reference, signature and
arity of relation types. In contrast to the notion of a hypergraph, a
type language is aligned along its reference function. The set of
entity types linked by a relation type is called its signature. Type
languages are related through type language morphisms. A type language
morphism from source type language to target type language maps source
entity (relation) types to target entity (relation) types, preserving
reference, signature and arity. The context of languages Language
consists of
first order type languages and their morphisms. The context Language⊥
is the subcontext whose morphisms are special – they have
bijective
variable functions.
Any type language is extended to a type
language of expressions,
which has the same sets for variables and
entity types and the same reference function, but has logical
expressions (formulas) as its relation types. The set of expressions,
which is defined recursively, is the disjoint union of atomic
expressions, negations, conjunctions, disjunctions, implications,
existential and universal quantifications, and substitutions. There is
a special embedding type
language morphism from any type language to
its expression type language. Of course, we can form expressions of
expressions. There is also a special collapsing
type language morphism
from the expressions of expressions type language to the expressions
type language. The triple of operators (expressions, embedding,
collapsing) has nice monoidal
properties (identity, associativity, etc.). Associated with this triple
is the derived
context of type language interpretations. Intuitively, a type language
interpretation is a type
language morphism from one type language to
the expressions of another type language.
The IFF gives a (somewhat novel)
category-theoretic axiomatization for first-order model theory based
upon the two fundamental ideas of classification and hypergraph. In one
sense, an IFF model is a hypergraph of classifications. In place of
nodes, there is a classification of entities, and in place of
hyperedges, there is a classification of relations. The set of entity
instances is called the universe of discourse, and the set of relation
instances is called the tuple space. In another sense, an IFF model is
a classification of hypergraphs – the instance aspect of a model forms
an instance hypergraph, and dually the type aspect of a model forms a
type language. IFF models are equivalent to the models of traditional
many-sorted logic. In this equivalence, the extent functions of the
entity, relation and expression classifications are regarded as
interpretation functions.
Relation classification is inductively extended to expression classification. In the expression classification, tuples satisfy expressions. When a tuple is classified by an expression, we say that the expression holds for the tuple or that the tuple satisfies the expression. The IFF has a lax notion of satisfaction for tuples. For a tuple to satisfy an expression, or that expression to hold for or classify that tuple, we only require that the arity of the expression be a subset of the arity of the tuple and that the restriction of the tuple to that subset satisfy the expression in the usual sense. Satisfaction is defined recursively. A model satisfies an expression of its type language when all tuples are classified by that expression. In other words, a model satisfies an expression when that expression holds for all tuples; i.e., has maximal extent in the expression classification. A model for a theory is a model that satisfies every axiom of that theory. Every model generates a theory, whose base language is the underlying type language of the model, and whose axioms are all expressions satisfied by the model. The theory of a model is closed, and is the maximal theory satisfied by that model.
An IFF theory extends a
type language with a set of expressions
called axioms. These embody a formal or axiomatic semantics. A theory
logically entails an expression of its base language when every model
of the theory is also a model of the expression. Obviously, all axioms
are entailed by a theory. The closure of a theory is the theory with
the same base whose axioms consist of all expressions entailed by the
original theory. An axiom of the closure is called a theorem of the
original theory. Any axiom is a theorem. A theory is closed when it is
its own closure. Theories are related through theory morphisms. A
theory morphism from source theory to target theory is a type language
morphism that maps source axioms to target theorems. The context of
theories Theory
consists of all theories and their morphisms. The context
Theory⊥ is the subcontext
whose morphisms are special – their bases
have bijective variable functions. Any theory has an initial model,
which is the free model of the base language, restricted to those
tuples satisfying all the axioms of the theory. This model is the
initial model in the collection of all models of that theory. The
initial model passage init-mod
: Theory⊥ → Model and the
maximal
theory passage max-th
: Model → Theory⊥ form the semantics
generalized inverse μ,
which links interpretative semantics of the
model
context with the axiomatic semantics of the theory context.
Any theory has a free logic, whose component theory is the original
theory and whose component model is the initial model over that theory.
For any logic the canonical logic intent infomorphism from the free
logic over the component theory of the logic to the logic itself. The
intent infomorphism is the identity on types, maps entity instances to
their entity extents, and maps relation instances (tuples) to their
relation extents consisting of all relation types (with possibly
smaller arities) that classify that tuple. The free logic over a theory
has the following meaning. Any theory morphism from a theory to the
component theory of a logic, is naturally equivalent to a logic
infomorphism from the free logic over the theory to the logic. This
adjoint logic infomorphism can be computed as the composition of the
free logic infomorphism of the theory morphisms and the canonical logic
intent infomorphism for that logic. The IFF approach to the semantic
integration of object-level ontologies is a two-step process consisting
of alignment followed by unification. The construction of a
free logic
over a common mediating theory, a lifting operation from the context of
theories to the context of logics, is an essential sub-step of IFF
alignment.
When free logics are investigated with respect to the lax IFF notion
of satisfaction, there is a question about the relationship between
unary relation types (unary predicates) and entity types (sorts). The
IFF adopts a laissez-faire attitude: use the least constraints needed.
It defines its basic logic using the constraint that every unary
predicate has a particular sort (the single sort in its signature): the
relational extent of the unary predicate is contained in the entity
extent of its sort. However, the free logic construction requires that
we tighten up our axiomatization for models. The logic notion needed
for the free logic construction requires that every sort be the sort of
some unary predicate that is extensionally equivalent to it.
An IFF prologic is an inclusive idea combining the notions of model
and theory into a (not necessarily sound) whole. It consists of a
component theory of types and a component model of instances that share
a common type language. The theory provides the formal semantics and
the model provides the interpretative semantics. A free prologic can be
constructed over any theory by adjoining to that theory the free model
of its base type language. The free passage from theories to prologics
and the component theory passage form the free prologic generalized
inverse υ, which is a fibered
product of the free model generalized
inverse with an identity generalized inverse on special theories.
In addition, two special subsets are highlighted: there is a subset of
the universe of discourse called the normal entities and a subset of
the tuple space called the normal tuples, where the components of
normal tuples are normal entities and normal entities and normal tuples
satisfy the axioms of the theory. A prologic is sound when every
instance of the universe is normal and every tuple is normal. By
definition, an IFF logic is
a sound prologic. For any prologic, the
sound part of the prologic is obtained by restriction – the restriction
construction throws away all abnormal instances and restricts the
entity and relation classifications to normal instances. The
restriction passage from prologics to logics and the inclusion of
logics as prologics forms the restriction
generalized inverse ρ.
A logic
infomorphism from source logic to target logic is a theory morphism
along the theory aspect and a model infomorphism along the model aspect
that share a common type language morphism. The context of logics
Logic
consists of all logics and their infomorphisms.
Any theory forms a free logic with its initial model. The free logic log
: Theory⊥ → Logic and
underlying theory th
: Logic → Theory⊥ passages form
the integration (aka free
logic)
generalized inverse λ, which
is important in the IFF semantic integration
of object-level ontologies. The integration generalized inverse is the
composition of the free prologic generalized inverse with the
restriction generalized inverse. Any model has a free logic, whose
component model is the original model and whose component theory is the
maximal theory over that model. The component model passage between the
logic and model contexts mod
: Logic → Model and the
free logic passage log
: Model → Logic form a component
model or projection
generalized inverse π. The
semantics generalized inverse is
the
composition of the integration generalized inverse with the component
model generalized inverse.
There is an initial language consisting of empty variable, entity
and relation type sets. There is an initial
theory whose base is the
initial language and whose axiom set is empty. Any two languages have a
sum defined via the disjoint
unions of variable, entity and relation
type sets. Any two theories have a sum defined as the sum of their base
type languages and the union of their axiom sets. A span over a theory
pair is a third theory that is the source of two theory morphisms to
the pair. Any span of theories has a fusion,
which is the appropriate
quotient theory modulo the span on the sum of the underlying theory
pair.
The lattice of theories is represented in IFF-ONT, the IFF Ontology
(meta) Ontology. This parallels much of the Formal Concept Analysis
(FCA) development in the IFF Upper Classification Ontology (IFF-UCLS).
The mathematical theory for the IFF-UCLS is presented in Kent 2002a.
Classifications are also known as formal contexts in Formal Concept Analysis (FCA). A classification consists of a collection of instances also known as formal objects in FCA, a collection of types also known as formal attributes in FCA, and a binary incidence relation.
Each first order type language L has an
associated truth
classification, whose collection of instances mod(L) is the class
of
models of the language, whose collection of types expr(L) is the set of
expressions of the language, and whose incidence is satisfaction. The
truth classification truth-cls(L) is a large
classification, since its
collection of instances is a set-theoretic class.
| mod(L) = model(L) |
instances (formal objects): models whose underlying type language is L |
| expr(L) = expression(L) |
types (formal attributes): expressions of L |
| truth-incidence(L) = satisfies(L) = |=L |
truth incidence is satisfaction A |=L φ for A ∈ mod(L) and φ ∈ expr(L) |
| truth-cls(L) = truth-classification(L) = (mod(L), expr(L), |=L) |
truth classification over L |
The notion of a concept lattice
is the central data structure in
FCA. It is a complete lattice, where each lattice element resolves as
both a join and a meet of subsets of distinguished atoms. A concept
lattice consists of: a collection of instances, a collection of types,
a collection of formal concepts, an embedding map from instances to
concepts, an embedding map from types to concepts, an order relation on
concepts, and meet and join operators that map subcollections of
concepts to single concepts. The embedding image of an instance is
called an instance concept. The collection of instance concepts is
join-dense: any concept can be expressed as the join of a subcollection
of instance concepts. The embedding image of a type is called a type
concept. The collection of type concepts is meet-dense: any concept can
be expressed as the meet of a subcollection of type concepts.
Every classification serves as the base of a concept lattice. A formal
concept of a classification is a pair consisting of a collection
of
instances called the extent of
the concept and a collection of types
called the intent of the
concept, where every instance is classified by
every type, and there are no other such instances or types. A formal
concept can be represented by either its extent or its intent, since
these are equivalent and define each other. One concept is below
another concept in the lattice order
when it is more specialized – it
has a bigger intent and a smaller extent. Any collection of instances
generate a concept whose intent is the collection of all types
that
classify those instances. Any collection of types generate a concept
whose extent is the collection of all instances that are classified by
those types. For any collection of concepts there is a join concept
defined as the concept generated by the intersection of the intents.
For any collection of concepts there is a meet concept defined as the
concept generated by the intersection of the extents. This completes
the description of the concept lattice associated with a
classification.
Each first order type language L has an
associated large concept
lattice truth(L) called the
truth concept lattice or the “lattice
of
theories” (see Figure 2a). The IFF represents these formal
concepts in
terms of their intents, which are elements of the set cloth(L) of
closed theories of the language. The collection of instances mod(L) is
the class of models for the language, and the collection of types
expr(L) is the set of
expressions for the language. Lattice order is
reverse subset inclusion on the theorem sets of closed theories. The
instance embedding function max-th(L) maps a model
to its maximal
theory, whereas the type embedding function entail(L) maps an
expression to the theory of all entailed expressions.
Any collection of models generates a closed theory, whose set of
theorems is the intersection of the theorem sets. Any collection of
expressions generates a closed theory, whose theorem set is the closure
of the theory with just those expressions as axioms. The (set of
theorems of the) meet of a collection of closed theories is the concept
generated by (closure of) the union of the theorem sets. The (set of
theorems of the) join of a collection of closed theories is the
intersection of the theorem sets.
| cloth(L) = closed-theories(L) |
formal concepts: closed theories whose base language is L |
| max-th(L) = maximal-theory(L) = ιL : mod(L) → cloth(L) |
model embedding function: maximal theory |
| entail(L) = τL : expr(L) → cloth(L) |
expression embedding function: expression entailment theory |
| ≤L |
lattice order: reverse theorem subset inclusion |
| truth(L) truth-concept-lattice(L) = lattice-of-theories(L) = (cloth(L), mod(L), expr(L), ιL, τL) |
truth concept lattice of theories |
Each special type language morphism f : L → Ł has an associated large concept morphism truth(f) : truth(L) → truth(Ł) (see Figure 2b) called the truth concept morphism or the “lattice morphism of theories”. Concept morphisms consist of four components: an instance function, a type function and the left and right monotonic functions of an adjoint pair connecting the concept lattices of source and target languages.
The instance (formal object) function mod(f) : mod(Ł) → mod(L) maps a model of the target language to a model of the source language. This is axiomatized in the language namespace, where it is called the model fiber function. The type (formal attribute) function expr(f) : expr(L) → expr(Ł) maps an expression of the source language to an expression of the target language. This also is axiomatized in the language namespace. The IFF transforms formal concepts in terms of their intents. The left adjoint monotonic function left(f) : cloth(Ł) → cloth(L) maps a closed theory of the target language to a closed theory of the source language. It is defined in terms of the inverse image expression function expr(f)–1 : Pexpr(Ł) → Pexpr(L) on the theorem sets. The right adjoint monotonic function right(f) : cloth(L) → cloth(Ł) maps a closed theory of the source language to a closed theory of the target language. It is defined in terms of the direct image expression function Pexpr(f) : Pexpr(L) → Pexpr(Ł) on the theorem sets, and the closure function clo(Ł) : th(Ł) → cloth(Ł).
Being monotonic, the left and right functions preserve lattice order
(reverse subset inclusion on the theorem sets of closed theories). In
addition, the left adjoint preserves arbitrary lattice joins and the
right adjoint preserves arbitrary lattice meets. Furthermore, the
concept morphism preserves instance embedding, since the left function
commutes with the instance function through the instance embeddings:
max-th(Ł) · left(f) = mod(f) · max-th(L). This means
that
the left image of the embedding of any model of the target language is
the embedding of its model fiber. And also, the concept morphism
preserves type embedding, since the right function commutes with the
type function through the type embeddings: entail(L) · right(f)
= expr(f) · entail(L). This means
that the right image of the
embedding of any expression of the source language is the embedding of
its expression image. The instance (model fiber) function is not in the
computational part of truth, whereas the other three component
functions are computational.
| mod(f) = model(f) |
instance (formal object)
function: model fiber function of f |
| expr(f) = expression(f) |
type (formal attribute) function: expression function of f |
| left(f) expr(f)–1 |
left adjoint monotonic function: inverse image of the expression function of f |
| right(f) clo(Pexpr(f)) |
right adjoint monotonic function: closure of the direct image of the expression function of f |
Figures 2a and 2b diagrammatically illustrate the functionality that
is axiomatized in the type language and theory namespaces of the
IFF-ONT. Figure 2a is concerned with functionality associated with a
type language L.
whereas Figure 2b has functionality associated with a
type language morphism f : L → Ł. Tables 1 and
2 list a more
complete truth functionality.
Table 1: IFF Lattice of Theories Operators – Objects
|
IFF Lattice of Theories Namespace [ L is a type language ] |
| instance(L) = model(L) type(L) = expression(L) truth-incidence(L) = satisfies(L) = |=L ⊆ model(L) × expression(L) truth-classification(L) |
| concept(L) = closed-theory(L) extent(L) : closed-theory(L) → Pmodel(L) intent(L) = theorem(L) : closed-theory(L) → Pexpression(L) truth-order(L) = ≤L ⊆ closed-theory(L) × closed-theory(L) |
| instance-generation(L) : Pmodel(L) → closed-theory(L) type-generation(L) : Pexpression(L) → closed-theory(L) |
| join(L) : Pclosed-theory(L) → closed-theory(L) meet(L) : Pclosed-theory(L) → closed-theory(L) truth-lattice(L) |
| maximal-theory(L) : model(L) → closed-theory(L) entail(L) : expression(L) → closed-theory(L) truth-concept-lattice(L) = lattice-of-theories(L) |
Table 2: IFF Lattice of Theories Operators – Morphisms
|
IFF Lattice of Theories Namespace [ f : L → Ł is a special morphism of type languages ] |
| instance(f) = mod(f) : model(Ł) → model(L) type(f) = expr(f) : expression(L) → expression(Ł) truth-infomorphism(f) : truth-classification(L) → truth-classification(Ł) |
| left-adjoint(f) = expr(f)–1
: closed-theory(Ł) → closed-theory(L) right-adjoint(f) = clo(Pexpr(f)) : closed-theory(L) → closed-theory(Ł) truth-adjoint-pair(f) : truth-lattice(L) → truth-lattice(Ł) truth-concept-morphism(f) : truth-concept-lattice(L) → truth-concept-lattice(Ł) |
This subsection follows the discussion
in section 6.5 “Theories, Models and the World” of the book Knowledge
Representation by John Sowa. From each theory in the lattice of
theories, the partial ordering defines paths to the more generalized
theories above and the more specialized theories below. Figure 4 shows
four ways for moving along paths from one theory to another:
contraction, expansion, revision and analogy.
Contraction: Any (closed) theory can be contracted or reduced to a smaller, simpler closed theory by deleting one or more axioms.
Expansion: Any (closed) theory can be expanded by adding one or more axioms.
Revision: A revision step is composite – it uses a contraction step to discard irrelevant details, followed by an expansion step to added new axioms.
Analogy: Unlike contraction and expansion, which move to nearby theories in the lattice, analogy jumps to a remote theory by systematically renaming the entity types, relation types, and constants (individuals) that appear in the axioms.
By repeated contraction, expansion, and analogy, any theory can be converted into any other. Multiple contractions would reduce a (closed) theory to the empty (top) theory at the top of the lattice. The top theory is the closure of the empty theory – it contains only tautologies or logical truths; i.e., expressions that are true in all models (it is “true of everything”). Multiple expansions would reduce a (closed) theory to the full inconsistent theory at the bottom of the lattice. The full inconsistent theory is the closed theory consisting of all expressions; i.e., expressions that are true in no models (it is “true of nothing”).
In the IFF, the operations of contraction, expansion and revision are not primitive. Suppose we have a theory T = (base(T), axm(T)) over a base type language L = base(T), whose closure clo(T) = (base(T), thm(T)) is in the concept lattice of theories indexed by L. The IFF closure function in the language namespace
clo(L) : th(L) → cloth(L)
Map the theory to its subset of axioms
T1 ›→ axm(T1)
using the IFF axiom function
axm(L) : th(L) → Pexpr(L)
in the IFF theory namespace.
Apply the subset difference operation getting a new set of axioms
(axm(T1), A) ›→ axm(T1) – A
using the set difference function
set-diff(expr(L)) : Pexpr(L) × Pexpr(L) → Pexpr(L)
in the IFF set function namespace (of the IFF lower core ontology).
Install this subset of expressions as a theory
axm(T1) – A ›→ T2 = (base(T1), axm(T1) – A),
using the IFF installation function in the language namespace
install(L) : Pexpr(L) → th(L).
Analogy is represented in the IFF by type language and theory morphisms. A type language morphism
f : L → Ł
from type language L to type language Ł maps (renames) the entity types, relation types and constants using the entity, relation and constant functions
respectively. As describe above, associated with a special type language morphism f is the concept lattice of theories morphism
truth(f) : truth(L) → truth(Ł)
from the truth concept lattice of theories over L to the truth concept lattice of theories over Ł.
The following discussion represents an IFF approach to the semantic integration of object-level ontologies. This is just one of many possible approaches to semantic integration.
Assume that two communities, whose knowledge is represented in their own separate community ontologies, want to design a new ontology that integrates the two participant community ontologies into a fusion ontology. Moreover, they want fusion to respect their own knowledge structures, but they also want to incorporate a substantial amount of agreement. The following discussion depicts a process they might undertake in order to accomplish this. For more on this see the two papers (Kent 2000, Kent 2003).
The IFF integration of ontologies is the two-step process of alignment and unification. Ontological alignment consists of the sharing of common terminology and semantics through a mediating ontology. Ontological unification, concentrated in a virtual ontology of community connections, is fusion of the alignment diagram of participant community ontologies – the quotient of the sum of the participant portals modulo the ontological alignment structure. Unification is the automatic process of fusion in the theoretical/logical context. However, alignment is not automatic, but at best only semiautomatic.
In the IFF, ontologies are represented by theories and populated ontologies – those with instance data- are represented by logics. We start with two participant community ontologies represented as logics. We end, after the alignment and unification steps, with a third logic representing the fusion ontology. Integration is facilitated by a fourth mediating ontology.
The mediating ontology with alignment
links is called the alignment diagram.
Construction of the alignment
diagram is not automatic. Instead, much negotiation between participant
communities will be involved in this step. Perhaps some form of
game-theoretic semantics would be useful here.
The process of unification is fusion of the alignment diagram. We use the logic alignment diagram to specify a logic invariant: we use the type aspect to specify an equivalence relation on the types (entity, function and relation) of the sum logic, and we use the instance aspect to specify an appropriate subset of the instances (entity, function and relation) of the sum logic. This logic invariant induces a quotient logic over the sum logic: types are the quotient classes of the corresponding equivalence relation, whereas instances called instance connections are pairs of instances, one from each participant ontology, that are indistinguishable vis-à-vis the mediating ontology. This quotient logic represents a virtual ontology that is a fusion of the community portals with respect to the alignment diagram. A canonical logic infomorphism links the sum logic to the quotient logic – its type component maps sum types to their equivalence class, and its instance component is subset inclusion. Two fusion injections link the portals with the quotient logic. The resulting unification diagram consists of two unification links from the component ontologies to the fusion ontology. The links are the composition of the portals links with the fusion injections. The fusion ontology represents the complete system of semantic integration.
Barwise, Jon and Seligman, Jerry. 1997. Information Flow: The Logic of Distributed Systems. Cambridge Tracts in Theoretical Computer Science 44. Cambridge University Press.
Chang, C. C. and Keisler, H. J. 1973. Model Theory. Studies in Logic and the Foundations of Mathematics 73. Amsterdam: North Holland.
Enderton, Herbert B. 1972. A Mathematical
Introduction to Logic. New York: Academic Press.
Kent, Robert E. 2000. The Information Flow Foundation for Conceptual Knowledge Organization. In: Dynamism and Stability in Knowledge Organization. Proceedings of the Sixth International ISKO Conference. Advances in Knowledge Organization 7 (2000) 111–117. Ergon Verlag, Würzburg.
Kent, Robert E. 2002a. Distributed Conceptual Structures. In: Proceedings of the 6th International Workshop on Relational Methods in Computer Science (RelMiCS 6). Lecture Notes in Computer Science 2561. Springer, Berlin.
Kent, Robert E. 2002b. The IFF Approach to Semantic Integration. Presentation at the Boeing Mini-Workshop on Semantic Integration, 7 November 2002.
Kent, Robert E. 2003. The IFF Foundation for Ontological Knowledge Organization. In: Knowledge Organization and Classification in International Information Retrieval. Cataloging and Classification Quarterly. The Haworth Press Inc., Binghamton, New York.
Mac Lane, Saunders. 1971. Categories
for the Working Mathematician, New
York/Heidelberg/Berlin: Springer-Verlag. New edition
(1998).