Author: Thomas Gruber
Version: 3
Copyright (c) 1992 Thomas R. Gruber

This file defines an ontology for representing bibliographic data, such as
those used in reference lists and document index databases.  The objective of
this ontology is to define the concepts and relationships that underlie a
family of databases and tools in the domain of bibliographies.  Such a
conceptualization is intended to help with automatic translation among
existing databases, to enable the development of reference-formatting styles
that are independent of database or tool, and to support remote services
such as bibliography database search and reference-list generation.

An ontology can be partitioned into theories.  This file contains the
BIBLIOGRAPHIC-DATA theory, which establishes the basic terminology.
Child theories that include (specialize) the bibliographic-data ontology
will describe the constraints of specific bibliographic databases and tools.

Basic ontological commitments:

A bibliography is made up of references.  A REFERENCE describes the
information needed to identify and retrieve a publication.  A publication is
associated with a DOCUMENT of some sort (e.g., a book or journal).  In some
cases there are several publications per document (e.g., papers in an edited
collection).  Thus documents are distinguished from references.  Documents
are created by AUTHOR s, which are PEOPLE or other agents (e.g.,
ORGANIZATION ).  They are published by PUBLISHER s or other organizations.

A very simple ontology of time is included.  A TIMEPOINT is a specification
of a single point in historical time.  CALENDAR-DATE is a timepoint at the
resolution of days; that is, the day, month, and year are known.  A
CALENDAR-YEAR is a timepoint at the resolution of years.  The publication
date of a DOCUMENT is some kind of timepoint; for many publications only
the year is known.  Events such as a CONFERENCE also occur on dates specified
with timepoints.

All documents have titles.  TITLEs are names (strings of characters), as are
AGENT-NAME s, CITY-ADDRESS es, and other data types that are used as
identifiers and are not further destructured.  The class called BIBLIO-NAME
is a place holder for these atomic identifiers.  The class BIBLIO-NL-TEXT is
for strings of characters meant for human reading, rather than as an

The most interesting ontological commitment is the distinction between the
data fields in a reference and the facts about documents.  Facts are stated
as relationships over and properties of explicitly-represented objects.  For
example, some facts are about publishers: the publisher name, the city with
which the publisher is associated, and the year of (latest) publication.  In
a document, the DOC.PUBLISHER is an ORGANIZATION.  In a REFERENCE, the
REF.PUBLISHER is the PUBLISHER.NAME of the publisher, and the REF.ADDRESS is
the PUBLISHER.ADDRESS of the document's publisher.  The REF.YEAR of the
reference is a number, which is the TIMEPOINT.YEAR of the
DOC.PUBLICATION-DATE (a timepoint) of the document associated with a
reference.  Thus, in a reference -- the entity we are trying to share -- many
of the facts have been mapped onto these atomic data types such as name
strings, title strings, and numbers.  In a document, some of the meaning of
these data types can be stated as logical constraints.  This is in the spirit
of the Cyc project, which aims to provide the background knowledge behind the
narrow, brittle representations of expert systems and conventional databases.

This distinction between data in references and facts in other parts of the
ontology is there to support the interoperability of tools that commit to
this ontology, and the integration of this ontology and associated databases
with other ontologies and databases.  Part of the incompatibility between
bibliography databases and tools is due to different encodings and
presentations of the same information.  For example, one database might
encode a date as a string, another as a structured record of integer fields.
Their ontological commitments might be the same -- they might both support
years and months for a magazine article reference -- but their encodings mask
their conceptual agreement.  Similarly, different bibliography formatting
styles might disagree on whether a publisher city is required for a given
reference type, but they both agree that the city is a function of the
publisher (not a name for it found in some reference field).  Explicitly
representing agents (authors), organizations (publishers), events
(conferences), and time (publication dates) as objects in the
conceptualization allows one to write knowledge-full constraints about how
the data fields are related.  Capturing these constraints is part of good
database design, because it reduces redundancy and anticipates integration
with other databases.  For example, associating author and publisher names
(which are all that appear in references) with independently defined agents
ensures that these agents will be named consistently in the references and
facilitates the importation of data on authors and publishers from other

This ontology is a set of definitions of classes, relations, and functions.
It is represented in Ontolingua forms, which use KIF as the formal language
and English documentation strings to describe meanings that we haven't
formalized.  We are using a slightly new-and-improved syntax for Ontolingua,
in which the result variable of a function resides next to the argument list.
Also, some new second-order relations are introduced (HAVE-SAME-VALUES,
These are defined in an ontology called slot-constraint-sugar, and ontolingua
turns sentences in these forms into their canonical forms using the 
frame ontology vocabulary (value-cardinality, value-type, etc.).

The definitions are organized in a mildly bottom-up order, as follows:

 1. Introduction
 2. Generic Data Classes: biblio-name, biblio-NL-text, title, keyword
 3. Agents and Events: persons, organizations, publishers, conferences
 4. Dates and units of time
 5. Documents
   5.1 The document class and slots on it
   5.2 Document types (subclasses): books, periodicals, theses, reports, etc.
 6. References
   6.1 The reference class and slots on it
   6.2 Reference types (subclasses): book-ref, article-ref, thesis-ref, etc.
   6.3 Constraints used frequently to define reference types.
 7. Acknowledgments

;;; ----------------------------------------------------------------------
;;; 1. Introduction

;;; First we need to establish the package in which this is to be read.
;;; Ontolingua-user is a good package to write ontologies.  It inherits the
;;; exported symbols from the KIF and Ontolingua packages, which gives the
;;; user use of all the symbols defined in the KIF ontology (e.g., AND, OR,
;;; SETOF, =>) and Frame-ontology (e.g., VALUE-TYPE, HAS-ONE,

(in-package "ONTOLINGUA-USER")

;;; DEFINE-THEORY is analogous to DEFPACKAGE.

;;; All ontologies need to be in one or more theories.  Here we define a
;;; theory that includes the frame ontology and an ontology called
;;; slot-constraint-sugar that provides mnemonic names for common
;;; slot constraints (e.g., has-one means value-cardinality = 1).

(define-theory BIBLIOGRAPHIC-DATA (frame-ontology slot-constraint-sugar)
   "The bibliographic-data ontology defines the terms used
for describing bibliographic references.  This theory defines
the basic class for reference objects and the types (classes) for
the data objects that appear in references, such as authors and titles.
Specific databases will use schemata that associate references with
various combinations of data objects, usually as fields in a record.
This ontology is intended to provide the basic types from which
a specific database schema might be defined."
   :issues ((:copyright "Copyright (c) 1992 Thomas R. Gruber")))

;;; DEFINE-THEORY only defines the theory, it doesn't make it the ``current
;;; theory''.  The following form does just that.  IN-THEORY is analogous to
;;; IN-PACKAGE.  The rest of the ontolingua forms in this file are
;;; interpreted with respect to the BIBLIOGRAPHIC-DATA theory.


;;; ----------------------------------------------------------------------
;;; 2. Generic Data Classes: biblio-name, biblio-NL-text, title, keyword

;;; Ontologies will commonly have a top-level class such as the following.
;;; They are more for organization rather than meaning, but are useful for
;;; assimilating a small ontology into a more comprehensive ontology.

(define-class BIBLIO-THING (?x)
  "Biblio-thing is the root of the bibliographic ontology.
It is the superclass-of anything that would otherwise be a 
a completely standalone primitive (i.e., a root of the class

  :def (individual-thing ?x)  ; the most general class

  :axiom-def (subclass-partition
               (setof agent
  :issues ("Removed biblio-text because it is a subclass-of STRING."
	   "Added CONFERENCE because it is a subclass-of biblio-thing
            and it is disjoint from these other primitive classes."

(define-class BIBLIO-TEXT (?string)
  "The most general class of undifferentiated text objects."

  :def (string ?string)

  :issues (("Why not make biblio-name and biblio-nl-text be disjoint
             subclasses of biblio-text?"
            "There may be valid names that are exactly the same strings
             as NL texts, so it would be overconstraining to require
             these two classes to be disjoint.  The distinction between
             names and NL texts is in their intended use, rather than
             their forms. This happens because we don't represent what
             the strings denote.  If we did, then we could offer a
             formal basis for distinguishing between these two classes
             of text strings.")))

(define-class BIBLIO-NAME (?string)
  "A name of something in the bibliographic-data ontology.
Names are distinguished from strings in general because
they may be treated specially in some databases; for example,
there may be uniqueness assumptions."

  :def (biblio-text ?string)
  :issues (("Why isn't there a subclass-partition for this, since
             classes like TITLE, KEYWORD, and CITY-ADDRESS are
	    "Because these are all strings that may be lexically
             equal.  If they were concepts then they would be 
             mutually exclusive.")))

(define-class BIBLIO-NL-TEXT (?string)
  "A string of natural language text mentioned in some bibliographic
reference.  Texts are distinguished from strings in general because
they may be treated specially in some databases, or presented as
free-flowing text to a human reader.  BIBLIO-NL-TEXT's are used for
different purposes than biblio-names.  BIBLIO-NL-TEXT's are for things like
notes and abstracts; BIBLIO-NAME's are meant to identify some object or
some property."

  :def (biblio-text ?string)
  :issues ((:see-also BIBLIO-NAME)))

(define-class TITLE (?x)
  "A title is a string naming a publication, a document, or 
something analogous.  Title strings are distinct from strings naming
agents (books can't talk)."

  :def (biblio-name ?x))

(define-class KEYWORD (?keyword)
  "A keyword is a string used as an index."
  :def (biblio-name ?keyword))

(define-class CITY-ADDRESS (?name)
  "A city-address is a string that identifies a city
somewhere in the world.  We distinguish it from other
names to facilitate integrating it with ontologies that
include representations for locations and alternative ways
of identifying places."

  :def (biblio-name ?name))

;;; ----------------------------------------------------------------------
;;; 3. Agents and Events: persons, organizations, publishers, conferences
;;;    People, organizations, and events involved in creating and
;;;    publishing documents

(define-class AGENT (?x)
  "An agent is something or someone that can act on its
own and produce changes in the world.  There is more to
agenthood than that, but for this ontology that is all
that matters."

  :def (and (biblio-thing ?x)
            (has-one ?x agent.name))

  :axiom-def (subclass-partition
               (setof person

  :issues ("could be merged with more meaningful definitions
            of agenthood in larger ontologies."))

(define-function AGENT.NAME (?agent) :-> ?name
  "Function from an agent to the name by which it goes.  If an agent
has more than one complete name (not parts of the name, such as first
and last name), then the agent.name is the name used to identify that
agent in the shared world.  If the shared world is represented in a
database, then the name would be a `key field' for the agent.  Other
names can be related to the agent by some other relations."

  :def (and (agent ?agent)
            (biblio-name ?name)))

(define-class AGENT-NAME (?name)
  "A string that is the name of some agent."

  :axiom-def (exact-range AGENT.NAME AGENT-NAME)
  :constraints (biblio-name ?name)
  :issues ("Added the constraint that agent-name is a subclass-of
biblio-name to be clear.  This could be inferred from the definition
of the AGENT.NAME function, and a RANGE of AGENT.NAME is BIBLIO-NAME,
and since the EXACT-RANGE of a BINARY-RELATION is a SUBCLASS-OF any of its
ranges, then it follows that AGENT-NAME is a SUBCLASS-OF BIBLIO-NAME."))

(define-class PERSON (?x)
  "Human person"

  :def (agent ?x))

(define-class AUTHOR (?x)
  "An author is an agent who writes things.  An author must have a
name, which is its real name as an agent.  The name as author
may or may not be the agent's name, but usually is."

  :def (and (agent ?x)
            (has-one ?x agent.name))

  ;; ontolingua doesn't handle defaults anymore
  ;;  :default-constraints (same-values ?x author.name agent.name)

  :issues ((:see-also AUTHOR.NAME)))

(define-relation AUTHOR.NAME  (?author ?name)
  "An author name is the name of an agent used to identify
it as an author.  It is not necessarily unique; authors may
go by pseudonyms.  A particular author.name of an author must 
be either the author's real name (i.e., her agent.name), or else
it is one of her pennames."

  :def (and (author ?author)
            (biblio-name ?name)
            (or (agent.name ?author ?name)
		(penname ?author ?name))))

(define-relation PENNAME (?author ?name)
  "An author's pseudonym [Webster].  An author may use several
pseudonyms.  Which name is a function of the document.
The penname of an author cannot be his or her real name [denoted
by the function agent.name]; it must be some made-up name."

  :def (and (author ?author)
	    (biblio-name ?name)
	    (not (agent.name ?author ?name)))

  :issues ((:see-also AUTHOR.NAME DOC.AUTHOR-NAME)))

;;; note the naming convention: CLASS.SLOT versus HYPHENATED-CLASS

(define-class AUTHOR-NAME (?name)
  "A string that is used as the author.name of some author.
Often databases of author names are kept separately from
databases of people or documents."

  :axiom-def (exact-range AUTHOR.NAME AUTHOR-NAME)
  :constraints (biblio-name ?name)
  :issues ("see the discussion of AGENT-NAME."))

(define-class ORGANIZATION (?x)
  "An organization is a corporate or similar institution, distinguished
from persons and other agents."

  :def (agent ?x))

(define-function ORGANIZATION.NAME (?organization) :-> ?name
  "The name by which organizations go by.  One name per place."

  :def (and (organization ?organization)
            (biblio-name ?name)
            (agent.name ?organization ?name))) ; specialization of agent.name

(define-class PUBLISHER (?x)
  "A publisher is an organization that publishes.  
The owner of a publishing company may be a person, 
and the name of the publisher may be the name of a person."

  :def (and (organization ?x)
            (has-one ?x PUBLISHER.NAME)))

(define-function PUBLISHER.NAME (?publisher) :-> ?name
  "The name of a publisher; one per publisher."

  :def (and (publisher ?publisher)
            (biblio-name ?name)
            (organization.name ?publisher ?name)))

(define-class PUBLISHER-NAME (?name)
  "A name of some publisher"
  :axiom-def (exact-range publisher.name PUBLISHER-NAME)
  :constraints (biblio-name ?name)
  :issues ("see the discussion of AGENT-NAME."))

(define-relation PUBLISHER.ADDRESS (?publisher ?city)
  "The publisher.address is the name of a city with which a publisher
is associated for document ordering purposes.  There may be several
cities associated with a publisher.  If the city is well-known,
then just its name is given; otherwise its name and state and sometimes 
country are given as the location."

  :def (and (publisher ?publisher)
            (city-address ?city)))

(define-class UNIVERSITY (?x)
  "A university is an institute of higher learning that offers a
graduate research program.  Of importance here is the fact that
universities sponsor the publication of dissertations.  Any organization
that has been accredited to grant graduate degrees and is recognized
in libraries to be a publisher of dissertations can be called a
university.  Some places that call themselves colleges fall under this

  :def (organization ?x)
  :issues (("Randy Davis: 
            Dartmouth College (and a famous Supreme Court case from 
            the mid 1800's) agree that the institution is a college, 
            not a University, yet it has a grad research program, 
            pubishes dissertations, etc."
           "Tom Gruber:
            In that case, maybe the definition of a university in this
            ontology should be something that publishes dissertations.")))

(define-class CONFERENCE (?x)
  "A conference is a big meeting where people wear badges, sit through
boring talks, and drink coffee in the halls."

  :def (and (biblio-thing ?x)   ;should be an event of some kind
            (has-one-of-type ?x conf.name biblio-name)
            (has-one-of-type ?x conf.organization organization)
            (HAS-one-of-type ?x conf.date calendar-date)
            (value-type ?x conf.address city-address)
            (can-have-one ?x conf.address)))

(define-function CONF.NAME (?conference) :-> ?name
  "Conference name."
   :def (and (conference ?conference)
	     (biblio-name ?name)))

(define-function CONF.DATE (?conference) :-> ?date
  "Conference date."
   :def (and (conference ?conference)
	     (calendar-date ?date)))

(define-function CONF.ADDRESS (?conference) :-> ?address
  "Conference address."
   :def (and (conference ?conference)
	     (city-address ?address)))

(define-function CONF.ORGANIZATION (?conference) :-> ?name
  "Conference name."
   :def (and (conference ?conference)
	     (organization ?name)))

;;; ----------------------------------------------------------------------
;;; 4. Dates and units of time
;;;    An incomplete ontology of time.  Should be merged with a more 
;;;    general-purpose version, such as those used for scheduling.

(define-class TIMEPOINT (?t)
  "A timepoint is a point in real, historical time (on earth).  
It is independent of observer and context.  A timepoint is not
a measurement of time, nor is it a specification of time.
It is the point in time. The timepoints at which events occur can 
be known with various degrees of precision and approximation,
but conceptually timepoints are point-like and not interval-like.
That is, it doesn't make sense to talk about what happens during
a timepoint, or how long the timepoint lasts."

  :def (biblio-thing ?t))

(define-class CALENDAR-YEAR (?t)
  "a specification of a point in absolute calendar time, at the 
resolution of one year."

  :def (and (timepoint ?t)
            (has-one ?t timepoint.year)))

(define-class CALENDAR-DATE (?t)
  "a specification of a point in absolute calendar time, at the 
resolution of one day."

  :def (and (timepoint ?t)
            (has-one ?t timepoint.day)
            (has-one ?t timepoint.month)
            (has-one ?t timepoint.year)))

(define-class UNIVERSAL-TIME-SPEC (?t)
   "a specification of a point in real-world, historical, wall-clock time,
independent of timezone and with one second resolution."
  :def (and (timepoint ?t)
             (has-one ?t timepoint.seconds)
             (has-one ?t timepoint.minutes)
             (has-one ?t timepoint.day)
             (has-one ?t timepoint.month)
             (has-one ?t timepoint.year)))

(define-function TIMEPOINT.YEAR (?timepoint) :-> ?year
  "function from time points to integers representing the year
component of the time specification.  The integer represents
the number of years A.D., e.g., 1992."

  :def (and (timepoint ?timepoint)
            (year-number ?year)))

(define-class YEAR-NUMBER (?year)
  "A year expressed as the number of years A.D."

  :def (integer ?year))

(define-function TIMEPOINT.MONTH (?timepoint) :-> ?month
  "function from time points to months, representing the month component of
the time specification.  Months are not integers, but named objects."

  :def (and (timepoint ?timepoint)
            (month-name ?month)))

(define-class MONTH-NAME (?month)
  "The months of the year, specified as an extensionally-defined
 (i.e., enumerated) set of objects, in English.
  Instances of this class of months are not symbols, they are months
that may be denoted by object constants."

  :iff-def (member ?month
                   (setof january february march april may june july
                          august september october november december))

  :issues (("Why not specify them as an ordered sequence?"
            "The class only defines the set of months.  Their order would
             be given by an ordering predicate: a binary relation.")))

(define-instance JANUARY (month-name))
(define-instance FEBRUARY (month-name))
(define-instance MARCH (month-name))
(define-instance APRIL (month-name))
(define-instance MAY (month-name))
(define-instance JUNE (month-name))
(define-instance JULY (month-name))
(define-instance AUGUST (month-name))
(define-instance SEPTEMBER (month-name))
(define-instance OCTOBER (month-name))
(define-instance NOVEMBER (month-name))
(define-instance DECEMBER (month-name))

(define-class DAY-NUMBER (?day-of-month)
  "integer representing day of month."
  :iff-def (and (integer ?day-of-month)
		(=< 0 ?day-of-month)
		(=< ?day-of-month 31)))

(define-function TIMEPOINT.DAY (?timepoint) :-> ?day-of-month
  "function from time points to integers representing the day
component of the time specification."

  :def (and (timepoint ?timepoint)
	    (day-number ?day-of-month)))

(define-function TIMEPOINT.MINUTES (?timepoint) :-> ?minutes
  "function from time points to integers representing the minutes
component of the time specification."

  :def (and (timepoint ?timepoint)
            (integer ?minutes)
            (=< 0 ?minutes)
            (=< ?minutes 59)))

(define-function TIMEPOINT.SECONDS (?timepoint) :-> ?seconds
  "function from time points to integers representing the seconds component of
the time specification.  This is not the internal representation of the
universal time, (e.g., number seconds since some historical date).
Timepoint.seconds is the number of seconds past the minute, hour, day, etc.
specified in the other components of the timepoint."

  :def (and (timepoint ?timepoint)
            (integer ?seconds)
            (=< 0 ?seconds)
            (=< ?seconds 59)))

;;; ----------------------------------------------------------------------
;;; 5. Documents
;;;   5.1 The document class and slots on it.

(define-class DOCUMENT (?x)
  "A document is something created by author(s) that may be viewed,
listened to, etc., by some audience.  A document persists in material
form (e.g., a concert or dramatic performance is not a document).
Documents typically reside in libraries."

  :def (and (biblio-thing ?x)
            (has-one ?x doc.title))

  :axiom-def (subclass-partition
               (setof book

(define-function DOC.TITLE (?doc) :-> ?title
  "The title of a document.  Not necessarily the title of a work
published in the document."

  :def (and (document ?doc)
            (title ?title)))

(define-relation DOC.AUTHOR (?doc ?author)
  "The creator(s) of a document.  Not necessarily the author of a
work published in the document, but often so.  The author is a real
agent, not a name of an agent."

  :def (and (document ?doc)
            (author ?author)))

(define-function DOC.AUTHOR.NAME (?doc ?author) :-> ?name
  "The name used by an author is a function of the document and the author."
  :def (and (document ?doc)
            (author ?author)
            (author-name ?name)))
(define-relation DOC.AUTHOR-NAME (?doc ?name)
  "Each author of a document is identified by an author-name.
Although an author can have several pennames, the author only
gets to use one of them for a particular document."
  :def (and (document ?doc)
            (author-name ?name)
            (exists ?author
               (and (doc.author ?doc ?author)
                    (doc.author.name ?doc ?author ?name)))))

(define-function DOC.PUBLICATION-DATE (?doc) :-> ?year
  "The publication date of a document.  If the document isn't
formally published, e.g., a painting, then it is the year of creation.
The date is a timepoint for which at least the year is known.
In some cases, the month and day are also known."

  :def (and (document ?doc)
            (calendar-year ?year))

  :issues ("Calendar-date is a subclass-of calendar-year, because it
            requires the same constraint (that a year be known) plus
            a few more (that a month and day be known).  This means
            that if we require publication dates to be calendar-years,
            then we also allow more precise timepoint specifications
            as well.  Thus, documents for which a month field is needed
            can get the month from the publication date."))

(define-function DOC.PUBLISHER (?doc) :-> ?publisher
  "The publisher of a document, if there is one.  This is the 
publisher, not its name."

  :def (and (document ?doc)
            (publisher ?publisher)))

(define-function DOC.INSTITUTION (?doc) :-> ?organization
  "The institution that publishes a document, like a University or
trade association."

  :def (and (or (book ?doc)
		(proceedings ?doc))
	    (organization ?organization)))

(define-function DOC.CONFERENCE (?doc) :-> ?conference
  "The conference associated with a proceedings."
  :def (and (proceedings ?doc)
	    (conference ?conference)))

(define-relation DOC.EDITOR (?doc ?editor)
  "Named primary editors of a document."

  :def (and
         (or (book ?doc)
             (proceedings ?doc))
         (person ?editor)))

(define-relation DOC.SERIES-EDITOR (?doc ?editor)
  "Series editors of a document."

  :def (and
         (or (book ?doc)
             (proceedings ?doc))
         (person ?editor)))

(define-function DOC.SERIES-TITLE (?doc) :-> ?title
  "Series title of a document."

  :def (and
         (or (book ?doc)
             (proceedings ?doc))
         (title ?title)))

(define-relation DOC.TRANSLATOR (?doc ?translator)
  "Named primary editors of a document."

  :def (and
         (or (book ?doc)
             (proceedings ?doc))
         (person ?translator)))

(define-function DOC.EDITION (?doc) :-> ?nth
 "Refers to the nth edition of a document."

  :def (and
         (or (book ?doc)
             (proceedings ?doc)
             (cartographic-map ?doc))
         (natural ?nth)))

(define-function DOC.NUMBER-OF-PAGES (?doc) :-> ?n
 "Number of pages contained a document.  Not the page numbers of an article"

  :def (and (document ?doc)
            (natural ?n)))

;;; ----------------------------------------------------------------------
;;;   5.2 Document types (subclasses): books, periodicals, theses,
;;;       proceedings, reports, maps, manuals, etc.

(define-class BOOK (?x)
  "pages in a bound cover. You can't judge it by its cover."
  :def (and (document ?x)
            (has-some ?x doc.author)
            (has-one ?x doc.title)
            (has-one ?x doc.publication-date)
            (has-one ?x doc.publisher)

(define-class EDITED-BOOK (?x)
  "An edited book is a book whose authors are known as editors."
  :iff-def (and (book ?x)
                (has-some ?x doc.editor)
                (same-values ?x doc.editor doc.author)))

  "A periodical-publication is published regularly, such as once
every week.  Strictly speaking, the noun ``periodical'' is used
by librarians to refer to things published at intervals of greater
than a day.  We use the phase periodical-publication to include
newspapers and other daily publications, since they share many
bibliographic features."

  :def (document ?x)
  :axiom-def (subclass-partition
               (setof journal

(define-class JOURNAL (?x)
  "A journal is an archival periodical publication.  Note that a
journal is not the same as a journal article or a reference to an
article.  A journal is a document; a particular issue of a journal may
contain several articles."

  :def (periodical-publication ?x))

(define-class MAGAZINE (?x)
  "A magazine is a periodical publication that is considered to be of
more general interest than a journal."

  :def (periodical-publication ?x))

(define-class NEWSPAPER (?x)
  "A newspaper is a periodical publication that may be published as
frequently as once a day."

  :def (periodical-publication ?x))

(define-class PROCEEDINGS (?x)
  "The published proceedings of a conference, workshop, or similar
meeting.  If the proceedings appear as an edited book, the document
is an edited book with a title other than ``proceedings of...''
Proceedings may have editors, however."

  :def (and (document ?x)
            (has-one-of-type ?x doc.conference conference)
            (same-values ?x doc.title
                              (compose conf.name doc.conference))
            (same-values ?x doc.publication-date
                              (compose conf.date doc.conference)))

  :issues ("We are assuming that the title of the proceedings is
            the same as the name of the conferences.  This may be

(define-class THESIS (?x)
  "An official report on a bout of graduate work for which one receives a
degree, published by the university.  Never mind that some fields make a big
deal about the difference between dissertations and theses.  From the
bibliographic perspective, they are both of the same family."

  :def (and (document ?x)
            (has-one ?x doc.author)
            (has-one ?x doc.title)
            (has-one ?x doc.publication-date)
            (has-one-of-type ?x thesis.university university))

  :axiom-def (exhaustive-subclass-partition
               (setof masters-thesis

  :issues (("What about theses published as technical reports?"
            "If it is cited as a TR, it is a TR."
            "One can imagine adding a cross-reference field to
             references that points to associated documents or
             other references.")))

(define-class MASTERS-THESIS (?x)
  "M.S. thesis document."

  :def (thesis ?x))

(define-class DOCTORAL-THESIS (?x)
  "Ph.D. thesis document"

  :def (thesis ?x))

(define-function thesis.university (?thesis) :-> ?university
  :def (and (thesis ?thesis)
	    (university ?university)))

(define-class TECHNICAL-REPORT (?x)
  "A technical report is a paper published by some research

  :def (and (document ?x)
            (has-some ?x doc.author)
            (has-one ?x doc.title)
            (has-one ?x doc.publication-date)
            (has-one-of-type ?x doc.institution organization)))

  "A miscellaneous category of documents that are infrequently found
in bibliographic references."

  :def (and (document ?x)
            (has-one ?x doc.title))

  :axiom-def (subclass-partition
               (setof technical-manual

(define-class TECHNICAL-MANUAL (?x)
  "The doc.author is the technical writer."

  :def (miscellaneous-publication ?x))

(define-class COMPUTER-PROGRAM (?x)
  "The doc.author is the programmer."

  :def (miscellaneous-publication ?x))

(define-class ARTWORK (?x)
  "The doc.author is the artist."

  :def (and (has-one ?x doc.author)
            (miscellaneous-publication ?x)))

(define-class CARTOGRAPHIC-MAP (?x)
  "The doc.author is the cartographer."

  :def (miscellaneous-publication ?x))

(define-class MULTIMEDIA-DOCUMENT (?x)
  "A multimedia document is some identifiable communique in a
modality such as audio, video, animation, etc.
The document may exist in digital form in a library that is accessed
by electronic means."

  :def (miscellaneous-publication ?x))

;;; ----------------------------------------------------------------------
;;;  6. References
;;;    6.1 The reference class and slots on it

(define-class REFERENCE (?ref)
  "A bibliographic reference is a description of some publication that
uniquely identifies it, providing the information needed to retrieve the
associated document.  A reference is distinguished from a citation, which occurs
in the body of a document and points to a reference.  Note that references
are distinguished from documents as well.
    The information associated with a reference is contained in data fields,
which are binary relations (often unary functions).
   A reference should at least contain information about the author, title,
and year.  (Since there are exceptions, that constraint is associated with a
specialization of this class.) ."

  :def (biblio-thing ?ref)
  :axiom-def (exhaustive-subclass-partition
               (setof publication-reference

;;; Fields of references are represented as binary relations (slots).
;;; If they are single-valued, they are defined as unary functions.
;;; (Recall that in KIF, unary functions are a subclass of binary relations.)

(define-function REF.DOCUMENT (?ref) :-> ?document
  "Function from references to associated documents. 
Is only defined on publication-references, since by definition they are the
references associated with documents."

  :def (and (publication-reference ?ref)
            (document ?document)))

(define-relation REF.AUTHOR (?ref ?author-name)
  "Relation between a reference and the name(s) of the
creator(s) of the publication."

  :def (and (reference ?ref)
            (author-name ?author-name)))

(define-function REF.TITLE (?ref) :-> ?title
  "Most general relation between a reference and the PRIMARY title 
of a publication.  The primary title goes by various names depending 
on the reference type."

  :def (and (reference ?ref)
            (title ?title)))

(define-function REF.BOOKTITLE (?ref) :-> ?title
  "The title of the document that is a collection in which a reference
appears.  For example, the ref.title of a paper in an edited collection
would be the name of the paper, and the ref.booktitle would be the name
of the edited book."

  :def (and (reference ?ref)
            (title ?title)))

(define-function REF.YEAR (?ref) :-> ?year
  "The year field is a function from a reference to the year 
in which the publication was published."

  :def (and (reference ?ref)
            (year-number ?year)))

(define-function REF.PERIODICAL (?ref) :-> ?journal-title
  "Most general relation between a reference and a journal."

  :def (and (reference ?ref)
            (title ?journal-title)))

(define-function REF.VOLUME (?ref) :-> ?number
  "in a reference, the volume number of a journal or magazine
in which an article occurs."

  :def (and
         ;; domain is a subclass of all references
           (book-reference ?ref)
           (book-section-reference ?ref)
           (article-reference ?ref))

         ;; range is natural numbers
         (natural ?number)))

(define-function REF.ISSUE (?ref) :-> ?issue-number
  "In a reference, the issue number of a journal or magazine
in which an article occurs."

  :def (and (article-reference ?ref)
            (natural ?issue-number)))

(define-function REF.REPORT-NUMBER (?ref) :-> ?identifier
  "An alphanumeric identifier that identifies a technical report within a
series sponsored by the publishing institution.  For example, STAN-CS-68-118
is the 118th report number of a report written at Stanford in the computer
science department in 1968."

  :def (and (technical-report-reference ?ref)
            (biblio-name ?identifier)))

(define-function REF.PAGES (?ref) :-> ?page-range
  "In a reference, the pages of an article or analogous subdocument in which a
publication resides.  Specified as a sequence of two integers."

  :def (and
         ;; domain is the union of these ref types:
         (or (book-section-reference ?ref)
             (article-reference ?ref)
             (proceedings-paper-reference ?ref))

         ;; range is a list of (starting ending) pages
         (list ?page-range)
         (integer (first ?page-range))
         (integer (first (rest ?page-range)))))

(define-function REF.MONTH (?ref) :-> ?month
  "In a reference, the month in which a publication is published.
Useful for magazines, conference proceedings, and technical reports."

  :def (and (or (article-reference ?ref)
                (technical-report ?ref))
            (month-name ?month)))

(define-function REF.DAY (?ref) :-> ?day
  "In a reference, the day of the month in which a publication is published.
Useful for conference proceedings, personal communications."

  :def (and (or (article-reference ?ref)
                (personal-communication-reference ?ref))
            (day-number ?day)))

(define-relation REF.NOTES (?ref ?note-string)
  "In a reference, the notes field contains a set of strings that is used 
to describe all sorts of things."

  :def (and (reference ?ref)
            (biblio-NL-text ?note-string)))

(define-function REF.ABSTRACT (?ref) :-> ?abstract-string
  "In a reference, the abstract field contains a string of natural
language text that is used to describe all sorts of things."

  :def (and (reference ?ref)
            (biblio-NL-text ?abstract-string)))

(define-relation REF.KEYWORDS (?ref ?keyword)
  "Keywords associated with a reference."
  :def (and (reference ?ref)
            (keyword ?keyword)))

(define-relation REF.LABELS (?ref ?label)
  "Labels associated with a reference."
  :def (and (reference ?ref)
            (biblio-name ?label)))

(define-relation REF.EDITOR (?ref ?editor)
  "A reference's editor is the name of the document's editor."

  :axiom-def (= REF.EDITOR
             (compose agent.name doc.editor ref.document)))

(define-relation REF.SERIES-EDITOR (?ref ?editor)
  "A reference's series editor is the name of a series editor of 
the document."

  :axiom-def (= REF.SERIES-EDITOR 
             (compose agent.name doc.series-editor ref.document)))

(define-relation REF.TRANSLATOR (?ref ?translator)
  "A reference's translator is the name of the document's translator."

  :axiom-def (= REF.TRANSLATOR
             (compose agent.name doc.translator ref.document)))

(define-relation REF.SECONDARY-AUTHOR (?ref ?editor)
  "In a reference, the secondary author field usually names an editor
of some sort who was involved in the production of the work but who
was not a original author."

  :def (and (reference ?ref)
            (agent-name ?editor)))

(define-relation REF.TERTIARY-AUTHOR (?ref ?editor)
  "Teritiary author of a reference.  Beats me what this is."

  :def (and (reference ?ref)
            (agent-name ?editor)))

(define-relation REF.SECONDARY-TITLE (?ref ?title)
  "In a reference, the secondary title usually names the book or 
serial in which the publication is published."

  :def (and (reference ?ref)
            (title ?title)))

(define-relation REF.ADDRESS (?ref ?address)
  "The place (e.g., city) where a document is published.  Means
different things depending on the reference type."

  :def (and (reference ?ref)
            (city-address ?address)))

(define-function REF.ORGANIZATION (?ref) :-> ?address
 "The organization that publishes a referenced document.
May be inherited from a conference organization for proceedings."

  :def (and (reference ?ref)
            (organization ?address)))

(define-function REF.PUBLISHER (?ref) :-> ?publisher-name
  "The publisher field of a reference points to the publisher of 
the associated document."

  :def (and (reference ?ref)
            (publisher-name ?publisher-name)))

(define-function REF.NUMBER-OF-VOLUMES (?ref) :-> ?number
  "In a reference, the number of volumes in the associated document."

  :def (and (reference ?ref)
            (natural ?number)))

(define-function REF.EDITION (?ref) :-> ?nth
  "Refers to the nth edition of a document."

  :def (and (reference ?ref)
            (natural ?nth))

  ;; ref's edition is the document's edition
  :lambda-body (doc.edition (ref.document ?ref)))

(define-function REF.TYPE-OF-WORK (?ref) :-> ?name
  "An identifier of some specialization within the reference type.
For example, technical reports are labeled with types-of-work such as
``technical report'' and ``memo''.  Dissertations are specialized by the
level of the associated degree."

  :def (and (or (thesis-reference ?ref)
                (technical-report-reference ?ref)
                (misc-publication-reference ?ref))
            (biblio-name ?name)))

;;; ----------------------------------------------------------------------
;;;  Reference types

(define-class PUBLICATION-REFERENCE (?ref)
  "A reference associated with some kind of published document, where
publication and documenthood are interpreted broadly."

  :def (and (reference ?ref)
	    (has-one-of-type ?ref ref.document document)
            (has-one ?ref ref.title))
  :axiom-def (subclass-partition
               (setof book-reference

(define-class NON-PUBLICATION-REFERENCE (?ref)
  "A reference to something that just isn't a document."

  :def (and (reference ?ref)
            (cannot-have ?ref ref.document))
  :axiom-def (subclass-partition
               (setof personal-communication-reference

(define-class BOOK-REFERENCE (?ref)
  "A book reference.   Book references usually include complete publisher
information, and may have a series editor and title, edition, and translator.
A reference to a book gets many of its publication data from the book qua

  :def (and (publication-reference ?ref)
            (has-one-of-type ?ref ref.document book)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (book-publication-data-constraint ?ref) ;see-below
            (same-values ?ref ref.secondary-author ref.series-editor)
            (same-values ?ref ref.secondary-title doc.series-title)))

(define-class EDITED-BOOK-REFERENCE (?ref)
  "like a book-reference, except the document is an edited-book and
the author and editor are the same."

  :iff-def (and (book-reference ?ref)
                (has-one-of-type ?ref ref.document edited-book)
                (has-some ?ref ref.editor)
                (same-values ?ref ref.author ref.editor)))

(define-class BOOK-SECTION-REFERENCE (?ref)
  "A section of a book, like a chapter or a paper in an edited collection."

  :def (and (publication-reference ?ref)
            (has-one-of-type ?ref ref.document edited-book)
            (has-some ?ref ref.author)
            (has-some ?ref ref.editor)
            (has-one ?ref ref.booktitle)
            (same-values ?ref ref.booktitle
                              (compose doc.title ref.document))
            (book-publication-data-constraint ?ref)
            (same-values ?ref ref.secondary-author ref.editor)
            (same-values ?ref ref.tertiary-author ref.series-editor)))

(define-class ARTICLE-REFERENCE (?ref)
  "An article is a piece published in a journal, magazine, or newspaper."

  :def (and (publication-reference ?ref)
            (value-type ?ref ref.document periodical-publication)
            (has-some ?ref ref.author)
            (has-one ?ref ref.title)
            (has-one ?ref ref.year)
            (has-one ?ref ref.periodical)
            (same-values ?ref ref.periodical
                              (compose doc.title ref.document))
            (same-values ?ref ref.secondary-title

(define-class JOURNAL-ARTICLE-REFERENCE (?ref)
  "A reference to article in a journal must give information sufficient to
find the issue containing the article."

  :def (and (article-reference ?ref)
            (value-type ?ref ref.document journal)
            (cannot-have ?ref ref.month)  ; unlike other articles

  "A reference to an article in a magazine is essentially the same as a
journal article reference.  Some formatting styles need the distinction.
Magazine article references sometimes include the month instead of the
volume/issue numbers."

  :def (and (article-reference ?ref)
            (value-type ?ref ref.document magazine)
            (has-one ?ref ref.magazine-name)
            (same-values ?ref ref.magazine-name
(define-function REF.MAGAZINE-NAME (?ref) :-> ?name 
  "Field for name of the magazine in a magazine article reference."
  :def (and (magazine-article-reference ?ref)
	    (title ?name)))

  "A newspaper article reference is like a magazine article reference"

  :def (and (article-reference ?ref)
            (value-type ?ref ref.document newspaper)
            (has-one ?ref ref.newspaper-name)
            (same-values ?ref ref.magazine-name ref.periodical)
            (has-one ?ref ref.month)
            (has-one ?ref ref.day)
            (value-type ?ref ref.address city-address)))

(define-function REF.NEWSPAPER-NAME (?ref) :-> ?name 
  "Field for name of a newspaper in a newspaper article reference."
  :def (and (newspaper-article-reference ?ref)
	    (title ?name)))

  "An article appearing in the published proceedings of some conference or

  :def (and (publication-reference ?ref)
            (value-type ?ref ref.document proceedings)
            (has-some ?ref ref.author)
            (has-one ?ref ref.title)
            (inherits-year-from-document ?ref)
            (has-one ?ref ref.booktitle)
            (same-values ?ref ref.booktitle
                              (compose doc.title ref.document))
            (same-values ?ref ref.secondary-title ref.booktitle)
            (same-values ?ref ref.secondary-author ref.editor)

            (same-values ?ref ref.organization
                              (compose conf.organization
                                        doc.conference ref.document))
            (same-values ?ref ref.address
                              (compose conf.address
                                        doc.conference ref.document))
            (same-values ?ref ref.month
                              (compose timepoint.month
                                        doc.publication-date ref.document))
            (same-values ?ref ref.day
                              (compose timepoint.day
                                        doc.publication-date ref.document))))

(define-class THESIS-REFERENCE (?ref)
  "A reference to a master's or doctoral thesis."

  :def (and (publication-reference ?Ref)
            (value-type ?ref ref.document thesis)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (inherits-year-from-document ?ref)
            (has-one ?ref ref.publisher)
            (same-values ?ref ref.publisher
                             (compose organization.name thesis.university)))
  :axiom-def (subclass-partition
               (setof doctoral-thesis-reference

(define-class DOCTORAL-THESIS-REFERENCE (?ref)

  :def (and (thesis-reference ?ref)
            (value-type ?ref ref.document doctoral-thesis)
            (has-value ?ref ref.type-of-work "Doctoral Thesis")))

(define-class MASTERS-THESIS-REFERENCE (?ref)

  :def (and (thesis-reference ?ref)
            (value-type ?ref ref.document masters-thesis)
            (has-value ?ref ref.type-of-work "Masters Thesis")))


  :def (and (publication-reference ?ref)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (inherits-year-from-document ?ref)
            (has-one ?ref ref.publisher)
            (same-values ?ref ref.publisher
                             (compose organization.name doc.institution))))


  :def (publication-reference ?ref)
  :axiom-def (subclass-partition
               (setof technical-manual-reference

  "A reference to a manual that may accompany a product but is otherwise

  :def (and (misc-publication-reference ?ref)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (inherits-year-from-document ?ref)))

  "A reference to a computer program.  The ref.title is the name of the
program.  The author is the programmer."

  :def (and (misc-publication-reference ?ref)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)))

  "A reference to a map created by a cartographer."

  :def (and (misc-publication-reference ?ref)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (inherits-year-from-document ?ref)))

(define-class ARTWORK-REFERENCE (?ref)
  "A reference to a work of art that does not fit the other categories of
documents.  The author is the artist."

  :def (and (misc-publication-reference ?ref)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (inherits-year-from-document ?ref)))

  "A bibliographic reference to a multimedia document.
Who knows what conventions the future holds for these things."

  :def (and (misc-publication-reference ?ref)
            (inherits-author-from-document ?ref)
            (inherits-title-from-document ?ref)
            (inherits-year-from-document ?ref)))

  "A reference to a personal communication between the author of the paper in
which the bibliography appears and some other person.  The ref.author of the
reference is the person with whom the conversation was held."

  :def (and (non-publication-reference ?ref)
            (has-one ?ref ref.author)
            (has-one ?ref ref.year)
            (has-one ?ref ref.month)
            (has-one ?ref ref.day)))

  :def (non-publication-reference ?ref))
;;; ----------------------------------------------------------------------
;;;  6.3 Constraints used frequently to define reference types.

;;; Technically, the following are classes.  In intent, they are constraints
;;; over slot values of classes (thus, they are specializations of classes). 
;;; We use define-relation instead of define-class for such constraints, but 
;;; there is no logical distinction between the unary-relation qua class and
;;; qua constraint over class membership.

(define-relation INHERITS-AUTHOR-FROM-DOCUMENT (?ref)
  "When a reference is a one-to-one account of a document, then the author
in the reference (ref.author) is the name of the author of the document.
This relation captures this relationship."

  :iff-def (and (publication-reference ?ref)
                (same-values ?ref ref.author
                                  (compose doc.author-name ref.document))))

  "When a reference is a one-to-one account of a document, then the publisher
in the reference (ref.publisher) is the name of the publisher of the
document. This relation captures this relationship.  Inherits the 
publisher's address as well."

  :iff-def (and (publication-reference ?ref)
                (same-values ?ref ref.publisher
                               (compose publisher.name doc.publisher
                (same-values ?ref ref.address
                               (compose publisher.address
                                         doc.publisher ref.document))))

(define-relation INHERITS-YEAR-FROM-DOCUMENT (?ref)
  "When a reference is a one-to-one account of a document, then the year
in the reference (ref.year) is the year of publication of the document.
This relation captures this relationship."

  :iff-def (and (publication-reference ?ref)
                (same-values ?ref ref.year
                                  (compose timepoint.year

(define-relation INHERITS-TITLE-FROM-DOCUMENT (?ref)

  :iff-def (and (publication-reference ?ref)
                (same-values ?ref ref.title
                                  (compose doc.title ref.document))))

  "In references associated with books, the reference fields
for publication data such as publisher, place, and edition
are all taken from the data on the book-document itself.
This unary relation captures these constraints in one place, 
so that each of the book reference types can just inherit them."

  :iff-def (and
             ;; the constraint applies to references
             (publication-reference ?ref)

             ;; whose associated document is a book of some sort
             (has-one-of-type ?ref ref.document book)

             ;; must list a publisher.
             (has-one ?ref ref.publisher)

             ;; ref's publisher is the book publisher's name
             ;; and the address is the publisher's address
             (inherits-publisher-from-document ?ref)

             ;; books must have a year, and the are the year of publication
             ;; of the book document.
             (has-one ?ref ref.year)
             (inherits-year-from-document ?ref)))



Many thanks to Richard Fikes, who helped with the formalization and style
decisions, and Fritz Mueller, who implemented Ontolingua code to support
these definitions.  This work is supported by DARPA.


(define-instance LaTeX (book-reference)
  "The LaTeX book."
  :def (and (ref.author LaTeX leslie-lamport)
            (ref.title LaTeX "LaTeX: A Document Preparation System")
            (ref.year LaTeX 1986)
            (ref.publisher LaTeX addison-wesley)
            (ref.address LaTeX "Menlo Park, CA")))

(define-instance EndNote (manual-reference)
  :def (and (ref.author EndNote "Niles and Associates, Inc.")
            (ref.publisher EndNote  "Niles and Associates, Inc.")
            (ref.title EndNote "EndNote Plus: Enhanced Reference Database and Bibliography Maker")
            (ref.year EndNote 1990)
            (ref.address EndNote "2000 Hearst St., Berkeley, CA 94709")))

(define-instance ADDISON-WESLEY (publisher)
  "The Addison-Wesley Publishing Company"
  :def (and (publisher.name ADDISON-WESLEY
                            "Addison-Wesley Publishing Company")
            (publisher.address ADDISON-WESLEY
                                "Menlo Park, CA")))

(define-instance NILES&ASSOCIATES (organization)
  "The company that distributes the EndNote program"
  :def (agent.name NILES&ASSOCIATES "Niles and Associates, Inc."))


This Lisp-to-HTML translation was brought to you by
François Gerbaux and Tom Gruber