omstd11.tex

\documentclass[11pt,twoside,chapter]{openmath}
\setcounter{secnumdepth}{4}
\usepackage[latin1]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{ae,amsfonts,amssymb,url,graphics,color,hyperref}

\let\cellsep&

\catcode`\&=12
\catcode`\_=12
\catcode`\^=12
\catcode`\#=12
\catcode`\$=12
\catcode`\£=1
\catcode`\ß=2
\let\omlogo\relax
\begin{document}
\catcode`\%=12
\catcode`\{=12
\catcode`\}=12

\raggedbottom

\title£The OpenMath Standardß

\version£1.1bß
\author£The OpenMath Esprit Consortiumß


\editor£O.Caprottiß

\editor£D.P.Carlisleß

\editor£A.M.Cohenß



\date£October 24 2002ß

\begin£abstractß


£This document proposes \emph£OpenMathß as a standard for the communication of
  semantically rich mathematical objects. This draft of the \emph£OpenMathß 
  standard comprises the following: a description of \emph£OpenMathß objects, the
  grammar of \textsc£xmlß and of the binary encoding of objects, a
  description of Content Dictionaries and an \textsc£xmlß document type
  definition for validating Content Dictionaries. The non-normative
  Chapter 1 of this document briefly overviews the history
  of \emph£OpenMathß.ß


\end£abstractß

\maketitle


\subsection*£Change-marked edition notesß
This edition contains colour coded change markings
relative to the OpenMath 1.0 document\ldots
\begin£itemizeß
\color£greenß
\item New text is marked in green.
\color£redß
\item Deleted text is marked in red.
\end£itemizeß

\subsubsection*£Sections with new textß
\begin£itemizeß

\item
\ref£sec_ominß Further Description of OpenMath Objects\\

\item
\ref£ssec_xmlß A Grammar for the xml Encoding\\

\end£itemizeß



  

\catcode`\{=1
\catcode`\}=2
\tableofcontents
\catcode`\{=12
\catcode`\}=12


\catcode`\{=1
\catcode`\}=2
\listoffigures
\catcode`\{=12
\catcode`\}=12




\chapter£\emph£OpenMathß Movementß\label£cha_hisß






£This chapter is a historical account of \emph£OpenMathß and should be regarded
as non-normative.ß





£\emph£OpenMathß is a standard for representing mathematical objects,
allowing them to be exchanged between computer programs, stored in
databases, or published on the worldwide web.  While the original
designers were mainly developers of computer algebra systems, it is
now attracting interest from other areas of scientific computation and
from many publishers of electronic documents with a significant
mathematical content.  There is a strong relationship to the MathML
recommendation \cite£MathML_98ß from the Worldwide Web
Consortium, and a large overlap between the two developer communities.
MathML deals principally with the \emph£presentationß of
mathematical objects, while \emph£OpenMathß is solely concerned with their
semantic meaning or \emph£contentß.  While MathML does
have some limited facilities for dealing with content, it also allows
semantic information encoded in \emph£OpenMathß to be embedded inside a MathML
structure.  Thus the two technologies may be seen as highly
complementary.ß



£
\section£Historyß\label£sec_histß






£\emph£OpenMathß was originally developed through a series of workshops held
in Zurich (1993 and 1996), Oxford (1994), Amsterdam (1995), Copenhagen
(1995), Bath (1996), Dublin (1996), Nice (1997), Yorktown Heights
(1997), Berlin (1998), and Tallahassee (1998).  The participants in
these workshops formed a global \emph£OpenMathß community which was coordinated
by a Steering Committee and operated through electronic mailing groups
and ad-hoc working parties.  This loose arrangement has been
formalised through the establishment of an \emph£OpenMathß Society.  Up until the
end of 1996 much of the work of the community was funded through a
grant from the Human Capital and Mobility program of the European
Union, the contributions of several institutions and individuals.  A
document outlining the objectives and basic design of \emph£OpenMathß was
produced (later published as
\cite£Abbott_Leeuwen_Strotmann_98ß).  By the end of 1996
a simplified specification had been agreed on and some prototype
implementations have come about
\cite£Dalmas_Gaetano_Watt_97ß.ß






£In 1996 a group of European participants in \emph£OpenMathß decided to bid
for funding under the European Union's Fourth Framework Programme for
strategic research in information technology.  This bid was successful
and the project started in late 1997.  The principal aims of the
project are to formalise \emph£OpenMathß as a standard and to develop it
further through industrial applications; this document is a product of
that process and draws heavily on the previous work described earlier.
\emph£OpenMathß participants from all over the world continue to meet
regularly and cooperate on areas of mutual interest, and
recent workshops in Tallahassee (November 1998) and Eindhoven (June
1999)  endorsed  drafts of this document as the current \emph£OpenMathß standard.ß






ß

£
\section£\emph£OpenMathß Societyß\label£sec_omsocß






£In November 1998 the \emph£OpenMathß Society has been established to coordinate
all \emph£OpenMathß activities. The society is based in Helsinki, Finland and is
steered by the executive committee whose members are elected by the
society. The official web page of the society is
\href£http://www.openmath.orgߣhttp://www.openmath.orgß.ß


ß





\chapter£Introduction to \emph£OpenMathßß\label£cha_intß








£This chapter briefly introduces \emph£OpenMathß concepts and notions that are
referred to in the rest of this document.ß



£
\section£\emph£OpenMathß Architectureß\label£sec_om-archß





\begin£figureß


    
    \includegraphics£om-archß


\caption£The \emph£OpenMathß Architectureß\label£fig_omß
\end£figureß




£The architecture of \emph£OpenMathß is described in Figure 2.1 and
summarizes the interactions among the different \emph£OpenMathß components.
There are three layers of representation of a mathematical object
\cite£OM_98ß. A private layer that is the internal representation used
by an application.  An abstract layer that is the representation as an
\emph£OpenMathß object. Third is a communication layer that translates the \emph£OpenMathß 
object representation to a stream of bytes. An application dependent
program manipulates the mathematical objects using its internal
representation, it can convert them to \emph£OpenMathß objects and communicate
them by using the byte stream representation of \emph£OpenMathß objects.ß


ß

£
\section£\emph£OpenMathß Objects and Encodingsß\label£sec_intro-objß









£\emph£OpenMathß objects are representations of mathematical entities that
can be communicated among various software applications in a
meaningful way, that is, preserving their
``semantics''.ß





£\emph£OpenMathß objects and encodings are described in detail in Chapter 3 and Chapter 4.ß








£The standard endorses encodings in \textsc£xmlß and binary
format. These are the encodings supported by the official \emph£OpenMathß
libraries. However they are not the only possible encodings of \emph£OpenMathß
objects. Users that wish to define their own encoding using some other
specific language (e.g.  Lisp) may do so provided there is an
effective translation of this encoding to an official one.ß


ß

£
\section£Content Dictionariesß\label£sec_intro-cdß






£Content Dictionaries (CDs) are used to assign informal and formal
semantics to all symbols used in the \emph£OpenMathß objects. They define the
symbols used to represent concepts arising in a particular area of
mathematics.ß





£The Content Dictionaries are public, they represent the actual
common knowledge among \emph£OpenMathß applications.  Content Dictionaries fix
the ``meaning'' of objects independently of the
application.  The application receiving the object may then recognize
whether or not, according to the semantics of the symbols defined in
the Content Dictionaries, the object can be transformed to the
corresponding internal representation used by the application.ß


ß

£
\section£Additional Filesß\label£sec_addnfilesß

  

£Several
additional files are related to Content Dictionaries.  Signature files
contain the signatures of symbols defined in some \emph£OpenMathß Content
Dictionary and their format is endorsed by this standard.ß





£Furthermore, the standard fixes how to define as a CDGroup a specific
set of Content Dictionaries.ß





£Auxiliary files that define presentation and rendering or that
are used for manipulating and processing Content Dictionaries are not
discussed by the standard.ß




ß
£
\section£Phrasebooksß\label£sec_phrasebooksß







£The conversion of an \emph£OpenMathß object to/from the internal
representation in a software application is performed by an interface
program called \emph£Phrasebookß. The translation is
governed by the Content Dictionaries and the specifics of the
application. It is envisioned that a software application dealing with
a specific area of mathematics declares which Content Dictionaries it
understands. As a consequence, it is expected that the Phrasebook of
the application is able to translate \emph£OpenMathß objects built using symbols
from these Content Dictionaries to/from the internal mathematical
objects of the application.ß



 

£\emph£OpenMathß objects do not
specify any compuational behaviour, they merely represent mathematical
expressions.  Part of the \emph£OpenMathß philosophy is to leave it to the
application to decide what it does with an object once it has received
it.  \emph£OpenMathß is not a query or programming language. Because of this,
\emph£OpenMathß does not prescribe a way of forcing ``evaluation'' or
``simplification'' of objects like
\protect\(2+3\protect\) or
\protect\(sin(\pi )\protect\). Thus,
the same object \protect\(2+3\protect\) could be
transformed to \protect\(5\protect\) by a computer algebra system,
or displayed as \protect\(2+3\protect\) by a
typesetting tool.ß


ß




\chapter£\emph£OpenMathß Objectsß\label£cha_objß







£In this chapter we provide a self-contained description of \emph£OpenMathß
objects. We first do so at an informal level (Section 3.2) and next by means of an abstract grammar
description (Section 3.1).ß




£
\section£Formal Definition of \emph£OpenMathß Objectsß\label£sec_omabsß






£\emph£OpenMathß represents mathematical objects as terms or as labelled
trees that are called \emph£OpenMathß objects or \emph£OpenMathß expressions. The definition
of an abstract \emph£OpenMathß object is then the following.ß




£
\subsection£Basic \emph£OpenMathß objectsß\label£sec_basicß

 

£The Basic \emph£OpenMathß Objects form
the leaves of the \emph£OpenMathß Object tree.  A Basic \emph£OpenMathß Object is of one of
the following.ß

 

\begin£enumerateß

\def\theenumi£\roman£enumißß
\def\labelenumi£(\theenumi)ß


\item


£ Integer.ß



£Integers in
  the mathematical sense, with no predefined range.  They are
  ``infinite precision'' integers (also called
  ``bignums'' in computer algebra).ß



\item


£ IEEE floating point
    number.ß



£Double precision floating-point numbers
    following the \textsc£ieeeß 754-1985
    standard \cite£ieee754_85ß.ß



\item


£ Character string.ß



£A Unicode Character string. This also corresponds to `characters' in
  \textsc£xmlß.ß



\item


£ Bytearray.ß



£A sequence of bytes.ß



\item


£ Symbol.ß



£A Symbol
encodes two fields of information, a \emph£nameß and a
\emph£Content Dictionaryß. Each is a sequence of
characters matching a regular expression, as described below.ß



\item


£ Variable.ß



£A Variable consists of a \emph£nameß which is a
 sequence of characters matching a regular expression, as described
 below.ß



\end£enumerateß

ß

£
\subsection£Compound \emph£OpenMathß Objectsß\label£sec_compoundß


  


£\emph£OpenMathß objects are built recursively as follows.

\begin£enumerateß

\def\theenumi£\roman£enumißß
\def\labelenumi£(\theenumi)ß


\item


£ Basic \emph£OpenMathß objects are \emph£OpenMathß objects.ß




\item


£
     If
    \protect\(A\sb£1ß\protect\), \ldots ,
    \protect\(A\sb£nß\protect\)
    \protect\((n>0)\protect\) are \emph£OpenMathß
    objects, then 
  \protect\[
  \mathbf£applicationß(A\sb£1ß, \ldots , A\sb£nß)
  \protect\]
  is an \emph£OpenMathß \emph£application objectß.ß

 
\item


£ If
  \protect\(S\sb£1ß,
  \ldots , S\sb£nß\protect\)
  are \emph£OpenMathß symbols, and \protect\(A\protect\),
  \protect\(A\sb£1ß\protect\),
  \ldots , \protect\(A\sb£nß\protect\), \protect\((n>0)\protect\) are \emph£OpenMathß objects, then
  \protect\[\mathbf£attributionß
  (A, S\sb£1ß
  \hspace£.3emß
  A\sb£1ß,
 \hspace£.3emß \ldots  \hspace£.3emß , S\sb£nß \hspace£.3emß
  A\sb£nß)\protect\]
  is an \emph£OpenMathß \emph£attribution objectß and \protect\(A\protect\) is the object
  \emph£stripped of attributionsß. The operation of recursively
  applying stripping to the stripped object is called \emph£flattening
    of the attributionß. When  the stripped object after flattening
  is a  variable, the attributed object is called \emph£attributed
    variableß.ß



\item


£ If \protect\(B\protect\) and \protect\(C\protect\) are \emph£OpenMathß objects, and \protect\(v\sb£1ß\protect\), \protect\(\ldots \protect\),
  \protect\(v\sb£nß\protect\) \protect\((n \geq  0)\protect\) are \emph£OpenMathß variables or attributed variables, then
  \protect\[
  \mathbf£bindingß (B, v\sb£1ß, \ldots , v\sb£nß, C)
  \protect\]
  is an \emph£OpenMathß \emph£binding objectß.ß



\item


£ If \protect\(S\protect\) is an
\emph£OpenMathß symbol and \protect\(A\sb£1ß\protect\), \ldots , \protect\(A\sb£nß\protect\) \protect\((n \geq  0)\protect\) are \emph£OpenMathß objects, then
  \protect\[\mathbf£errorß (S, A\sb£1ß,\ldots ,A\sb£nß)
  \protect\]
  is an \emph£OpenMathß \emph£error objectß.ß



\end£enumerateß

ß


ß
ß

£
\section£Further Description of \emph£OpenMathß Objectsß\label£sec_ominß





  



£Informally, an \emph£OpenMathß \textsl£objectß can be
viewed as a tree and is also referred to as a term.  The objects at
the leaves of \emph£OpenMathß trees are called \textsl£basic
objectsß.  The basic objects supported by \emph£OpenMathß are:

\begin£descriptionß


\item[Integer]


£Arbitrary Precision
integers.ß

 

\item[Float]
 

£\emph£OpenMathß floats are
\textsc£ieeeß 754 Double precision floating-point
numbers. Other types of floating point number may be encoded in \emph£OpenMathß
by the use of suitable content dictionaries.ß


  



\item[Character strings]


£are
  sequences of characters. These characters come from the Unicode
  standard \cite£UNICODEß.ß


  


\item[Bytearrays]


£are sequences of bytes. There is no ``byte'' in \emph£OpenMathß 
  as an object of its own. However, a single byte can of course be
  represented by a bytearray of length 1.  The difference between
  strings and bytearrays is the following: a character string is a
  sequence of bytes with a fixed interpretation (as characters,
  Unicode texts may require several bytes to code one character),
  whereas a bytearray is an uninterpreted sequence of bytes with no
  intrinsic meaning.  Bytearrays could be used inside \emph£OpenMathß errors to
  provide information to, for example, a debugger; they could also
  contain intermediate results of calculations, or `handles' into
  computations or databases.ß





\item[Symbols]

  
  
  

£
 are uniquely defined by the Content Dictionary in which they occur
  and by a name. In definition in Section 3.1 we have
  left this information implicit. However, it should be kept in mind
  that all symbols appearing in an \emph£OpenMathß object are defined in a
  Content Dictionary. The form of these definitions is explained in
  Chapter 5.  Each symbol has no more than one
  definition in a Content Dictionary. Many Content Dictionaries may
  define differently a symbol with the same name (e.g., the symbol
  \texttt£unionß is defined as
  associative-commutativeset theoretic union in a Content Dictionary
  \texttt£set1ß but another Content Dictionary,
  \texttt£multiset1ß might define a symbol
  \texttt£unionß as the union of multi-sets.  The name
  of a symbol can only contain alphanumeric characters and
  underscores.  More precisely, a symbol name matches the following
  regular expression: 
\begin£quotationß


£
  [\texttt£Aß-\texttt£Zß\texttt£aß-\texttt£zß]
  [\texttt£Aß-\texttt£Zß\texttt£aß-\texttt£zß\texttt£0ß-\texttt£9ß\texttt£_ß]*
  ß


\end£quotationß
ß


  
  

£Notice that these symbol names are case sensitive.  \emph£OpenMathß
  \emph£recommendsß that symbol names should be no longer than
  100 characters.ß


 
  


\item[Variables]


£are meant to
  denote parameters, variables or indeterminates (such as bound
  variables of function definitions, variables in summations and
  integrals, independent variables of derivatives).  Plain variable
  names are restricted to use a subset of the printable ASCII
  characters.  Formally the names must match the regular expression:
  
\begin£quotationß


£
[\texttt£Aß-\texttt£Zß\texttt£aß-\texttt£zß\texttt£0ß-\texttt£9ß\texttt£=+(),-./:?!#$%*;=@[]^_`{|}ß]+
  ß


\end£quotationß
ß


   



\end£descriptionß
 ß





£The four following constructs can be used to make compound \emph£OpenMathß
objects.ß




\begin£descriptionß


\item[Application]


£constructs an
  \emph£OpenMathß object from a sequence of one or more \emph£OpenMathß objects. The first
  argument of application is referred to as ``head'' while
  the remaining objects are called ``arguments''.  An \emph£OpenMathß
  application object can be used to convey the mathematical notion of
  application of a function to a set of arguments.  For instance,
  suppose that the \emph£OpenMathß symbol \texttt£sinß is defined
  in a Content Dictionary for trigonometry, then \protect\(\mathbf£applicationß(sin,
  x )\protect\) is the abstract \emph£OpenMathß object
  corresponding to \protect\(sin (x
  )\protect\).  More generally, an \emph£OpenMathß application object can
  be used as a constructor to convey a mathematical object built from
  other objects such as a polynomial constructed from a set of
  monomials.  Constructors build inhabitants of some symbolic type,
  for instance the type of rational numbers or the type of
  polynomials.  The rational number, usually denoted as
  \protect\(1/2\protect\), is represented by the
  \emph£OpenMathß application object \protect\(\mathbf£applicationß(Rational,
  1, 2)\protect\). The symbol
  \texttt£Rationalß must be defined, by a Content
  Dictionary, as a constructor symbol for the rational numbers.ß


   

\begin£figureß


      \includegraphics£lambdaß


\caption£The \emph£OpenMathß application and binding objects for
\protect\(sin (x )\protect\) and
\protect\(\lambda  x.x +
2\protect\) in tree-like notation.ß\label£fig_objß
\end£figureß


  



\item[Binding]


£objects are
  constructed from an \emph£OpenMathß object, and from a sequence of zero or more
  variables followed by another \emph£OpenMathß object.  The first \emph£OpenMathß object is
  the ``binder'' object. Arguments 2 to
  \protect\(n-1\protect\) are always variables to
  be bound in the ``body'' which is the
  \protect\(n\sp£thß\protect\) argument object. It
  is allowed to have no bound variables, but the binder object and the
  body should be present. Binding can be used to express functions or
  logical statements.  The function \protect\(\lambda 
  x.x +2\protect\), in which
  the variable \protect\(x\protect\) is bound by
  \protect\(\lambda \protect\), corresponds to a binding object having
  as binder the \emph£OpenMathß symbol \texttt£lambdaß: \protect\[\mathbf£bindingß(\mathtt£lambdaß,
  x , \mathbf£applicationß(plus,
  x ,
  2))\mbox£.ß\protect\]ß


  
  
  

£\color£redßBinding of several variables as in: \protect\[\mathbf£bindingß
  (B,
  v\sb£1ß,
  \ldots ,
  v\sb£nß, C
  )\protect\] is semantically equivalent to composition of
  binding of a single variable, namely
  \protect\[
    \mathbf£bindingß
    (
    B
    ,
    v\sb£1ß
    ,
    (
    \mathbf£bindingß
    (
    B
    ,
    v\sb£2ß
    ,
    (
    \ldots 
    ,
    \mathbf£bindingß
    (
    B
    ,
    v\sb£nß
    ,
    C
    )
    \ldots 
    )
    \mbox£.ß
  \protect\]
ß


  
  
 

£\color£redßNote that it follows from
this that repeated occurrences of the same variable in a binding
operator are allowed. For example the object
  \protect\[
    \mathbf£bindingß
    (\mathtt£lambdaß, v ,
    v ,\mathbf£applicationß
    (\mathtt£timesß,v
    ,v) )\protect\] is semantically
    equivalent to: \protect\[\mathbf£bindingß(\mathtt£lambdaß,
    v, \mathbf£bindingß
    (\mathtt£lambdaß, v,\mathbf£applicationß(\mathtt£timesß,v,v)))\protect\]
    so that the outermost binding is actually a constant function
    (\protect\(v\protect\) does not occur free in the body \protect\(\mathbf£applicationß
    (\mathtt£timesß,v
    ,v) )\protect\)).ß





£Phrasebooks are allowed to use \protect\(\alpha \protect\)
  conversion in order to avoid clashes of variable names. Suppose an
  object \protect\(\Omega \protect\) contains an occurrence of the
  object \protect\(\mathbf£bindingß
  (B , v , C
  )\protect\).  This object \protect\(\mathbf£bindingß (B ,
  v , C )\protect\) can be replaced
  in \protect\(\Omega \protect\) by \protect\(\mathbf£bindingß (B ,
  z , C')\protect\) where
  \protect\(z\protect\) is a variable not occurring free in
  \protect\(C\protect\) and \protect\(C'\protect\) is obtained
  from \protect\(C\protect\) by replacing each free (i.e., not bound
  by any intermediate \textbf£bindingß construct) occurrence
  of \protect\(v\protect\) by \protect\(z\protect\).  This
  operation preserves the semantics of the object
  \protect\(\Omega \protect\). In the above example, a phrasebook is
  thus allowed to transform the object to, e.g.  \protect\[\mathbf£bindingß
  (\mathtt£lambdaß, v , \mathbf£bindingß (\mathtt£lambdaß,
  z ,\mathbf£applicationß
  (\mathtt£timesß,z
  ,z)))\mbox£.ß\protect\]
  \protect\[\mathbf£bindingß(\mathtt£lambdaß,
  z , \mathbf£applicationß(plus,
  z ,
  2))\mbox£.ß\protect\]
ß




£\color£greenßRepeated occurrences of the same variable in a
  binding operator are allowed. An OpenMath application should treat a
  binding with multiple occurrences of the same variable as equivalent
  to the binding in which all but the last occurrence of each variable
  is replaced by a new variable which does not occur free in the body
  of the binding.  \protect\[\mathbf£bindingß (\mathtt£lambdaß,
  v , v ,\mathbf£applicationß
  (\mathtt£timesß,v
  ,v) )\protect\] is semantically
  equivalent to: \protect\[\mathbf£bindingß (\mathtt£lambdaß ,
  v\sp£'ß , v
  ,\mathbf£applicationß
  (\mathtt£timesß,v
  ,v) )\protect\] so that the
  resulting function is actually a constant in its first argument
  (\protect\(v\sp£'ß\protect\) does not occur free
  in the body \protect\(\mathbf£applicationß
  (\mathtt£timesß,v
  ,v) )\protect\)).ß



  



\item[Attribution]


£decorates an
  object with a sequence of one or more pairs made up of an \emph£OpenMathß
  symbol, the ``attribute'', and an associated \emph£OpenMathß object,
  the ``value of the attribute''.  The value of the
  attribute can be an attribution object itself. As example of this,
  consider the \emph£OpenMathß objects representing groups, automorphism groups,
  and group dimensions. It is then possible to attribute an \emph£OpenMathß
  object representing a group by its automorphism group, itself
  attributed by its dimension.ß





£Composition of attributions, as in
  \protect\[
\mathbf£attributionß(\mathbf£attributionß(A,
  S\sb£1ß \hspace£.3emß
  A\sb£1ß,\ldots ,S\sb£hß
  \hspace£.3emß
  A\sb£hß),
  S\sb££h+1ßß
  \hspace£.3emß
  A\sb££h+1ßß,
  \ldots , S\sb£nß \hspace£.3emß A\sb£nß)\protect\] is
  semantically equivalent to a single attribution, that is \protect\[\mathbf£attributionß(A,
  S\sb£1ß \hspace£.3emß
  A\sb£1ß,
  \ldots , S\sb£hß \hspace£.3emß A\sb£hß,
  S\sb££h+1ßß
  \hspace£.3emß
  A\sb££h+1ßß,
  \ldots , S\sb£nß \hspace£.3emß
  A\sb£nß)\mbox£.ß\protect\]
  The operation that produces an object with a single layer of
  attribution is called \texttt£flatteningß.ß





£Multiple attributes with the same name are allowed.  While the order
  of the given attributes does not imply any notion of priority,
  potentially it could be significant. For instance, consider the case
  in which \protect\(S\sb£hß =
  S\sb£nß\protect\)
 (\protect\(h < n\protect\)) in the example above. Then, the
  object is to be interpreted as if the value \protect\(A\sb£nß\protect\) overwrites the
  value \protect\(A\sb£hß\protect\).  (\emph£OpenMathß however does not mandate that an application
  preserves the attributes or their order.)ß






£Objects can be decorated in a multitude of
ways. In \cite£OM_D131bß, typing of \emph£OpenMathß objects is
expressed by using an attribution. The object \protect\(\mathbf£attributionß(A,
type \hspace£.3emß t )\protect\)
represents the judgment stating that object \protect\(A\protect\)
has type \protect\(t\protect\). Note that both
\protect\(A\protect\) and \protect\(t\protect\) are \emph£OpenMathß
objects.ß





£Attribution can act as either annotation, in the sense of adornment,
  or as modifier. In the former case, replacement of the adorned
  object by the object itself is probably not harmful (preserves the
  semantics). In the latter case however, it may very well be.
  Therefore, attribution in general should by default be treated as a
  construct rather than as adornment. Only when the CD definitions of
  the attributes make it clear that they are adornments, can the
  attributed object be viewed as semantically equivalent to the
  stripped object.ß



  



\item[Error]


£is made up of an \emph£OpenMathß
  symbol and a sequence of zero or more \emph£OpenMathß objects. This object has
  no direct mathematical meaning.  Errors occur as the result of some
  treatment on an \emph£OpenMathß object and are thus of real interest only when
  some sort of communication is taking place. Errors may occur inside
  other objects and also inside other errors.  Error objects might
  consist only of a symbol as in the object: \protect\(\mathbf£errorß (S
  )\protect\).ß

 



\end£descriptionß
 
ß

£
\section£Summaryß\label£sec_summaryß




\begin£itemizeß


\item


£\emph£OpenMathß supports basic objects like integers, symbols,
  floating-point numbers, character strings, bytearrays, and
  variables.ß



\item


£\emph£OpenMathß compound objects are of four kinds: applications, bindings,
  errors, and attributions.ß



\item


£\emph£OpenMathß objects have the expressive power to cover all areas of
  computational mathematics.ß



\end£itemizeß





£Observe that an \emph£OpenMathß application object is viewed as a ``tree'' by
software applications that do not understand Content Dictionaries,
whereas a Phrasebook that understands the semantics of the symbols, as
defined in the Content Dictionaries, should interpret the object as
functional application, constructor, or binding accordingly. Thus, for
example, for some applications, the \emph£OpenMathß object corresponding
to \protect\(2+5\protect\) may result in a command that writes \protect\(7\protect\).ß


ß




\chapter£\emph£OpenMathß Encodingsß\label£cha_encoß






£In this chapter, two encodings are defined that map between  \emph£OpenMathß
objects and byte streams.  These byte streams constitute a low level
representation that can be easily exchanged between processes (via
almost any communication method) or stored and retrieved from files.ß






£The first encoding uses  ISO 646:1983 characters \cite£iso646_83ß
(also known as \textsc£asciiß characters) and is  an \textsc£xmlß
application. Although the \textsc£xmlß markup of the encoding uses only \textsc£asciiß
characters, OpenMath strings may use
arbitrary Unicode/ISO 10646:1988 
characters \cite£UNICODEß. 
It can be used, for example, to send \emph£OpenMathß objects via
e-mail, news, cut-and-paste, etc. The texts produced by this encoding
can be part of \textsc£xmlß documents.ß





£The second encoding is a binary encoding that is meant to be used when 
the compactness of the encoding is important (interprocess communications 
over a network is an example).ß





£Note that these two encodings are sufficiently different for
autodetection to be effective: an application reading the bytes can
very easily determine which encoding is used.ß



£
\section£The \textsc£xmlß Encodingß\label£sec_xmlß





£This encoding has been designed with two main goals in mind:

\begin£enumerateß


\item


£to provide an encoding that uses the most common character set
  (so that it can be easily included in most documents and transport
  protocols) and that is both readable and writable by a human.ß



\item


£to provide an encoding that can be included (embedded) in
  \textsc£xmlß documents.ß



\end£enumerateß
 
ß



£
\subsection£A Grammar for the \textsc£xmlß Encodingß\label£ssec_xmlß








£The \textsc£xmlß encoding of an OpenMath object is defined by the \textsc£dtdß given
in Figure 4.1 below, with the following additional rules
not implied by the \textsc£xmlß \textsc£dtdß.ß



\begin£itemizeß


\item


£Comments are permitted only between
elements, not within element character data.ß



\item


£Processing Instructions are only allowed before the \textsc£OMOBJß
 element.ß



\item


£The content of an \textsc£OMBß element, is a valid base64-encoded text.ß



\item


£The character data forming element content and attribute values
matches the regular expressions of Figure 4.2.ß



\end£itemizeß




\begin£figureß


    
£\footnotesize
\begin£verbatimß
<!-- DTD for OM Objects - sb 29.10.98 -->
<!-- sb 3.2.99 -->

<!--
     general list of embeddable elements
      : excludes OMATP as this is only embeddable in OMATTR
      : excludes OMBVAR as this is only embeddable in OMBIND
-->

<!ENTITY % omel "OMS | OMV | OMI | OMB | OMSTR
                           | OMF | OMA | OMBIND | OME | OMATTR ">

<!-- things which can be variables -->

<!ENTITY % omvar "OMV | OMATTR" >

<!-- symbol -->
<!ELEMENT OMS EMPTY>
<!ATTLIST OMS name CDATA #REQUIRED  cd CDATA #REQUIRED >

<!-- variable -->
<!ELEMENT OMV EMPTY>
<!ATTLIST OMV name CDATA #REQUIRED >

<!-- integer -->
<!ELEMENT OMI (#PCDATA) >

<!-- byte array -->
<!ELEMENT OMB (#PCDATA) >

<!-- string -->
<!ELEMENT OMSTR (#PCDATA) >

<!-- floating point -->
<!ELEMENT OMF EMPTY>
<!ATTLIST OMF dec CDATA #IMPLIED  hex CDATA #IMPLIED>

<!-- apply constructor -->
<!ELEMENT OMA (%omel;)+ >

<!-- binding constructor & variable -->
<!ELEMENT OMBIND ((%omel;), OMBVAR, (%omel;)) >
<!ELEMENT OMBVAR (%omvar;)+ >

<!-- error -->
<!ELEMENT OME (OMS, (%omel;)* ) >

<!-- attribution constructor & attribute pair constructor -->
<!ELEMENT OMATTR (OMATP, (%omel;)) >
<!ELEMENT OMATP (OMS, (%omel;))+ >

<!-- OM object constructor -->
<!ELEMENT OMOBJ (%omel;) >
\end{verbatim}\par\vspace£-10ptßß



\caption£DTD for the \emph£OpenMathß \textsc£xmlß encoding of objects.ß\label£fig_objdtdß
\end£figureß





£In addition, if the \textsc£xmlß document encoding the \emph£OpenMathß object is
linearised into the \textsc£xmlß concrete syntax, the following further
constraints apply, which ensure thet the encoding may be read by \emph£OpenMathß
applications that may not include a full \textsc£xmlß parser.ß




\begin£itemizeß


\item


£The document should use \textsc£utf-8ß encoding.ß



\item
\color£redß

£Entity and character references should not be used.ß



\item


£A \texttt£<!DOCTYPEß declaration should not be used.ß



\item
\color£greenß

£Character references should not be used. As \texttt£<!DOCTYPEß
is not used, the only entity references that are allowed are the five predefined entity
references: 
\texttt£&apos;ß ('),
\texttt£&quot;ß ("),
\texttt£&lt;ß (<),
\texttt£&gt;ß (>),
\texttt£&amp;ß (&).
ß



\item


£The \textsc£xmlß empty element form \texttt£<\ldots />ß should always be
used to encode elements such as \textsc£omfß which are specified in the
\textsc£dtdß as
being \textsc£emptyß. It should never be used for elements that may sometimes be
empty, such as \textsc£omstrß.ß



\end£itemizeß




£Such a linearisation of an \textsc£xmlß encoded \emph£OpenMathß Object would match the
match the character based grammar given in Figure 4.2.ß





£The notation used in this section and in Figure 4.2 should
be quite straightforward (+ meaning ``one or more'', ? meaning zero or
one, and \protect\(|\protect\) meaning ``or''). The start symbol of the grammar is
``start'', ``space'' stands for the space character, ``cr'' for the
carriage return character, ``nl'' for the line feed character and
``tab'' for the horizontal tabulation character.ß





\begin£figureß


    



£\footnotesize
\begin£tabularߣcccccccccccccß



S            \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  (space\protect\(|\protect\)tab\protect\(|\protect\)cr\protect\(|\protect\)nl)+  
 \cellsep 
\\





integer      \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  
        (\texttt£-ß S?)? [0-9]+ (S [0-9]+)*  \protect\(|\protect\) 
        (\texttt£-ß S?)? \texttt£xß S? [0-9A-F]+ (S [0-9A-F]+)* 
 \cellsep 
\\



 

cdname       \cellsep  \protect\(\longrightarrow \protect\)  \cellsep   [a-z][a-z0-9\texttt£_ß]*
 \cellsep 
\\





symbname     \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [A-Za-z][A-Za-z0-9\texttt£_ß]*
 \cellsep 
\\





fpdec        \cellsep  \protect\(\longrightarrow \protect\)  \cellsep   
    (\texttt£-ß?)([0-9]+)?(\texttt£.ß[0-9]+)?(\texttt£eß([+-]?)[0-9]+)?
 \cellsep 
\\





fphex        \cellsep  \protect\(\longrightarrow \protect\)  \cellsep   [0-9ABCDEF]+ 
 \cellsep 
\\





varname         \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  ([A-Za-z0-9+=(),-./:?!#$%*;@[]^_`{|}])+ 
 \cellsep 
\\





base64       \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  ([A-Za-z0-9 +/=] \protect\(|\protect\) S)+ 
 \cellsep 
\\



char   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  \emph£XML Character Dataß
 \cellsep 
\\


\end£tabularßß






\begin£tabularߣcccccccccccccß



symbnameatt \cellsep  \protect\(\longrightarrow \protect\) \cellsep  
    \texttt£nameß S? = S? (\texttt£"ß symbname \texttt£"ß \texttt£|ß \texttt£'ß symbname \texttt£'ß) 
 \cellsep 
\\




cdnameatt \cellsep  \protect\(\longrightarrow \protect\) \cellsep 
 \texttt£cdß S? = S? (\texttt£"ß cdname \texttt£"ß \texttt£|ß \texttt£'ß cdname \texttt£'ß) 
 \cellsep 
\\




varnameatt \cellsep  \protect\(\longrightarrow \protect\) \cellsep 
 \texttt£nameß S? = S? (\texttt£"ß varname \texttt£"ß \texttt£|ß \texttt£'ß varname \texttt£'ß) 
 \cellsep 
\\




fpdecatt \cellsep  \protect\(\longrightarrow \protect\) \cellsep 
 \texttt£decß S? = S? (\texttt£"ß fpdec \texttt£"ß \texttt£|ß \texttt£'ß fpdec \texttt£'ß) 
 \cellsep 
\\




fphexatt \cellsep  \protect\(\longrightarrow \protect\) \cellsep 
 \texttt£hexß S? = S? (\texttt£"ß fphex \texttt£"ß \texttt£|ß \texttt£'ß fphex \texttt£'ß) 
 \cellsep 
\\




PI  \cellsep  \protect\(\longrightarrow \protect\) \cellsep  <\texttt£?ß char \texttt£?ß\texttt£>ß
 \cellsep 
\\




comment \cellsep  \protect\(\longrightarrow \protect\) \cellsep  <\texttt£!--ß char \texttt£--ß\texttt£>ß
 \cellsep 
\\





SC \cellsep \protect\(\longrightarrow \protect\) \cellsep  S+ \texttt£|ß (comment S)+
 \cellsep 
\\





start   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  
 (SC \texttt£|ß PI)* \texttt£<OMOBJß S?\texttt£>ß S? object S? \texttt£</OMOBJß S?\texttt£>ß 
 \cellsep 
\\





symbol    \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  
  \texttt£<OMSß S  symbnameatt S cdnameatt  S? \texttt£/>ß
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep 
  \texttt£<OMSß S cdnameatt S symbnameatt S? \texttt£/>ß
 \cellsep 
\\





variable  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep 
   \texttt£<OMVß S varnameatt S? \texttt£/>ß
 \cellsep 
\\




          \cellsep  \protect\(|\protect\) 
          \cellsep  \texttt£<OMATTRß S?\texttt£>ß SC? omatp SC? variable SC? \texttt£</OMATTRß S?\texttt£>ß
 \cellsep 
\\




omatp  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep 
     \texttt£<OMATPß S?\texttt£>ß SC? attrs SC? \texttt£</OMATPß S?\texttt£>ß 
 \cellsep 
\\







object  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  symbol 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)            \cellsep  variable 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMIß S?\texttt£>ß S? integer S? \texttt£</OMIß S?\texttt£>ß
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMFß S fpdecatt S? \texttt£/>ß
 \cellsep 
\\



  
        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMFß S fphexatt S? \texttt£/>ß
 \cellsep 
\\



  
        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMSTRß S?\texttt£>ß char \texttt£</OMSTRß S?\texttt£>ß 
 \cellsep 
\\



  
        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMBß S?\texttt£>ß base64  \texttt£</OMBß S?\texttt£>ß 
 \cellsep 
\\



   
        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMAß S?\texttt£>ß SC? object SC? objects SC? \texttt£</OMAß S?\texttt£>ß
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMBINDß S?\texttt£>ß SC? object SC? 
 \cellsep 
\\




        \cellsep  \cellsep  \texttt£<OMBVARß S?\texttt£>ß SC? variables SC? \texttt£</OMBVARß S?\texttt£>ß 
 \cellsep 
\\




        \cellsep  \cellsep  SC? object SC? \texttt£</OMBINDß S?\texttt£>ß
 \cellsep 
\\



 
        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMEß S?\texttt£>ß SC? symbol SC? objects SC? \texttt£</OMEß S?\texttt£>ß 
 \cellsep 
\\



  
        \cellsep  \protect\(|\protect\)            \cellsep  \texttt£<OMATTRß S?\texttt£>ß SC?  \texttt£<OMATPß S?\texttt£>ß SC? attrs SC? \texttt£</OMATPß S?\texttt£>ß   
 \cellsep 
\\




        \cellsep  \cellsep SC? object SC? \texttt£</OMATTRß S?\texttt£>ß  
 \cellsep 
\\



  
 

attrs   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  symbol S? object   
 \cellsep 
\\



 
        \cellsep  \protect\(|\protect\)                \cellsep  symbol S? object S? attrs 
 \cellsep 
\\






objects  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  SC?     
 \cellsep 
\\




         \cellsep  \protect\(|\protect\)                \cellsep  object SC? objects  
 \cellsep 
\\





variables  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  SC?   
 \cellsep 
\\



 
         \cellsep  \protect\(|\protect\)                \cellsep  variable SC? variables  
 \cellsep 
\\




 \cellsep 
\\


\end£tabularß





\caption£Grammar for the \textsc£xmlß encoding of \emph£OpenMathß objects.ß\label£fig_xmlß
\end£figureß

ß

£
\subsection£Description of the Grammarß\label£sec_xml-descß







£An encoded \emph£OpenMathß object is placed inside an \texttt£OMOBJß element.  This 
element can contain the elements (and integers) as described above.ß





£We briefly discuss the \textsc£xmlß encoding for each type of \emph£OpenMathß object
starting from the basic objects.ß




\begin£descriptionß


\item[Integers]





£are encoded using the \texttt£OMIß element around the
  sequence of their digits in base 10 or 16 (most significant digit
  first).  White space may be inserted between the characters of the
  integer representation, this will be ignored.
  After ignoring white
  space, integers written in base 10 match the regular expression
  \texttt£-?[0-9]+ß.  Integers written in base 16 match
  \texttt£-?x[0-9A-F]+ß.
The integer 10 can be thus encoded as
  \texttt£<OMI> 10 </OMI> ß or as \texttt£<OMI> xA </OMI> ß
  but neither \texttt£<OMI> +10 </OMI>ß nor \texttt£<OMI> +xA </OMI>ß
  can be used.ß





£The negative integer \protect\(-120\protect\) can be encoded as either as decimal
       \texttt£<OMI> -120 </OMI>ß or  as hexadecimal \texttt£<OMI> -x78 </OMI>ß.ß



  



\item[Symbols]


£are encoded using the \texttt£OMSß element. This element
  has two \textsc£xmlß-attributes \texttt£cdß and \texttt£nameß. The value
  of \texttt£cdß is the name of the Content Dictionary in which the
  symbol is defined and the value of \texttt£nameß is the name of the
  symbol.  The name of the Content Dictionary is compulsory, but a
  future revision of the \emph£OpenMathß standard might introduce a defaulting
  mechanism.  For example, \texttt£<OMS cd="transc" name="sin"/>ß is the
  encoding of the symbol named \texttt£sinß in the Content Dictionary
  named \texttt£transcß.ß


  



\item[Variables]


£are encoded using the \texttt£OMVß element, with only
  one \textsc£xmlß-attribute, \texttt£nameß, whose value is the variable
  name.  The variable name is a subset of the printable \textsc£asciiß
 set of characters.
  In particular, neither spaces nor double-quote \texttt£"ß are allowed
  in variable names.  For instance, the encoding of the object
  representing the variable \protect\(x\protect\) is:
    \texttt£<OMV  name="x"/>ßß



  



\item[Floating-point numbers]


£are encoded using the \texttt£OMFß element
  that has either the \textsc£xmlß-attribute \texttt£decß or the
  \textsc£xmlß-attribute \texttt£hexß. The two \textsc£xmlß-attributes
  cannot be present simultaneously. The value of \texttt£decß is the
  floating-point number expressed in base 10, using the common syntax:ß


  
  
\begin£quotationß


£
  \texttt£(-?)([0-9]+)?("."[0-9]+)?(e(-?)[0-9]+)?ß.
  ß


\end£quotationß

  
  

£The value of \texttt£hexß is the digits of the floating-point number
  expressed in base 16, with digits \texttt£0ß-\texttt£9ß, \texttt£Aß-\texttt£Fß
  (mantissa, exponent, and sign from lowest to highest bits) using a
  least significant byte ordering.  For example, \texttt£<OMF
    dec="1.0e-10"/>ß is a valid floating-point number.ß


  




\item[Character strings]


£are encoded using the \texttt£OMSTRß element.
  Its content is  a Unicode text (The default encoding 
  is \textsc£utf-8ß\cite£utf8ß, although \textsc£xmlß encoded OpenMath may be embedded
 in a containing \textsc£xmlß document that specifies alternative encoding in
  the \textsc£xmlß declaration. Note that as always in \textsc£xmlß the
  characters \texttt£<ß and \texttt£&ß  need to be represented by the
  entity references \texttt£<ß and \texttt£&ß respectively.ß


  



\item[Bytearrays]


£are encoded using the \texttt£OMBß element. Its content
  is a sequence of characters that is a base64 encoding of the data.
  The base64 encoding is defined in \textsc£rfcß 1521 \cite£rfc1521ß.
  Basically, it represents an arbitrary sequence of octets using 64
  ``digits'' (\texttt£Aß through \texttt£Zß, \texttt£aß through \texttt£zß, \texttt£0ß through \texttt£9ß, \texttt£+ß and /, in order of increasing
  value). Three octets are represented as four digits (the \texttt£=ß
  character for padding to the right at the end of the data). All line
  breaks and carriage return, space, form feed and horizontal
  tabulation characters are ignored. The reader is refered to
  \cite£rfc1521ß for more detailed information.ß






\end£descriptionß

 


£In detail the encoding of an \emph£OpenMathß object is described below.ß




\begin£descriptionß


\item[Applications]


£are encoded using the \texttt£OMAß element. The
  application whose root is the \emph£OpenMathß object \protect\(e\sb£0ß\protect\) and whose arguments
  are the \emph£OpenMathß objects \protect\(e\sb£1ß\protect\), \ldots , \protect\(e\sb£nß\protect\) is encoded as \texttt£<OMA>ß
  \protect\(C\sb£0ß\protect\) \protect\(C\sb£1ß\protect\)\ldots  \protect\(C\sb£nß\protect\) \texttt£</OMA>ß where \protect\(C\sb£iß\protect\) is the encoding of
  \protect\(e\sb£iß\protect\).ß





£For example, \protect\(\mathbf£applicationß(sin,x )\protect\) is encoded as:

\begin£verbatimß
            <OMA>  
            <OMS cd="transc1" name="sin"/> 
            <OMV name="x"/>  
            </OMA> 
\end{verbatim}
 
  provided that the symbol \texttt£sinß is defined to be a function
  symbol in a Content Dictionary named \texttt£transc1ß.ß



  



\item[Binding]


£is encoded using the \texttt£OMBINDß element.  The binding
  by the \emph£OpenMathß object \protect\(b\protect\) of the \emph£OpenMathß variables \protect\(x\sb£1ß\protect\), \protect\(x\sb£2ß\protect\),
  \protect\(\ldots \protect\), \protect\(x\sb£nß\protect\) in the object \protect\(c\protect\) is encoded as \texttt£<OMBIND>ß \protect\(B\protect\)
  \texttt£<OMBVAR>ß \protect\(X\sb£1ß\protect\) \protect\(\ldots \protect\) \protect\(X\sb£nß\protect\) \texttt£</OMBVAR>ß \protect\(C\protect\) \texttt£</OMBIND>ß where \protect\(B\protect\), \protect\(C\protect\), and \protect\(X\sb£iß\protect\) are the encodings of \protect\(b\protect\), \protect\(c\protect\)
  and \protect\(x\sb£iß\protect\), respectively.ß





£For instance the encoding of
  \protect\(\mathbf£bindingß
       (\mathtt£lambdaß,
  x,\mathbf£applicationß
     (sin, x))\protect\) is:

\begin£verbatimß 
      <OMBIND>
        <OMS cd="fns1" name="lambda"/>  
        <OMBVAR>
          <OMV name="x"/>
        </OMBVAR>  
        <OMA>
          <OMS cd="transc1" name="sin"/> 
          <OMV name="x"/>  
        </OMA>
      </OMBIND>
\end{verbatim}
 ß


  


£Binders are defined in  Content Dictionaries, in particular,
  the symbol \texttt£lambdaß is defined in the Content Dictionary
  \texttt£fns1ß for functions over functions.ß


  



\item[Attributions]


£are encoded using the \texttt£OMATTRß element.  If
  the \emph£OpenMathß object \protect\(e\protect\) is attributed with (\protect\(s\sb£1ß\protect\), \protect\(e\sb£1ß\protect\)), \ldots , 
  (\protect\(s\sb£nß\protect\), \protect\(e\sb£nß\protect\)) pairs (where \protect\(s\sb£iß\protect\) are the attributes), it is encoded
  as \texttt£<OMATTR>ß \texttt£<OMATP>ß \protect\(S\sb£1ß\protect\) \protect\(C\sb£1ß\protect\) \ldots  \protect\(S\sb£nß\protect\) \protect\(C\sb£nß\protect\) \texttt£</OMATP>ß \protect\(E\protect\) \texttt£</OMATTR>ß where \protect\(S\sb£iß\protect\) is the encoding of the
  symbol \protect\(s\sb£iß\protect\), \protect\(C\sb£iß\protect\) of the object \protect\(e\sb£iß\protect\) and \protect\(E\protect\) is the encoding of
  \protect\(e\protect\).ß





£Examples are the use of attribution to decorate a group by its
  automorphism group:

\begin£verbatimß
          <OMATTR>    
             <OMATP>
                  <OMS cd="groups" name="automorphism_group" />  
                  [..group-encoding..] 
             </OMATP>  
             [..group-encoding..] 
          </OMATTR>  
\end{verbatim}
 
or to express the type of a variable:

\begin£verbatimß 
          <OMATTR>    
              <OMATP>
                   <OMS cd="ecc" name="type" /> 
                   <OMS cd="ecc" name="real" />
              </OMATP> 
              <OMV name="x" />
          </OMATTR>
\end{verbatim}
 ß



  



\item[Errors]


£are encoded using the \texttt£OMEß element. The error whose
  symbol is \protect\(s\protect\) and whose arguments are the \emph£OpenMathß objects \protect\(e\sb£1ß\protect\),
  \ldots , \protect\(e\sb£nß\protect\) is encoded as \texttt£<OME>ß \protect\(C\sb£sß\protect\) \protect\(C\sb£1ß\protect\)\ldots  \protect\(C\sb£nß\protect\) \texttt£</OME>ß where \protect\(C\sb£sß\protect\) is the encoding of \protect\(s\protect\) and \protect\(C\sb£iß\protect\) the encoding
  of \protect\(e\sb£iß\protect\).ß





£If an \texttt£aritherrorß Content Dictionary contained a
  \texttt£DivisionByZeroß symbol, then the object
  \protect\(\mathbf£errorß(DivisionByZero, \mathbf£applicationß
  (divide, 
  x, 0))\protect\) would be encoded as follows:


\begin£verbatimß 
            <OME>
            <OMS cd="aritherror" name="DivisionByZero"/>  
            <OMA>
                 <OMS cd="arith1" name="divide" />
                 <OMV name="x"/>  
                 <OMI> 0 </OMI>
            </OMA> 
            </OME>
\end{verbatim}
ß

   
  



\end£descriptionß




ß

£
\subsection£Embedding OpenMath in XML Documentsß\label£xmldocß



     


£The above encoding of \textsc£xmlß encoded \emph£OpenMathß specifies the grammar to be
used in files that encode a single \emph£OpenMathß object, and specifies the
character streams that a conforming \emph£OpenMathß application should be able
to accept or produce.ß





£When embedding \textsc£xmlß encoded \emph£OpenMathß objects into a larger XML document
one may wish, or need, to use other XML features. For example use of
extra \textsc£xmlß attributes to specify \textsc£xmlß Namespaces \cite£xmlnsß
or xml:lang attributes to specify the language used in strings \cite£xmlß.
Also, the encoding used in the larger document may not be \textsc£utf-8ß.ß



 


£In particular, if \emph£OpenMathß  is used with applications that use the XML
Namespace Recommendation \cite£xmlnsß then they should ensure
that \emph£OpenMathß elements are in the namespace
\texttt£http://www.openmath.org/OpenMathß
This is most conveniently achieved by adding the namespace declaration

\begin£verbatimß
xmlns="http://www.openmath.org/OpenMath"
\end{verbatim}

as an attribute to each \texttt£OMOBJß element in the document.ß





£If such \textsc£xmlß features are used then the \textsc£xmlß application controlling the
document must, if passing the \emph£OpenMathß fragment to an \emph£OpenMathß application,
remove any such extra attributes and must ensure that the
fragment is encoded according to the grammar specified above.ß


ß
ß

£
\section£The Binary Encodingß\label£sec_binaryß







£The binary encoding was essentially designed to be more compact than
the \textsc£xmlß encodings, so that it can be more efficient if large
amounts of data are involved. For the current encoding, we tried to
keep the right balance between compactness, speed of encoding and
decoding and simplicity (to allow a simple specification and easy
implementations).ß



£
\subsection£A Grammar for the Binary Encodingß\label£sec_binary_grammarß





     


\begin£figureß


    
    

\begin£tabularߣcccccccccccccß



start   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [24] object [25] 
 \cellsep 
\\




object  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  integer 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  float 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  variable 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  symbol 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  string 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  bytearray 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  construct 
 \cellsep 
\\




integer  \cellsep \protect\(\longrightarrow \protect\)  \cellsep  [1] [_] 
 \cellsep 
\\




         \cellsep \protect\(|\protect\)                \cellsep  [1 + 128] {_} 
 \cellsep 
\\




         \cellsep \protect\(|\protect\)                \cellsep  [2] [n] [_] digits:n 
 \cellsep 
\\




         \cellsep \protect\(|\protect\)                \cellsep  [2 + 128] {n} [_] digits:n 
 \cellsep 
\\




float   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [3] {_} {_} 
 \cellsep 
\\




variable  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [5] [n] varname:n 
 \cellsep 
\\




          \cellsep  \protect\(|\protect\)                \cellsep  [5 + 128] {n} varname:n 
 \cellsep 
\\




          \cellsep  \protect\(|\protect\)                \cellsep  [5 + 64] [n] 
 \cellsep 
\\




symbol  \cellsep   \protect\(\longrightarrow \protect\)  \cellsep  [8] [n] [m] cdname:n symbname:m 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                 \cellsep  [8 + 128] {n} {m} cdname:n symbname:m 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                 \cellsep  [8 + 64] [n] 
 \cellsep 
\\




string  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [6] [n] chars:n 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  [6 + 128] {n} chars:n 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  [7] [n] chars:2n 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  [7 + 128] {n} chars:2n 
 \cellsep 
\\




        \cellsep  \protect\(|\protect\)                \cellsep  [7 + 64] [n] 
 \cellsep 
\\




bytearray  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [4] [n] bytes:n 
 \cellsep 
\\




           \cellsep  \protect\(|\protect\)                \cellsep  [4 + 128] {n} bytes:n 
 \cellsep 
\\




construct  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [16] object objects [17] 
 \cellsep 
\\




           \cellsep  \protect\(|\protect\)                \cellsep  [22] symbol objects [23] 
 \cellsep 
\\




           \cellsep  \protect\(|\protect\)                \cellsep  [18] attrpairs object [19] 
 \cellsep 
\\




           \cellsep  \protect\(|\protect\)                \cellsep  [26] object bvars object [27] 
 \cellsep 
\\




attrpairs  \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [20] pairs [21]
 \cellsep 
\\




pairs      \cellsep   \protect\(\longrightarrow \protect\)  \cellsep  symbol object 
 \cellsep 
\\




           \cellsep  \protect\(|\protect\)                 \cellsep  symbol object pairs
 \cellsep 
\\




bvars     \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  [28] vars [29] 
 \cellsep 
\\




vars      \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  attrvar 
 \cellsep 
\\




          \cellsep   \protect\(|\protect\)               \cellsep  attrvar vars 
 \cellsep 
\\




attrvar   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  variable 
 \cellsep 
\\




          \cellsep   \protect\(|\protect\)               \cellsep  [18] attrpairs attrvar [19] 
 \cellsep 
\\




objects   \cellsep  \protect\(\longrightarrow \protect\)  \cellsep  
 \cellsep 
\\




          \cellsep  \protect\(|\protect\)               \cellsep  object objects 
 \cellsep 
\\


\end£tabularß





\caption£Grammar of the binary encoding of \emph£OpenMathß objects.ß\label£fig_bin-encß
\end£figureß










£Figure 4.3 gives a grammar for the binary encoding.  The
following conventions are used in this section: [\protect\(n\protect\)] denotes a byte
whose value is the integer \protect\(n\protect\) (\protect\(n\protect\) can range from 0 to 255), {\protect\(m\protect\)}
denotes four bytes representing the (unsigned) integer \protect\(m\protect\) in network
byte order, [_] denotes an arbitrary byte, {_} denotes an
arbitrary sequence of four bytes.  \emph£nameß:\protect\(n\protect\) denotes a sequence
of \protect\(n\protect\) bytes named \emph£nameß.  \emph£nameß:2\protect\(n\protect\) denotes a sequence of
\protect\(2n\protect\) bytes.  ``start'' is the start symbol of the grammar.ß



ß

£
\subsection£Description of the Grammarß\label£sec_bin-descß







£An \emph£OpenMathß object is encoded as a sequence of bytes starting with the
begin object tag (value 24) and ending with the end object tag
(value 25). These are similar to the \texttt£<OMOBJ>ß and \texttt£</OMOBJ>ß tags of
the \textsc£xmlß encoding.ß





£The encoding of each kind of \emph£OpenMathß object begins with a tag that is a
single byte, holding a \textsl£token identifierß and two flags, the \textsl£longß flag and the \textsl£sharedß flag. The identifier is stored in
the first 6 bits (1 to 6). The long flag is the eighth bit and the
shared flag is the seventh bit.ß





£Here is a description of the binary encodings of every kind of \emph£OpenMathß 
object:



\begin£descriptionß


\item[Integers]


£are encoded depending on how large they are. There are
  four possible formats.  Integers between -128 and 127 are encoded as
  the small integer tag (1) followed by a single byte that is the
  value of the integer (interpreted as a signed character). For
  example 16 is encoded as \texttt£0x01 0x10ß.  Integers between
  \protect\(-2\sp£31ß\protect\) (\protect\(-2147483648\protect\)) and \protect\(2\sp£31ß - 1\protect\) (\protect\(2147483647\protect\)) are encoded as
  the small integer tag with the long flag set followed by the integer
  encoded in little endian format on four bytes (network byte order:
  the most significant byte comes first). For example, 128 is encoded
  as \texttt£0x81ß \texttt£0x00000080ß.  The most general encoding begins
  with the big integer tag (token identifier 2) with the long flag set
  if the number of bytes in the encoding of the digits is greater or
  equal than 256. It is followed by the length (in bytes) of the
  sequence of digits, encoded on one byte (0 to 255, if the long flag
  was not set) or four bytes (network byte order, if the long flag was
  set).  It is then followed by a byte describing the sign and the
  base.  This 'sign/base' byte is \texttt£+ß (0x2B) or \texttt£-ß (0x2D)
  for the sign ored with the base mask bits that can be 0 for base 10
  or 0x40 for base 16.  It is followed by the strings of digits (as
  characters) in their natural order (as in the \textsc£xmlß
  encoding).  For example, 8589934592 (\protect\(2\sp£33ß\protect\)) is encoded \texttt£0x02
    0x0A 0x2B 0x38353839393334353932ß and xfffffff1 is
  encoded as \texttt£0x02 0x08 0x6b 0x6666666666666631ß.  Note that it is
  permitted to encode a ``small'' integer in any ``bigger'' format.ß


  



\item[Symbols]


£are encoded as the symbol tag (8) with the long flag
  set if the maximum of the length of the Content Dictionary name and
  the symbol name is greater than or equal to 256 (note that this
  should never be the case if the rules on symbols and Content
  Dictionary names are applied), then followed by the length of the
  Content Dictionary name as a byte (if the long flag was not set)
  or a four byte integer (in network byte order) followed by the
  length of the symbol name as a byte (if the long flag was not set)
  or a four byte integer (in network byte order), followed by the
  characters of the Content Dictionary name, followed by the
  characters of the symbol name.ß



  



\item[Variables]


£are encoded using the variable tag (5) with the long
  flag set if the number of bytes (characters) in the variable name is
  greater than or equal to 256 (this should never happen if the rules
  on variables are followed).  Then, there is the number of characters
  as a byte (if the long flag was not set) or a four byte integer
  (in network byte order), followed by the characters of the name of
  the variable. For example, the variable x is encoded as \texttt£0x05
    0x01 0x78ß.ß



  



\item[Floating-point number]


£are encoded using the floating-point
  number tag (3) followed by eight bytes that are the IEEE 754
  representation \cite£ieee754_85ß, most significant bytes first. For
  example, 0.1 is encoded as \texttt£0x03 0x000000000000f03fß.ß



  



\item[Character string]


£are encoded in two ways depending on whether
  the string contains \textsc£utf-16ß characters or not. If the
  string contains only 8 bit characters, it is encoded as the one
  byte character string tag (6) with the long flag set if the number
  of bytes (characters) in the string is greater than or equal to 256.
  Then, there is the number of characters as a byte (if the length
  flag was not set) or a four byte integer (in network byte order),
  followed by the characters in the string. If the string contains two
  byte characters, it is encoded as the two byte character string
  tag (7) with the long flag set if the number of characters in the
  string is greater or equal to 256. Then, there is the number of
  characters as a byte (if the long flag was not set) or a four byte
  integer (in network byte order), followed by the characters
  (\textsc£utf-16ß encoded  Unicode).ß


 
  



\item[Bytearrays]


£are encoded using the bytearray tag (4) with the
  long flag set if the number of bytes in the number of elements is
  greater than or equal to 256. Then, there is the number of elements,
  as a byte (if the long flag was not set) or a four byte integer
  (in network byte order), followed by the elements of the arrays in
  their normal order.ß


  
  



\item[Applications]


£are encoded using the application tag (16). More
  precisely, the application of \protect\(E\sb£0ß\protect\) to \protect\(E\sb£1ß\protect\)\ldots  \protect\(E\sb£nß\protect\) is encoded
  using the application tag (16), the sequence of the encodings of
  \protect\(E\sb£0ß\protect\) to \protect\(E\sb£nß\protect\) and the end application tag (17).ß


    



\item[Bindings]


£are encoded using the binding tag (26). More
  precisely, the binding by \protect\(B\protect\) of variables \protect\(V\sb£1ß\protect\)\ldots  \protect\(V\sb£nß\protect\) in
  \protect\(C\protect\) is encoded as the binding tag (26), followed by the encoding of
  \protect\(B\protect\), followed by the binding variables tag (28), followed by the
  encodings of the variables \protect\(V\sb£1ß\protect\) \ldots  \protect\(V\sb£nß\protect\), followed by the end
  binding variables tag (29), followed by the encoding of \protect\(C\protect\),
  followed by the end binding tag (27).ß



  



\item[Attribution]


£are encoded using the attribution tag (18). More
  precisely, attribution of the object \protect\(E\protect\) with (\protect\(S\sb£1ß\protect\), \protect\(E\sb£1ß\protect\)),
  \protect\(\ldots \protect\) (\protect\(S\sb£nß\protect\), \protect\(E\sb£nß\protect\)) pairs (where \protect\(S\sb£iß\protect\) are the attributes) is
  encoded as the attributed object tag (18), followed by the encoding
  of the attribute pairs as the attribute pairs tag (20), followed by
  the encoding of each symbol and value, followed by the end attribute
  pairs tag (21), followed by the encoding of \protect\(E\protect\), followed by the end
  attributed object tag (19).ß



    



\item[Error]


£are encoded using the error tag (22). More precisely,
  \protect\(S\sb£0ß\protect\) applied to \protect\(E\sb£1ß\protect\)\ldots  \protect\(E\sb£nß\protect\) is encoded as the error tag (22),
  the encoding of \protect\(S\sb£0ß\protect\), the sequence of the encodings of \protect\(E\sb£0ß\protect\) to
  \protect\(E\sb£nß\protect\) and the end error tag (23).ß






\end£descriptionß
 
ß


£
\subsubsection£Sharingß\label£sec_sharingß


 


£This binary encoding supports the sharing of symbols, variables and
strings (up to a certain length for strings) within one object. That
is, sharing between objects is not supported.  A reference to a shared
symbol, variable or string is encoded as the corresponding tag with
the long flag not set and the shared flag set, followed by a positive
integer \protect\(n\protect\) coded on one byte (0 to 255). This integer references the
\protect\(n + 1\protect\)-th such sharable sub-object (symbol, variable or string up to
255 characters) in the current \emph£OpenMathß object (counted in the order they
are generated by the encoding).  For example, \texttt£0x48 0x01ß
references a symbol that is identical to the second symbol that was
found in the current object.  Strings with 8 bit characters and
strings with 16 bit characters are two different kinds of objects for
this sharing. Only strings containing less than 256 characters can be
shared (i.e. only strings up to 255 characters).ß


ß
ß

£
\subsection£Implementation Noteß\label£sec_impl_noteß




£A typical implementation of the binary encoding uses four tables, each
of 256 entries, for symbol, variables, 8 bit character strings whose
lengths are less than 256 characters and 16 bit character strings
whose lengths are less than 256 characters.  When an object is read,
all the tables are first flushed. Each time a sharable sub-object is
read, it is entered in the corresponding table if it is not full. When
a reference to the shared i-th object of a given type is read, it
stands for the i-th entry in the corresponding table. It is an
encoding error if the i-th position in the table has not already been
assigned (i.e. forward references are not allowed).  Sharing is not
mandatory, there may be duplicate entries in the tables (if the
application that wrote the object chose not to share optimally).ß





£Writing an object is simple. The tables are first flushed. Each time a
sharable sub-object is encountered (in the natural order of output
given by the encoding), it is either entered in the corresponding
table (if it is not full) and output in the normal way or replaced by
the right reference if it is already present in the table.ß


ß

£
\subsection£Example of Binary Encodingß\label£sec_bin_exampleß





£As an example of this binary encoding, we can consider the \emph£OpenMathß object
whose \textsc£xmlß encoding is

\begin£verbatimß 
<OMOBJ>
  <OMA>
    <OMS name="times" cd="arith1"/>
    <OMA>
      <OMS name="plus" cd="arith1"/>
      <OMV name="x"/>
      <OMV name="y"/>
    </OMA>
    <OMA>
      <OMS name="plus" cd="arith1"/>
      <OMV name="x"/>
      <OMV name="z"/>
    </OMA>
  </OMA>
</OMOBJ>
\end{verbatim}
 
It is binary encoded as the sequence of bytes given by  the following table.ß



£\footnotesize
\begin£tabularߣcccccccccccccß



Hex  \cellsep     Meaning  \cellsep  Hex  \cellsep     Meaning 
 \cellsep 
\\




18   \cellsep     begin object tag    \cellsep    
68   \cellsep    h  .)
 \cellsep 
\\



 

10   \cellsep     begin application tag \cellsep 
31   \cellsep    1  .)
 \cellsep 
\\





08   \cellsep    symbol tag  \cellsep 
70   \cellsep    p (symbol name begin
 \cellsep 
\\





06   \cellsep     cd length  \cellsep 
6c   \cellsep    l  .
 \cellsep 
\\





05   \cellsep    name length \cellsep 
75   \cellsep    u  . 
 \cellsep 
\\





61   \cellsep     a (cd name begin \cellsep 
73   \cellsep    s  .) 
 \cellsep 
\\





72   \cellsep     r  . \cellsep 
05   \cellsep    variable tag 
 \cellsep 
\\





69   \cellsep    i  . \cellsep 
01   \cellsep    name length 
 \cellsep 
\\





74   \cellsep    t  . \cellsep 
78   \cellsep    x (name) 
 \cellsep 
\\





68   \cellsep    h  . \cellsep 
05   \cellsep    variable tag 
 \cellsep 
\\





31   \cellsep    1  .) \cellsep 
01   \cellsep    name length 
 \cellsep 
\\





74   \cellsep    t (symbol name begin \cellsep 
79   \cellsep    y (variable name) 
 \cellsep 
\\





69   \cellsep    i  . \cellsep 
11   \cellsep    end application tag 
 \cellsep 
\\





6d   \cellsep    m  . \cellsep 
10   \cellsep    begin application tag 
 \cellsep 
\\





65   \cellsep    e  . \cellsep 
48   \cellsep    symbol tag (with share bit on) 
 \cellsep 
\\





73   \cellsep    s  .) \cellsep 
01   \cellsep    reference to second symbol seen (arith1:plus) 
 \cellsep 
\\





10   \cellsep    begin application tag \cellsep 
45   \cellsep    variable tag (with share bit on) 
 \cellsep 
\\





08   \cellsep    symbol tag \cellsep 
00   \cellsep    reference to first variable seen (x) 
 \cellsep 
\\





06   \cellsep    cd length \cellsep 
05   \cellsep    variable tag 
 \cellsep 
\\





04   \cellsep    name length \cellsep 
01   \cellsep    name length 
 \cellsep 
\\





61   \cellsep    a (cd name begin \cellsep 
7a   \cellsep    z (variable name) 
 \cellsep 
\\





72   \cellsep    r  . \cellsep 
11   \cellsep    end application tag 
 \cellsep 
\\





69   \cellsep    i  . \cellsep 
11   \cellsep    end application tag 
 \cellsep 
\\





74   \cellsep    t  . \cellsep 
19   \cellsep    end object tag 
 \cellsep 
\\


\end£tabularßß
 

ß
ß

£
\section£Summaryß\label£sec_enc_summaryß





£The key points of this chapter are:

\begin£itemizeß


\item


£The \textsc£xmlß encoding for \emph£OpenMathß objects uses most common
  character sets.ß



\item


£The \textsc£xmlß encoding is readable, writable and can be
  embedded in most documents and transport protocols.ß



\item


£The binary encoding for \emph£OpenMathß objects should be used when
  efficiency is a key issue. It is compact yet simple enough to allow
  fast encoding and decoding of objects.ß



\end£itemizeß

ß


ß




\chapter£Content Dictionariesß\label£cha_cdß






£In this chapter we give a brief overview of Content Dictionaries
before explicitly stating their functionality and encoding.ß


£
\section£Introductionß\label£sec_cd_summaryß





£Content Dictionaries (CDs) are central to the \emph£OpenMathß philosophy of
transmitting mathematical information. It is the \emph£OpenMathß Content
Dictionaries which actually hold the meanings of the objects being
transmitted.ß





£For example if application \protect\(A\protect\) is talking to application \protect\(B\protect\), and
sends, say, an equation involving multiplication of matrices, then \protect\(A\protect\)
and \protect\(B\protect\) must agree on what a matrix is, and on what matrix
multiplication is, and even on what constitutes an equation. All this
information is held within some Content Dictionaries which both
applications agree upon.ß





£A \emph£ Content Dictionaryß holds the meanings of
(various) mathematical ``words''. These words are \emph£OpenMathß basic objects
referred to as \emph£symbolsß in Section 3.1.ß





£With a set of symbol definitions (perhaps from several content
Dictionaries), \protect\(A\protect\) and \protect\(B\protect\) can now talk in a common ``language''.ß





£It is important to stress that it is not Content Dictionaries
themselves which are being passed, but some ``mathematics'' whose
definitions are held within the Content Dictionaries. This means that
the applications must have already agreed on a set of Content
Dictionaries which they ``understand'' (i.e., can cope with to some
degree).ß






£In many cases, the Content
Dictionaries that an application understands will be constant, and be
intrinsic to the application's mathematical use. However the above
approach can also be used for applications which can handle
every Content Dictionary (such as an \emph£OpenMathß parser, or perhaps a
typesetting system), or alternatively for applications which
understand a changeable number of Content Dictionaries (perhaps after
being sent Content Dictionaries in some way).ß





£The primary use of Content Dictionaries is thought to be for designers
of Phrasebooks,the programs which translate between the
\emph£OpenMathß mathematical object and the corresponding (often internal)
structure of the particular application in question. For such a use
the Content Dictionaries have themselves been designed to be as
readable and precise as possible.ß





£Another possible use for \emph£OpenMathß Content Dictionaries could rely on their
automatic comprehension by a machine (e.g., when given definitions of
objects defined in terms of previously understood ones), in which case
Content Dictionaries may have to be passed as data. Towards this end,
a Content Dictionary has been written which contains a set of symbols
sufficient to represent any other Content Dictionary. This means that
Content Dictionaries may be passed in the same way as other (\emph£OpenMathß)
mathematical data.ß






£Finally, the syntax of the Content Dictionaries has been designed to
be relatively easy to learn and to write, and also free from the need
for any specialist software. This is because it is acknowledged that
there is an enormous amount of mathematical information to represent,
and so most of the Content Dictionaries will be written by
``ordinary'' mathematicians, encoding their particular fields of
expertise. 
A further reason is that the mathematics conveyed by a
specific Content Dictionary should be understandable independently of
any application.ß





£The key points from this section are:


\begin£itemizeß


\item


£Content Dictionaries should be readable and precise to help
  Phrasebook designers,ß



\item


£Content Dictionaries should be readily write-able to encourage
  widespread use,ß



\item


£It ought to be possible for a machine to understand a Content
  Dictionary to some degree.ß



\end£itemizeß

ß


ß

£
\section£Content Dictionariesß\label£sect_funcß





£In this section we define the overall structure of Content
Dictionaries.ß






£Other than Content Dictionary comments (which have no real semantics),
Content Dictionaries have been designed to hold two types of
information: that which is pertinent to the whole Content Dictionary,
and that which is restricted to a particular symbol definition.
Specific information pertaining to the symbols like the signature and
the defining mathematical properties is conveyed in additional files
associated to Content Dictionaries.ß





£Information that is pertinent to the whole Content Dictionary
includes:

\begin£itemizeß


\item


£The name of the Content Dictionary.ß



\item


£A description of the Content Dictionary.ß



\item


£A date when the Content Dictionary is next planned to be reviewed.ß



\item


£A date on which the Content Dictionary was last edited.ß



\item


£The current version and revision  numbers of the Content Dictionary.ß



\item


£The status of the Content Dictionary.ß



\item


£An optional URL for this Content Dictionary.ß



\item


£An optional list of Content Dictionaries on which this Content
  Dictionary depends. That is, those named in Examples and FMP
  in this Content Dictionary.ß



\item


£An optional comment, possibly containing the author's name.ß



\end£itemizeß

ß





£Information that is restricted to a particular symbol includes:

\begin£itemizeß


\item


£The name of the symbol.ß



\item


£A description of this symbol.ß



\item


£An optional comment.ß



\item


£Optional properties that this symbol should obey.ß



\item


£Optional examples of the use of this symbol.ß



\end£itemizeß

ß









£As mentioned earlier, certain kinds of data pertaining to symbols may
be conveyed in files other than a Content Dictionary.  In particular,
information on signatures according to a type system
may be described in \emph£Signature Filesß whose format is given in
Section 5.4.1. Other information such as
presentation forms, extra defining mathematical properties may be
associated with Content Dictionaries using files whose format is not
specified by this standard. It is expected that a common method
of defining the presentation for \emph£OpenMathß symbols is via
\textsc£xslß \cite£XSL_99ß stylesheets giving transformations to MathML.ß






£Content Dictionaries may be grouped into \emph£CD Groupsß. These
groups allow applications to easily refer to collections of Content
Dictionaries. One particular CDGroup of interest is the ``MathML
CDGroup''. This group expresses the collection of the core Content
Dictionaries that is designed to have the same semantic scope as the
content elements of MathML 2 \cite£MathML_2000ß.
 \emph£OpenMathß objects built from
symbols that come from Content Dictionaries in this CDGroup may be
expected to be eaily transformed between \emph£OpenMathß and MathML encodings.
The detailed structure of a CDGroup is described in
section Section 5.4.2 below.ß



ß

£
\section£The XML Encoding for Content Dictionariesß\label£sec_xml_cdß








£Content Dictionaries are XML documents.  A valid Content Dictionary
document should 

\begin£itemizeß


\item


£be valid according to  the DTD given in Figure 5.1,ß



\item


£adhere to the extra conditions on the content of the elements
  given in Section 5.3.2.ß



\end£itemizeß

ß







£An example of a complete Content Dictionary is given in
Appendix Appendix A.1, which is the \texttt£Metaß Content Dictionary
for describing Content Dictionaries themselves. A more typical Content
Dictionary is given in Appendix Appendix A.2, the \texttt£arith1ß
Content Dictionary for basic arithmetic functions.ß




£
\subsection£The DTD Specification of  Content Dictionariesß\label£sec_dtd_cdß





\begin£figureß


    
£\footnotesize
\begin£verbatimß
<!-- omcd.dtd -->
<!-- ********************************************* -->
<!--                                               -->
<!-- DTD for OpenMath CD                           -->
<!-- (c) EP24969 the ESPRIT OpenMath Consortium    -->
<!-- date = 28.aug.1998                            -->
<!-- author = s.buswell sb@stilo.demon.co.uk       -->
<!--                                               -->
<!-- edited by n.howgrave-graham 30.aug.98         -->
<!-- edited by sb 4.sep.98                         -->
<!-- edited by nh-g 4.sep.98                       -->
<!-- edited by sb 1.nov.98                         -->
<!-- edited by sb 1.nov.98                         -->
<!-- edited by dpc 1999-04-13                      -->
<!-- edited by dpc 1999-05-11  CDDate & CDVersion  -->
<!-- edited by dpc 1999-06-21  Delete Signature & Presentation  -->
<!--                           Force Name to be first child of -->
<!--                           CDDefinition -->
<!--                                               -->
<!--                                               -->
<!-- ********************************************* -->
<!ELEMENT CDComment      (#PCDATA) >
<!ELEMENT CDName         (#PCDATA) >
<!ELEMENT CDURL          (#PCDATA) >
<!ELEMENT CDUses         (CDName)*  >
<!ENTITY % inhel        "(#PCDATA)" >
<!ENTITY % inhel2       "(#PCDATA | OMOBJ)*" >
<!ELEMENT CDReviewDate   %inhel; >
<!ELEMENT CDDate         %inhel; >
<!ELEMENT CDVersion      %inhel; >
<!ELEMENT CDRevision     %inhel; >
<!ELEMENT CDStatus       %inhel; >
<!ELEMENT Description    %inhel; >
<!ELEMENT Name           %inhel; >
<!ELEMENT CMP            %inhel; >
<!-- include dtd for OM objects -->
<!ENTITY  % omobjectdtd SYSTEM "omobj.dtd" >
%omobjectdtd;
<!ELEMENT FMP            (OMOBJ) >             <!-- embedded OM -->
<!ELEMENT Example        %inhel2; >
<!ELEMENT CDDefinition    (Name, Description,
                          (CDComment | Example | FMP | CMP )*) >
<!ELEMENT CD             (CDComment | CDName | Description |
                         CDReviewDate | CDDate |CDVersion |CDRevision |
                         CDStatus | CDURL | CDUses | CDDefinition |
Example)* >
<!-- end of DTD for OM CD -->

\end{verbatim}\par\vspace£-10ptßß





\caption£DTD Specification of  Content Dictionariesß\label£fig_cd-dtdß
\end£figureß





£The XML DTD for Content Dictionaries is given in
Figure 5.1. The allowed elements are further
described in the following section.ß


ß

£
\subsection£Further Requirements of an \emph£OpenMathß Content Dictionaryß\label£sect_pcdataß






£The notion of being a valid Content Dictionary is stronger than merely
being successfully parsed by the DTD. This is because the content of
the elements, referred to in Figure 5.1 as PCDATA and
CDATA, must actually make sense to, say, a Phrasebook designer. In
this section we define exactly the format of the elements used in
Content Dictionaries.ß






\begin£descriptionß


\item[\texttt£CDNameß]


£The text occurring in the \texttt£CDNameß element
  corresponds to the name of Content Dictionary, and is of the form
  specified in Chapter 4.ß







\item[\texttt£Descriptionß]



£The text occurring in the \texttt£Descriptionß
  element is used to give a description of the enclosing element, which
  could be a symbol or the entire Content Dictionary. The content of
  this element can be any XML text.ß


  



\item[\texttt£CDReviewDateß]


£The text occurring in the \texttt£CDReviewDateß
  element corresponds to the earliest possible revision date of the
  Content Dictionary.  The date formats should be ISO-compliant in the
  form YYYY-MM-DD, e.g. 1953-09-26.ß


  



\item[\texttt£CDDateß]


£The text occurring in the \texttt£CDDateß element
  corresponds to the date of this version of the Content Dictionary.
  The date formats should be ISO-compliant in the form YYYY-MM-DD,
  e.g. 1953-09-26.ß


  



\item[\texttt£CDVersionß]

   
   
   

£The text occurring in the \texttt£CDVersionß element corresponds to
   the version number of the current version of a Content Dictionary.
   It should be a non negative integer.ß





£In CDs that do not have status \emph£experimentalß, CD version
  numbering should adhere to the following. The version number should
  be a positive integer.ß





£No changes can be
  introduced that invalidate objects built with previous versions.
  Any change that influences phrasebook compliance, like adding a new
  symbol to a Content Dictionary, is considered a major change.
  and should be reflected by an increase in this version number. Other
  changes, like adding an example or correcting a description, are
  considered minor changes. For minor changes the version number is not
  changed, but an increas should be made to the revision number, as
  described below. A change such as removing a symbol should
  not be made, instead a new CD, with a different name should be
  produced, so as not to invalidate existing objects.ß





£As detailed in chapter Chapter 6, \emph£OpenMathß compliant applications
  state which versions of which CDs they support.

  \emph£Experimentalß CDs may expect to have changes such as adding
  or removing symbols as they are developed, without requiring the name
  of the CD to be changed.ß



  



\item[\texttt£CDRevisionß]

   
   

£The text occurring in the \texttt£CDRevisionß element corresponds to
   the revision, or `minor version number' of the current version of a
   Content Dictionary.  It should be a non negative integer.ß





£Minor changes to a CD that do not warrant the release of a CD with
   an increased version number should be marked by increasing the
   revision number specified in this field. When the Cd Version number
   is increased, the Revision number is normally reset to zero.ß



  



\item[\texttt£CDStatusß]


£The text occurring in the \texttt£CDStatusß element
  corresponds to the status of Content Dictionary, and can be either
  \texttt£officialß (approved by the \emph£OpenMathß Society according to the
  procedure outlined in Section 5.5), \texttt£experimentalß
  (currently being tested), \texttt£privateß (used by a private group of
  \emph£OpenMathß users) or \texttt£obsoleteß (an obsolete Content Dictionary kept
  only for archival purposes).ß


  



\item[\texttt£CDURLß]


£The text occurring in the \texttt£CDURLß element
  should be a valid URL where the source file for the Content
  Dictionary encoding can be found (if it exists). The filename should
  conform to ISO 9660 \cite£ISO9660ß.ß






\item[\texttt£CDUsesß]

   
   

£The content of this element should be a series of \texttt£CDNameß
   elements, each naming a Content Dictionary used in the
   \texttt£Exampleß and \texttt£FMPßs of the current Content
   Dictionary. ß


   
 


\item[\texttt£CDCommentß]


£The content of this element should be text
   that does not convey any crucial information concerning the current
   Content Dictionary. It can be used in the Content Dictionary header
   to report the author of the Content Dictionary and to log change
   information. In the body of the Content Dictionary, it can be used
   to attach extra remarks to certain symbols.ß


   
   
 


\item[\texttt£Exampleß]





£The text occurring in the \texttt£Exampleß element is used to give
  examples of the enclosing symbol, and can be any XML text. In
  addition to text the element may contain examples as \textsc£xmlß encoded
  \emph£OpenMathß, inside \texttt£OMOBJß elements.  Note that \texttt£Examplesß must
  be with respect to some symbol and cannot be ``loose'' in the
  Content Dictionary.ß


  



\item[\texttt£Nameß]


£The text occurring in the \texttt£Nameß element
  corresponds to the name of the symbol, and is specified as in
  Chapter 4.ß

  
  



\item[\texttt£CMPß]



£The text occurring in the \texttt£CMPß element
  corresponds to a property of the symbol. An application which says
  it understands a Content Dictionary symbol need not understand a
  commented property of the symbol.ß


  



\item[\texttt£FMPß]


£The content of the \texttt£FMPß element also corresponds
  to a property\footnote£It corresponds to a theorem of a theory in
    some formal system.ß of the symbol, however the content of this
  element must be a valid \emph£OpenMathß object in the XML encoding.  An
  application which says it understands a Content Dictionary symbol
  need not understand a formal property of the symbol.ß





\end£descriptionß

ß
ß


£
\section£Additional Informationß\label£addfilesß








£Content Dictionaries contain just one part of the information that can
be associated to a symbol in order to stepwise define its meaning and
its functionality. \emph£OpenMathß Signature files, CDGroups, and possibly
files of extra mathematical properties, are used to convey the different
aspects that as a whole make up a mathematical definition.ß



£
\subsection£Signature Filesß\label£sigfilesß








£\emph£OpenMathß may be used with any type system. One just needs to produce a
Content Dictionary which gives the constructors of the type system,
and then one may build \emph£OpenMathß objects representing types in the given
type system. These are typically associated with \emph£OpenMathß objects via the
\emph£OpenMathß \textbf£attributionß constructor.ß





£A Small Type System, called STS, has been designed to give semi-formal
signatures to \emph£OpenMathß symbols and is documented in \cite£OM_D132cß.  The
signature file given in Appendix A.3 is based on this
formalism. Using the same mechanism, \cite£OMD132bß shows
how pure type systems can also be employed to assign types to \emph£OpenMathß 
symbols.ß




£
\subsubsection£The  DTD Specification of Signature Filesß\label£sec_dtd_sigß





£Signature Files are \textsc£xmlß documents, hence  a valid Signature File
 should 

\begin£itemizeß


\item


£be valid according to the \textsc£dtdß given in
  Figure 5.2,ß



\item


£adhere to the extra conditions on the content of the elements
  given in Section 5.4.1.2.ß



\end£itemizeß
ß






£Signature files have a header which specifies the Content Dictionary
and determines the type system being used, and the Content
Dictionary which contains the symbols for which the signatures are
being given. Each signature takes the form of an \textsc£xmlß encoded \emph£OpenMathß
object.ß





\begin£figureß


    

\begin£verbatimß
<!-- omcdsig.dtd -->
<!-- ********************************************* -->
<!--                                               -->
<!-- DTD for OpenMath CD Signatures                -->
<!-- (c) EP24969 the ESPRIT OpenMath Consortium    -->
<!-- David Carlisle 1999-04-13                     -->
<!-- David Carlisle 1999-05-21                     -->
<!-- David Carlisle 1999-06-22                     -->
<!--                                               -->
<!--                                               -->
<!-- ********************************************* -->

<!-- include dtd for OM objects -->
<!ENTITY  % omobjectdtd SYSTEM "omobj.dtd" >
%omobjectdtd;

<!ELEMENT CDSComment      (#PCDATA) >
<!ELEMENT CDSReviewDate    (#PCDATA) >
<!ELEMENT CDSStatus    (#PCDATA) >

<!ELEMENT CDSignatures   (CDComment |CDSComment | CDSReviewDate |
                         CDSStatus | Signature )* >

<!ATTLIST CDSignatures cd CDATA #REQUIRED
                       type CDATA #REQUIRED >

<!ELEMENT Signature      (OMOBJ?) >

<!ATTLIST  Signature  name CDATA #REQUIRED >

<!-- end of DTD for OM CD Signatures -->
\end{verbatim}



\caption£DTD Specification of Signature Filesß\label£fig_omcdsig.dtdß
\end£figureß

ß

£
\subsubsection£Further Requirements of a Signature Fileß\label£sect_sigpcdataß







£The notion of being a valid Signature File is stronger than merely
being successfully parsed by the \textsc£dtdß in Figure 5.2.
In this section we define exactly the format of the elements used in
Signature Files. Several of the requirements are the same as those on
elements of Contents Dictionaries.ß





\begin£descriptionß


\item[\texttt£CDSignaturesß]


£The outermost element of the Signature File
  is characterized by two required attributes that identify the type
  system and the Content Dictionary whose signatures are defined. The
  value of the \textsc£xmlß attribute \texttt£typeß is the name of the Content
  Dictionary or of the CDGroup (cfg. Section 5.4.2) that
  represents the type system. The value of the XML attribute
  \texttt£cdß is the name of the Content Dictionary whose symbols are
  assigned signatures in this Signature File. Both values are of the
  form specified in Chapter 4.ß


  



\item[\texttt£CDSCommentß]


£See \texttt£CDCommentß in
  Section 5.3.2.ß






\item[\texttt£CDSreviewDateß]


£The text occurring in the \texttt£CDSReviewDateß element corresponds to the earliest possible
  revision date of the Signature File.  The date formats should be
  ISO-compliant in the form YYYY-MM-DD, e.g. 2000-02-29.ß


  



\item[\texttt£CDSStatusß]


£The text occurring in the \texttt£CDSStatusß
  element corresponds to the status of the Signature File, and can be
  either \texttt£officialß (approved by the \emph£OpenMathß Society according to the
  procedure outlined in Section 5.5), \texttt£experimentalß
  (currently being tested), \texttt£privateß (used by a private group of
  \emph£OpenMathß users) or \texttt£obsoleteß (an obsolete Signature File kept only
  for archival purposes).ß


  



\item[\texttt£Signatureß]





£The content of the \texttt£Signatureß element
  has to be a valid \emph£OpenMathß object in \textsc£xmlß encoding as specified in
  Chapter 4. Additionally, the object must represent a
  valid type in the type system identified by the
  XML attribute \texttt£typeß of the \texttt£CDSignatureß element. See
  Section 5.4.1.3 for examples.ß






\end£descriptionß

ß


£
\subsubsection£Examplesß\label£sect_sigexß





£An example of a signature file for the type system STS and the
\texttt£arith1ß Content Dictionary is given in
Appendix A.3. Each
signature entry is similar to the
following one for the \emph£OpenMathß symbol 
\texttt£<OMS cd="arith1" name="plus"/>ß:

\begin£verbatimß
<Signature name="plus">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMA>
   <OMS name="nassoc" cd="sts"/> 
   <OMV name="AbelianSemiGroup"/>
  </OMA>
  <OMV name="AbelianSemiGroup"/>
 </OMA>
</OMOBJ>
</Signature>
\end{verbatim}

ß


ß
ß

£
\subsection£CDGroupsß\label£ssec_cdgroupsß









£The CD Group mechanism is a convenience mechanism for identifying
collections of CDs.  A CD Group file is an \textsc£xmlß document used in the
(static or dynamic) negotiation phase where communicating applications
declare and agree on the Content Dictionaries which they process.  It
is a complement, or an alternative, to the individual declaration of
Content Dictionaries understood by an application.  Note that
CD Groups do \emph£notß affect the \emph£OpenMathß objects themselves.
Symbols in an object always refer to content dictionaries, not groups.ß






£For an application to declare that it ``understands CDGroup G'' is
exactly equivalent to, and interchangable with, the declaration that it 
``understands Content Dictionaries \protect\(x\sb£1ß\protect\), \protect\(x\sb£2ß\protect\), \ldots  \protect\(x\sb£nß\protect\)'', where
\protect\(x\sb£1ß\protect\), \ldots  \protect\(x\sb£nß\protect\) are the members of CDGroup G.ß




£
\subsubsection£The DTD Specification of CDGroupsß\label£sec_dtd_cdgß






£CDGroups are XML documents, hence  a valid  CDGroup
 should 

\begin£itemizeß


\item


£be valid according to the DTD given in
  Figure 5.3,ß



\item


£adhere to the extra conditions on the content of the elements
  given in Section 5.4.2.2.ß



\end£itemizeß

ß





£Apart from some header information such as \texttt£CDGroupNameß and
\texttt£CDGroupß version, a CDGroup is simply an unordered list of
CDs, identified by name and optionally version number and URL.ß





\begin£figureß


    

\begin£verbatimß
<!-- CDgroup.dtd -->
<!-- ********************************************* -->
<!--                                               -->
<!-- DTD for OpenMath CD group                     -->
<!-- (c) EP24969 the ESPRIT OpenMath Consortium    -->
<!-- date = 18.Feb.1999                            -->
<!-- author = s.buswell sb@stilo.demon.co.uk       -->
<!--                                               -->
<!--                                               -->
<!-- available at                                  -->
<!-- http://www.nag.co.uk/~something here David~  -->
<!--                                               -->
<!-- ********************************************* -->

<!-- info on the CD group itself -->

<!ELEMENT CDGroupName      (#PCDATA) >
<!ELEMENT CDGroupVersion     (#PCDATA) >
<!ELEMENT CDGroupRevision     (#PCDATA) >
<!ELEMENT CDGroupURL          (#PCDATA) >
<!ELEMENT CDGroupDescription  (#PCDATA) >

<!-- info on the CDs in the group  -->

<!ELEMENT CDComment     (#PCDATA) >
<!ELEMENT CDGroupMember (CDComment?,CDName, CDVersion?, CDURL?) >
<!ELEMENT CDName     (#PCDATA) >
<!ELEMENT CDVersion     (#PCDATA) >
<!ELEMENT CDURL         (#PCDATA) >

<!-- structure of the group -->
<!ELEMENT CDGroup 
   (CDGroupName, CDGroupVersion, CDGroupRevision?,
    CDGroupURL, CDGroupDescription,
     (CDGroupMember  | CDComment )* ) >

<!-- end of DTD for OM CDGroup -->
\end{verbatim}




\caption£DTD Specification of CDGroupsß\label£fig_cdgroup.dtdß
\end£figureß

ß

£
\subsubsection£Further Requirements of a CDGroupß\label£sect_cdgpcdataß








£The notion of being a valid CDGroup implies that the following
requirements on the content of the elements described by the DTD in
Figure 5.2 are also met.ß





\begin£descriptionß


\item[\texttt£CDGroupß]



£The XML element \texttt£CDGroupß is the outermost
  element in a CDGroup document.ß


  



\item[\texttt£CDGroupNameß]





£The text occurring in the \texttt£CDGroupNameß
  element corresponds to the name of the CDGroup. For the syntactical
  requirements, see \texttt£CDNameß in Section 5.3.2.ß


  



\item[\texttt£CDGroupURLß]



£The text occurring in the \texttt£CDGroupURLß
  element identifies the location of the CDGroup file, not necessarily
  of the member Content Dictionaries. For the syntactical
  requirements, see \texttt£CDURLß in Section 5.3.2.ß


  



\item[\texttt£CDGroupDescriptionß]



£The text occurring in the \texttt£CDGroupDescriptionß element describes the mathematical area of the
  CDGroup.ß


  



\item[\texttt£CDGroupMemberß]



£The XML element \texttt£CDGroupMemberß
  encloses the data identifying each member of the CDGroup.ß


  



\item[\texttt£CDNameß]


£The text occurring in the \texttt£CDNameß element
  corresponds to the name of a Content Dictionary in the CDGroup. For
  the syntactical requirements, see \texttt£CDNameß in
  Section 5.3.2.ß


  



\item[\texttt£CDVersionß]


£The text occurring in the \texttt£CDVersionß
  element identifies which version of the Content Dictionary isto be
  taken as member of the CDGroup. This element is optional. In case it
  is missing, the latest version is the one included in the CDGroup.
  For the syntactical requirements, see \texttt£CDVersionß in
  Section 5.3.2.ß


  



\item[\texttt£CDURLß]





£The text occurring in the \texttt£CDURLß element
  identifies the location of the Content Dictionary to be taken as
  member of the CDGroup. This element is optional. In case it is
  missing, the location of the CDGroup identified by the element
  \texttt£CDGroupURLß is assumed.
  For the syntactical requirements, see \texttt£CDURLß
  in Section 5.3.2.ß


  



\item[\texttt£CDCommentß]


£See \texttt£CDCommentß in
  Section 5.3.2.ß








\end£descriptionß









ß
ß
ß

£
\section£Content Dictionaries Reviewing Processß\label£cdapproveß







£The \emph£OpenMathß Society is responsible  for implementing a
review and referee process to assess the accuracy of the mathematical
content of Content Dictionaries.  The status (see \texttt£CDStatusß)
and/or the version number (see \texttt£CDVersionß ) of a Content
Dictionary may change as a result of this review process.ß


ß








\chapter£\emph£OpenMathß Complianceß\label£cha_compß






£Applications that meet the requirements specified in this chapter may
label themselves as \emph£OpenMath compliantß. \emph£OpenMathß compliancy is
defined so as to maximize the potential for interoperability amongst
\emph£OpenMathß applications.ß



£
\section£Encodingß\label£sec_compl_encodingß




£This standard defines two reference encodings for \emph£OpenMathß, the binary
encoding and XML encoding,  defined in chapter Chapter 4.ß





£As a minimum, an \emph£OpenMathß compliant application, which accepts or generates
\emph£OpenMathß objects, \emph£mustß be capable of doing so using  the XML encoding.
The ability to use other encodings is optional.ß


ß

£
\section£Content Dictionariesß\label£sec_compl_cdß





£An \emph£OpenMathß compliant application  \emph£mustß be able to support the error
Content Dictionary defined in Appendix A.5.ß





£A compliant application must declare the names and version numbers of
the Content Dictionaries that it supports. Equivalently it may declare
the Content Dictionary Group (or groups) and major version number (not
revision number), rather than listing individual Content Dictionaries.
Applications that support all Content Dictionaries (e.g. renderers)
should refer to the implicit CD Group \texttt£allß.ß





£If a compliant application supports a Content Dictionary then it must
explicitly declare any symbols in the Content Dictionaries that are not
supported. Phrasebooks are encouraged to support every symbol in the 
Content Dictionaries.ß





£Symbols which are not listed as unsupported are \emph£supportedß by
the application. The meaning of \emph£supportedß will depend on the
application domain. For example an \emph£OpenMathß renderer should provide a
default display for any \emph£OpenMathß object that only references supported
symbols, whereas a Computer Algebra System will be expected to map
such an object to a suitable internal representation, in this system,
of this mathematical object. It is expected that the application's
\emph£phrasebooksß for supported Content Dictionaries will be
constructed such that propertes of the symbol expressed in the Content
Dictionary are respected as far as possible for the given application
domain. However \emph£OpenMathß compliance does \emph£notß imply
any guarantee by the \emph£OpenMathß Society on the accuracy of these representations.ß






£Content Dictionaries available from the official \emph£OpenMathß repository at
www.openmath.org need only be referenced by name, other Content
Dictionaries \emph£shouldß be referenced by the URL declared in the
\texttt£CDURLß field of the Dictionary. This URL may be used to
retrieve the Content Dictionary.ß





£When receiving an \emph£OpenMathß symbol, e.g. \protect\(s\protect\),  that is not supported from a
 supported Content Dictionary,  a compliant
application will act as if it had received the \emph£OpenMathß object
\protect\[\mathbf£errorß(Unhandled_Symbol,s)\protect\]
where \texttt£Unhandled_Symbolß is the symbol from the error Content
Dictionary.ß






£Similarly if it receives a symbol, e.g. \protect\(s\protect\), from an unsupported Content
Dictionary,
it  will act as if it had received the \emph£OpenMathß object
\protect\[\mathbf£errorß(Unsupported_CD,s)\protect\]ß





£Finally if the compliant application receives a symbol from a supported
Content Dictionary but with an unknown name, then this must either be
an incorrect object, or possibly the object has been built using a
later version of the Content Dictionary. In either case, the
application will act as if it had received the \emph£OpenMathß object
\protect\[\mathbf£errorß(Unexpected_Symbol,s)\protect\]ß


ß

£
\section£Lexical Errorsß\label£sec_comp_lexß





£The previous section defines the behaviour of a compliant application
upon receiving well formed \emph£OpenMathß objects containing unexpected symbols.
This standard does not specify any behaviour for an application upon
receiving ill-formed objects.ß


ß




\chapter£Conclusionß\label£cha_concß






£The goal of this document is to define the \emph£OpenMathß standard. The things
are addressed by the \emph£OpenMathß standard are:

\begin£itemizeß


\item


£Informal and formal definition of the \emph£OpenMathß objects.ß



\item


£Informal and formal definition of the notion of Content
  Dictionaries.ß



\end£itemizeß

To do this, \emph£OpenMathß objects are precisely defined and two encodings are
described to represent these objects using \textsc£xmlß and binary
code. Furthermore, the Document Type Definition for validating Content
Dictionaries and \emph£OpenMathß objects is given.ß









\appendix


\chapter£CD Filesß\label£app_cdfilesß



\clearpage£
\section£The \textbf£metaß Content Dictionaryß\label£app_cdcdß




\begin£verbatimß
<CD>

<CDName> meta </CDName>

<Description> 

This is a content dictionary to represent content dictionaries, so
that they may be passed between OpenMath compliant application in a
similar way to mathematical objects.  It is acknowledged that this is
not the only way to do this, but it seems a natural way.

This can be viewed as updating the previous Meta-CD.

The information written here is taken from "The OpenMath Standard".
This document is a slightly stronger statement than "the following
symbols are defined as in the DTD at
http://www.nag.co.uk/projects/OpenMath/omstd/dtds/cd.dtd", since the
DTD often only says that the information inside the elements is PCDATA
without saying what this actually corresponds to. However this is the
only way this document is better than the DTD, and thus this is the
only extra information we give here.

Author: N. Howgrave-Graham
</Description>

<CDReviewDate> 1998-10-01 </CDReviewDate>
<CDStatus> experimental </CDStatus>
<CDURL> http://www.nag.co.uk/projects/OpenMath/omstd/cds/meta.ocd </CDURL>

<CDComment>
This is how one uses comments.

This whole document must be valid XML which means that we cannot have
sub-elements inside elements where we are expecting PCDATA. For this
reason it is suggested that one use the unicode characters when
clashes occur. For example &lt; and &gt; for less than and more than.
</CDComment>

<CDDefinition>
<Name> CD </Name>
<Description>
The DTD fully specifies the use of the CD tag
</Description>
</CDDefinition>

<CDDefinition>
<Name> CDDescription </Name>
<Description>
The DTD fully specifies the use of the CDDescription tag
</Description>
</CDDefinition>

<CDComment>
For those that do not have access to the DTD, the tagged entries
are the following (in no particular order):

&lt;CD&gt;
&lt;CDName&gt; &lt;/CDName&gt;
&lt;Description&gt; &lt;/Description&gt;
&lt;CDReviewDate&gt; &lt;/CDReviewDate&gt;
&lt;CDStatus&gt; &lt;/CDStatus&gt;
&lt;CDURL&gt;? &lt;/CDURL&gt;
&lt;CDUses&gt;? &lt;CDUses&gt;
&lt;CDDefinition&gt;*
&lt;Name&gt; &lt;/Name&gt;
&lt;Description&gt; &lt;/Description&gt;
&lt;Signature&gt;? &lt;/Signature&gt;
&lt;Example&gt;* &lt;/Example&gt;
&lt;FMP&gt;* &lt;/FMP&gt;
&lt;CMP&gt;* &lt;/CMP&gt;
&lt;Presentation&gt;? &lt;/Presentation&gt;
&lt;/CDDefinition&gt;

where an asterisk (?) denotes it can repeated 0 or 1 times, and a star
(*) denotes 0 or more times.
</CDComment>

<CDDefinition>
<Name> CDName </Name>
<Description>
A tag which contains PCDATA corresponding to the name of the CD.
</Description>
</CDDefinition>

<CDDefinition>
<Name> CDURL </Name>
<Description>
An optional tag which contains PCDATA corresponding to the URL where
the CD is stored.
</Description>
</CDDefinition>

<CDDefinition>
<Name> Example </Name>
<Description>
A tag which contains PCDATA to give an example of the
enclosing symbol definition.
</Description>
</CDDefinition>

<CDDefinition>
<Name> CDReviewDate </Name>
<Description>
A tag which contains PCDATA to give an expiry date of
the CD.  It should be in the form of ISO-8601, i.e. YYYY-MM-DD
</Description>
</CDDefinition>

<CDDefinition>
<Name> CDStatus </Name>
<Description>
A tag which contains PCDATA to give information on the
status of the CD. This can be either official (approved by the
OpenMath steering committee), experimental (currently being tested),
private (used by a private group of OpenMath users) or obsolete
(an obsolete CD kept only for archival purposes).
</Description>
</CDDefinition>

<CDDefinition>
<Name> CDUses </Name>
<Description>
A tag which contains zero or more CDNames which correspond
to the CD's that this CD depends on. This makes an inheritance
structure for CD's. If the CD is dependent on any other CD's they must
be present here.
</Description>
</CDDefinition>

<CDDefinition>
<Name> CDTypeUses </Name>
<Description>
A tag which contains zero or more CDNames which correspond
to the CD's that hold type information that this CD depends on. This
makes an inheritance type structure for CD's. If the CD types are
dependent on any other CD's they must be present here. For application
that do not respect types, this symbol can be ignored.
</Description>
</CDDefinition>

<CDDefinition>
<Name> Description </Name>
<Description>
A tag which contains PCDATA corresponding to the
description of either the CD or the symbol (depending on which is the
enclosing element).
</Description>
</CDDefinition>

<CDDefinition>
<Name> Name </Name>
<Description>
A tag which contains PCDATA corresponding to the name of
the symbol being defined.
</Description>
</CDDefinition>

<CDDefinition>
<Name> Signature </Name>
<Description>
An optional tag which contains PCDATA corresponding to
the type of the symbol being defined. This type information will be
an OpenMath type object as defined in chapter 5 of "First Draft of the
OpenMath Standard".
</Description>
</CDDefinition>

<CDDefinition>
<Name> Presentation </Name>
<Description>
An optional tag (which may be repeated many times) which contains
PCDATA corresponding to a way of presenting the symbol being defined.
</Description>
</CDDefinition>

<CDDefinition>
<Name> CMP </Name>
<Description>
An optional tag (which may be repeated many times) which contains
PCDATA corresponding to a property of the symbol being
defined.
</Description>
</CDDefinition>

<CDDefinition>
<Name> FMP </Name>
<Description>
An optional tag (which may be repeated many times) which contains
PCDATA corresponding to a property of the symbol being
defined. This property must be a valid OpenMath object.
</Description>
</CDDefinition>

</CD>
\end{verbatim}

ß

\clearpage£
\section£The  \textbf£arith1ß Content Dictionary Fileß\label£arith1.ocdß





\begin£verbatimß
<CD>
<CDName> arith1 </CDName>
<CDURL> http://www.openmath.org/cd/arith1.ocd </CDURL>
<CDReviewDate> 2003-04-01 </CDReviewDate>
<CDStatus> official </CDStatus>
<CDDate> 2001-03-12 </CDDate>
<CDVersion> 2 </CDVersion>
<CDRevision> 0 </CDRevision>
<CDUses>
  <CDName>alg1</CDName>
  <CDName>fns1</CDName>
  <CDName>integer1</CDName>
  <CDName>interval1</CDName>
  <CDName>linalg2</CDName>
  <CDName>logic1</CDName>
  <CDName>quant1</CDName>
  <CDName>relation1</CDName>
  <CDName>set1</CDName>
  <CDName>setname1</CDName>
  <CDName>transc1</CDName>
</CDUses>

<Description> 
This CD defines symbols for common arithmetic functions.
</Description>

<CDDefinition>
<Name> lcm </Name>
<Description> 
The symbol to represent the n-ary function to return the least common
multiple of its arguments.
</Description>

<CMP> lcm(a,b) = a*b/gcd(a,b) </CMP>

<FMP>
<OMOBJ>
  <OMA>
    <OMS cd="relation1" name="eq"/>
    <OMA>
      <OMS cd="arith1" name="lcm"/>
      <OMV name="a"/>
      <OMV name="b"/>
    </OMA>
    <OMA>
      <OMS cd="arith1" name="divide"/>
      <OMA>
        <OMS cd="arith1" name="times"/>
	<OMV name="a"/>
	<OMV name="b"/>
      </OMA>
      <OMA>
        <OMS cd="arith1" name="gcd"/>
        <OMV name="a"/>
        <OMV name="b"/>
      </OMA>
    </OMA>
  </OMA>
</OMOBJ>
</FMP>
<CMP>
for all integers a,b |
There does not exist a c>0 such that c/a is an Integer and c/b is an
Integer and lcm(a,b) > c.
</CMP>

<FMP>
<OMOBJ>
<OMBIND>
  <OMS cd="quant1" name="forall"/>
  <OMBVAR>
    <OMV name="a"/>
    <OMV name="b"/>
  </OMBVAR>
  <OMA>
    <OMS cd="logic1" name="implies"/>
    <OMA>
      <OMS cd="logic1" name="and"/>
      <OMA>
        <OMS cd="set1" name="in"/>
	<OMV name="a"/>
	<OMS cd="setname1" name="Z"/>
      </OMA>
      <OMA>
        <OMS cd="set1" name="in"/>
	<OMV name="b"/>
	<OMS cd="setname1" name="Z"/>
      </OMA>
    </OMA>
    <OMA>
      <OMS cd="logic1" name="not"/>
      <OMBIND>
        <OMS cd="quant1" name="exists"/>
        <OMBVAR>
          <OMV name="c"/>
        </OMBVAR>
        <OMA>
          <OMS cd="logic1" name="and"/>
          <OMA>
            <OMS cd="relation1" name="gt"/>
              <OMV name="c"/>
              <OMI>0</OMI>
          </OMA>
          <OMA>
            <OMS cd="integer1" name="factorof"/>
              <OMV name="a"/>
              <OMV name="c"/>
          </OMA>
          <OMA>
            <OMS cd="integer1" name="factorof"/>
              <OMV name="b"/>
              <OMV name="c"/>
          </OMA>
          <OMA>
            <OMS cd="relation1" name="lt"/>
            <OMV name="c"/>
            <OMA>
              <OMS cd="arith1" name="lcm"/>
              <OMV name="a"/>
              <OMV name="b"/>
            </OMA>
          </OMA>
        </OMA>
      </OMBIND>
    </OMA>
  </OMA>
</OMBIND>
</OMOBJ>
</FMP>
</CDDefinition>

<CDDefinition>
<Name> gcd </Name>
<Description> 
The symbol to represent the n-ary function to return the gcd (greatest
common divisor) of its arguments.
</Description>

<CMP>
for all integers a,b |
There does not exist a c such that a/c is an Integer and b/c is an
Integer and c > gcd(a,b).

Note that this implies that gcd(a,b) > 0
</CMP>

<FMP>
<OMOBJ>
<OMBIND>
  <OMS cd="quant1" name="forall"/>
  <OMBVAR>
    <OMV name="a"/>
    <OMV name="b"/>
  </OMBVAR>
  <OMA>
    <OMS cd="logic1" name="implies"/>
    <OMA>
      <OMS cd="logic1" name="and"/>
      <OMA>
        <OMS cd="set1" name="in"/>
	<OMV name="a"/>
	<OMS cd="setname1" name="Z"/>
      </OMA>
      <OMA>
        <OMS cd="set1" name="in"/>
	<OMV name="b"/>
	<OMS cd="setname1" name="Z"/>
      </OMA>
    </OMA>
    <OMA>
      <OMS cd="logic1" name="not"/>
      <OMBIND>
        <OMS cd="quant1" name="exists"/>
        <OMBVAR>
          <OMV name="c"/>
        </OMBVAR>
        <OMA>
          <OMS cd="logic1" name="and"/>
          <OMA>
            <OMS cd="set1" name="in"/>
            <OMA>
              <OMS cd="arith1" name="divide"/>
              <OMV name="a"/>
              <OMV name="c"/>
            </OMA>
            <OMS cd="setname1" name="Z"/>
          </OMA>
          <OMA>
            <OMS cd="set1" name="in"/>
            <OMA>
              <OMS cd="arith1" name="divide"/>
              <OMV name="b"/>
              <OMV name="c"/>
            </OMA>
            <OMS cd="setname1" name="Z"/>
          </OMA>
          <OMA>
            <OMS cd="relation1" name="gt"/>
            <OMV name="c"/>
            <OMA>
              <OMS cd="arith1" name="gcd"/>
              <OMV name="a"/>
              <OMV name="b"/>
            </OMA>
          </OMA>
        </OMA>
      </OMBIND>
    </OMA>
  </OMA>
</OMBIND>
</OMOBJ>
</FMP>

<Example>
gcd(6,9) = 3
<OMOBJ>
  <OMA>
    <OMS cd="relation1" name="eq"/>
    <OMA>
      <OMS cd="arith1" name="gcd"/>
      <OMI> 6 </OMI>
      <OMI> 9 </OMI>
    </OMA>
    <OMI> 3 </OMI>
  </OMA>
</OMOBJ>
</Example>
</CDDefinition>

<CDDefinition>
<Name> plus </Name>
<Description>
The symbol representing an n-ary commutative function plus.
</Description>
<CMP> for all a,b | a + b = b + a </CMP>
<FMP>
<OMOBJ>
  <OMBIND>
    <OMS cd="quant1" name="forall"/>
    <OMBVAR>
       <OMV name="a"/>
       <OMV name="b"/>
    </OMBVAR>
    <OMA>
      <OMS cd="relation1" name="eq"/>
      <OMA>
        <OMS cd="arith1" name="plus"/>
        <OMV name="a"/>
        <OMV name="b"/>
      </OMA>
      <OMA>
        <OMS cd="arith1" name="plus"/>
        <OMV name="b"/>
        <OMV name="a"/>
      </OMA>
    </OMA>
  </OMBIND>
</OMOBJ>
</FMP>
</CDDefinition>

<CDDefinition>
<Name> unary_minus </Name>
<Description> 
This symbol denotes unary minus, i.e. the additive inverse.
</Description>
<CMP> for all a | a + (-a) = 0 </CMP>
<FMP>
<OMOBJ>
  <OMBIND>
    <OMS cd="quant1" name="forall"/>
    <OMBVAR>
       <OMV name="a"/>
    </OMBVAR>
    <OMA>
      <OMS cd="relation1" name="eq"/>
      <OMA>
        <OMS cd="arith1" name="plus"/>
        <OMV name="a"/>
        <OMA>
           <OMS cd="arith1" name="unary_minus"/>
           <OMV name="a"/>
        </OMA>
      </OMA>
      <OMS cd="alg1" name="zero"/>
    </OMA>
  </OMBIND>
</OMOBJ>
</FMP>
</CDDefinition>

<CDDefinition>
<Name> minus </Name>
<Description> 
The symbol representing a binary minus function. This is equivalent to
adding the additive inverse.
</Description>
<CMP> for all a,b | a - b = a + (-b) </CMP>
<FMP>
<OMOBJ>
  <OMBIND>
    <OMS cd="quant1" name="forall"/>
    <OMBVAR>
       <OMV name="a"/>
       <OMV name="b"/>
    </OMBVAR>
    <OMA>
      <OMS cd="relation1" name="eq"/>
      <OMA>
        <OMS cd="arith1" name="minus"/>
        <OMV name="a"/>
        <OMV name="b"/>
      </OMA>
      <OMA>
        <OMS cd="arith1" name="plus"/>
        <OMV name="a"/>
        <OMA>
          <OMS cd="arith1" name="unary_minus"/>
          <OMV name="b"/>
        </OMA>
      </OMA>
    </OMA>
  </OMBIND>
</OMOBJ>
</FMP>
</CDDefinition>

<CDDefinition>
<Name> times </Name>
<Description> 
The symbol representing an n-ary multiplication function.
</Description>
<Example>
<OMOBJ>
<OMA>
  <OMS cd="relation1" name="eq"/>
  <OMA>
    <OMS cd="arith1" name="times"/>
    <OMA>
      <OMS cd="linalg2" name="matrix"/>
      <OMA>
        <OMS cd="linalg2" name="matrixrow"/>
        <OMI> 1 </OMI>
        <OMI> 2 </OMI>
      </OMA>
      <OMA>
        <OMS cd="linalg2" name="matrixrow"/>
        <OMI> 3 </OMI>
        <OMI> 4 </OMI>
      </OMA>
    </OMA>
    <OMA>
      <OMS cd="linalg2" name="matrix"/>
      <OMA>
        <OMS cd="linalg2" name="matrixrow"/>
        <OMI> 5 </OMI>
        <OMI> 6 </OMI>
      </OMA>
      <OMA>
        <OMS cd="linalg2" name="matrixrow"/>
        <OMI> 7 </OMI>
        <OMI> 8 </OMI>
      </OMA>
    </OMA>
  </OMA>
  <OMA>
    <OMS cd="linalg2" name="matrix"/>
    <OMA>
      <OMS cd="linalg2" name="matrixrow"/>
      <OMI> 19 </OMI>
      <OMI> 20 </OMI>
    </OMA>
    <OMA>
      <OMS cd="linalg2" name="matrixrow"/>
      <OMI> 43 </OMI>
      <OMI> 50 </OMI>
    </OMA>
  </OMA>
</OMA>
</OMOBJ>
</Example>
<CMP> for all a,b | a * 0 = 0 and a * b = a * (b - 1) + a </CMP>

<FMP><OMOBJ>
<OMBIND>
  <OMS cd="quant1" name="forall"/>
  <OMBVAR>
    <OMV name="a"/>
    <OMV name="b"/>
  </OMBVAR>
  <OMA>
    <OMS cd="logic1" name="and"/>
    <OMA>
      <OMS cd="relation1" name="eq"/>
      <OMA>
        <OMS cd="arith1" name="times"/>
        <OMV name="a"/>
        <OMS cd="alg1" name="zero"/>
      </OMA>
      <OMS cd="alg1" name="zero"/>
    </OMA>
    <OMA>
      <OMS cd="relation1" name="eq"/>
      <OMA>
        <OMS cd="arith1" name="times"/>
	<OMV name="a"/>
	<OMV name="b"/>
      </OMA>
      <OMA>
        <OMS cd="arith1" name="plus"/>
	<OMA>
	  <OMS cd="arith1" name="times"/>
	  <OMV name="a"/>
	  <OMA>
	    <OMS cd="arith1" name="minus"/>
	    <OMV name="b"/>
	    <OMS cd="alg1" name="one"/>
	  </OMA>
	</OMA>
	<OMV name="a"/>
      </OMA>
    </OMA>
  </OMA>
</OMBIND>
</OMOBJ></FMP>

<CMP> for all a,b,c | a*(b+c) = a*b + a*c </CMP>
<FMP><OMOBJ>
<OMBIND>
  <OMS cd="quant1" name="forall"/>
  <OMBVAR>
    <OMV name="a"/>
    <OMV name="b"/>
    <OMV name="c"/>
  </OMBVAR>
  <OMA>
    <OMS cd="relation1" name="eq"/>
    <OMA>
      <OMS cd="arith1" name="times"/>
      <OMV name="a"/>
      <OMA>
        <OMS cd="arith1" name="plus"/>
	<OMV name="b"/>
	<OMV name="c"/>
      </OMA>
    </OMA>
    <OMA>
      <OMS cd="arith1" name="plus"/>
      <OMA>
        <OMS cd="arith1" name="times"/>
	<OMV name="a"/>
	<OMV name="b"/>
      </OMA>
      <OMA>
        <OMS cd="arith1" name="times"/>
	<OMV name="a"/>
	<OMV name="c"/>
      </OMA>
    </OMA>
  </OMA>
</OMBIND>
</OMOBJ></FMP>
</CDDefinition>

<CDDefinition>
<Name> divide </Name>
<Description>
This symbol represents a (binary) division function denoting the first argument
right-divided by the second, i.e. divide(a,b)=a*inverse(b). It is the
inverse of the multiplication function defined by the symbol times in this CD.
</Description>
<CMP> whenever not(a=0) then a/a = 1 </CMP>
<FMP>
<OMOBJ>
  <OMBIND>
    <OMS cd="quant1" name="forall"/>
    <OMBVAR>
       <OMV name="a"/>
    </OMBVAR>
    <OMA>
      <OMS cd="logic1" name="implies"/>
      <OMA>
        <OMS cd="relation1" name="neq"/>
        <OMV name="a"/>
        <OMS cd="alg1" name="zero"/>
      </OMA>
      <OMA>
        <OMS cd="relation1" name="eq"/>
        <OMA>
          <OMS cd="arith1" name="divide"/>
          <OMV name="a"/>
          <OMV name="a"/>
        </OMA>
        <OMS cd="alg1" name="one"/>
      </OMA>
    </OMA>
  </OMBIND>
</OMOBJ>
</FMP>
</CDDefinition>

<CDDefinition>
<Name> power </Name>
<Description>
This symbol represents a power function. The first argument is raised
to the power of the second argument. When the second argument is not
an integer, powering is defined in terms of exponentials and 
logarithms for the complex and real numbers.
This operator can represent general powering.
</Description>

<CMP>
x\in C implies x^a = exp(a ln x)
</CMP>

<FMP>
<OMOBJ>
  <OMA>
    <OMS cd="logic1" name="implies"/>
    <OMA>
      <OMS cd="set1" name="in"/>
      <OMV name="x"/>
      <OMS cd="setname1" name="C"/>
    </OMA>
    <OMA>
      <OMS cd="relation1" name="eq"/>
      <OMA>
        <OMS name="power" cd="arith1"/>
        <OMV name="x"/>
        <OMV name="a"/>
      </OMA>
      <OMA>
        <OMS name="exp" cd="transc1"/>
        <OMA>
          <OMS name="times" cd="arith1"/>
          <OMV name="a"/>
          <OMA>
            <OMS name="ln" cd="transc1"/>
            <OMV name="x"/>
          </OMA>
        </OMA>
      </OMA>
    </OMA>
  </OMA>
</OMOBJ>
</FMP>

<CMP>
  if n is an integer then
  x^0 = 1,
  x^n = x * x^(n-1)
</CMP>
<FMP>
<OMOBJ>
  <OMA>
    <OMS cd="logic1" name="implies"/>
    <OMA>
      <OMS cd="set1" name="in"/>
      <OMV name="n"/>
      <OMS cd="setname1" name="Z"/>
    </OMA>
    <OMA>
      <OMS cd="logic1" name="and"/>
      <OMA>
        <OMS cd="relation1" name="eq"/>
        <OMA>
          <OMS cd="arith1" name="power"/>
          <OMV name="x"/>
          <OMI>0</OMI>
        </OMA>
        <OMS cd="alg1" name="one"/>
      </OMA>
      <OMA>
        <OMS cd="relation1" name="eq"/>
        <OMA>
          <OMS cd="arith1" name="power"/>
          <OMV name="x"/>
          <OMV name="n"/>
        </OMA>
        <OMA>
          <OMS cd="arith1" name="times"/>
          <OMV name="x"/>
          <OMA>
            <OMS cd="arith1" name="power"/>
            <OMV name="x"/>
            <OMA>
              <OMS cd="arith1" name="minus"/>
              <OMV name="n"/>
              <OMI>1</OMI>
            </OMA>
          </OMA>
        </OMA>
      </OMA>
    </OMA>
  </OMA>
</OMOBJ>
</FMP>
<Example>
<OMOBJ>
<OMA>
  <OMS cd="relation1" name="eq"/>
  <OMA>
    <OMS cd="arith1" name="power"/>
    <OMA>
      <OMS cd="linalg2" name="matrix"/>
      <OMA>
        <OMS cd="linalg2" name="matrixrow"/>
        <OMI> 1 </OMI>
        <OMI> 2 </OMI>
      </OMA>
      <OMA>
        <OMS cd="linalg2" name="matrixrow"/>
        <OMI> 3 </OMI>
        <OMI> 4 </OMI>
      </OMA>
    </OMA>
    <OMI>3</OMI>
  </OMA>
  <OMA>
    <OMS cd="linalg2" name="matrix"/>
    <OMA>
      <OMS cd="linalg2" name="matrixrow"/>
      <OMI> 37 </OMI>
      <OMI> 54 </OMI>
    </OMA>
    <OMA>
      <OMS cd="linalg2" name="matrixrow"/>
      <OMI> 81 </OMI>
      <OMI> 118 </OMI>
    </OMA>
  </OMA>
</OMA>
</OMOBJ>
</Example>
<Example>
<OMOBJ>
<OMA>
  <OMS cd="relation1" name="eq"/>
  <OMA>
    <OMS cd="arith1" name="power"/>
    <OMS cd="nums1" name="e"/>
    <OMA>
      <OMS cd="arith1" name="times"/>
      <OMS cd="nums1" name="i"/>
      <OMS cd="nums1" name="pi"/>
    </OMA>
  </OMA>
  <OMA>
    <OMS cd="arith1" name="unary_minus"/>
    <OMS cd="alg1" name="one"/>
  </OMA>
</OMA>
</OMOBJ>
</Example>
</CDDefinition>

<CDDefinition>
<Name> abs </Name>
<Description> 
A unary operator which represents the absolute value of its
argument. The argument should be numerically valued.
In the complex case this is often referred to as the modulus.
</Description>
<CMP> for all x,y | abs(x) + abs(y) >= abs(x+y) </CMP>
<FMP>
<OMOBJ>
  <OMBIND>
    <OMS cd="quant1" name="forall"/>
    <OMBVAR>
      <OMV name="x"/>
      <OMV name="y"/>
    </OMBVAR>
    <OMA>
      <OMS cd="relation1" name="geq"/>
      <OMA>
        <OMS cd="arith1" name="plus"/>
        <OMA>
          <OMS cd="arith1" name="abs"/>
            <OMV name="x"/>
            <OMV name="y"/>
        </OMA>
        <OMA>
          <OMS cd="arith1" name="abs"/>
            <OMV name="x"/>
            <OMV name="y"/>
        </OMA>
      </OMA>
      <OMA>
        <OMS cd="arith1" name="abs"/>
        <OMA>
          <OMS cd="arith1" name="plus"/>
          <OMV name="x"/>
          <OMV name="y"/>
        </OMA>
      </OMA>
    </OMA>
  </OMBIND>
</OMOBJ>
</FMP>
</CDDefinition>

<CDDefinition>
<Name> root </Name>
<Description> 
A binary operator which represents its first argument "lowered" to its
n'th root where n is the second argument. This is the inverse of the operation
represented by the power symbol defined in this CD.

Care should be taken as to the precise meaning of this operator, in
particular which root is represented, however it is here to represent
the general notion of taking n'th roots. As inferred by the signature
relevant to this symbol, the function represented by this symbol is
the single valued function, the specific root returned is the one
indicated by the first CMP. Note also that the converse of the second
CMP is not valid in general.
</Description>

<CMP> x\in C implies root(x,n) = exp(ln(x)/n) </CMP>
<FMP>
  <OMOBJ>
    <OMA>
      <OMS cd="logic1" name="implies"/>
      <OMA>
        <OMS cd="set1" name="in"/>
        <OMV name="x"/>
        <OMS cd="setname1" name="C"/>
      </OMA>
      <OMA>
        <OMS cd="relation1" name="eq"/>
        <OMA>
          <OMS cd="arith1" name="root"/>
          <OMV name="x"/>
          <OMV name="n"/>          
        </OMA>
        <OMA>
          <OMS name="exp" cd="transc1"/>
          <OMA>
            <OMS name="divide" cd="arith1"/>
            <OMA>
              <OMS name="ln" cd="transc1"/>
              <OMV name="x"/>
            </OMA>
            <OMV name="n"/>          
          </OMA>
        </OMA>
      </OMA>
    </OMA>
  </OMOBJ>
</FMP>

<CMP> for all a,n | power(root(a,n),n) = a (if the root exists!) </CMP>
<FMP>
  <OMOBJ>
    <OMBIND>
      <OMS cd="quant1" name="forall"/>
      <OMBVAR>
         <OMV name="a"/>
         <OMV name="n"/>
      </OMBVAR>
      <OMA>
        <OMS cd="relation1" name="eq"/>
        <OMA>
          <OMS cd="arith1" name="power"/>
          <OMA>
            <OMS cd="arith1" name="root"/>
            <OMV name="a"/>
            <OMV name="n"/>
          </OMA>
          <OMV name="n"/>
        </OMA>
        <OMV name="a"/>
      </OMA>
    </OMBIND>
  </OMOBJ>
</FMP>
</CDDefinition>




<CDDefinition>
<Name> sum </Name>
<Description>
An operator taking two arguments, the first being the range of summation,
e.g. an integral interval, the second being the function to be
summed. Note that the sum may be over an infinite interval.
</Description>
<Example>
  This represents the summation of the reciprocals of all the integers between
  1 and 10 inclusive.
<OMOBJ>
  <OMA>
    <OMS cd="arith1" name="sum"/>
      <OMA>
        <OMS cd="interval1" name="integer_interval"/>
        <OMI> 1 </OMI>
        <OMI> 10 </OMI>
      </OMA>
    <OMBIND>
      <OMS cd="fns1" name="lambda"/>
        <OMBVAR>
          <OMV name="x"/>
        </OMBVAR>
        <OMA>
          <OMS cd="arith1" name="divide"/>
          <OMI> 1 </OMI>
          <OMV name="x"/>
        </OMA>
    </OMBIND>
  </OMA>
</OMOBJ>
</Example>
</CDDefinition>

<CDDefinition>
<Name> product </Name>
<Description>
An operator taking two arguments, the first being the range of multiplication
e.g. an integral interval, the second being the function to
be multiplied. Note that the product may be over an infinite interval. 
</Description>
<Example>
This represents the statement that the factorial of n is equal to the product
of all the integers between 1 and n inclusive.
<OMOBJ>
  <OMA>
    <OMS cd="relation1" name="eq"/>
    <OMA>
      <OMS cd="integer1" name="factorial"/>
      <OMV name="n" />
    </OMA>
    <OMA>
      <OMS cd="arith1" name="product"/>
        <OMA>
          <OMS cd="interval1" name="integer_interval"/>
          <OMI> 1 </OMI>
          <OMV name="n"/>
        </OMA>
      <OMBIND>
        <OMS cd="fns1" name="lambda"/>
          <OMBVAR>
            <OMV name="i"/>
          </OMBVAR>
          <OMV name="i"/>
      </OMBIND>
    </OMA>
  </OMA>
</OMOBJ>
</Example>
</CDDefinition>

</CD>
\end{verbatim}


ß

\clearpage£
\section£The  \textbf£arith1ß STS Signature Fileß\label£arith1.stsß






\begin£verbatimß
<CDSignatures type="sts" cd="arith1">

<CDSComment>
Date:  1999-11-26
Author: David Carlisle
</CDSComment>

<Signature name="lcm" >
<OMOBJ>
 <OMA>
   <OMS name="mapsto" cd="sts" />
   <OMA>
     <OMS name="nassoc" cd="sts"/>
     <OMV name="SemiGroup"/>
   </OMA>
   <OMV name="SemiGroup" />
 </OMA>
</OMOBJ>
</Signature>

<Signature name="gcd" >
<OMOBJ>
 <OMA>
   <OMS name="mapsto" cd="sts" />
   <OMA>
     <OMS name="nassoc" cd="sts"/>
     <OMV name="SemiGroup"/>
   </OMA>
   <OMV name="SemiGroup" />
 </OMA>
</OMOBJ>
</Signature>

<Signature name="plus">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMA>
   <OMS name="nassoc" cd="sts"/> 
   <OMV name="AbelianSemiGroup"/>
  </OMA>
  <OMV name="AbelianSemiGroup"/>
 </OMA>
</OMOBJ>
</Signature>

<Signature name="unary_minus">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMV name="AbelianGroup"/> 
  <OMV name="AbelianGroup"/> 
 </OMA>
</OMOBJ>
</Signature>

<Signature name="minus">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMV name="AbelianGroup"/> 
  <OMV name="AbelianGroup"/> 
  <OMV name="AbelianGroup"/> 
 </OMA>
</OMOBJ>
</Signature>

<Signature name="times">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMA>
   <OMS name="nassoc" cd="sts"/> 
   <OMV name="SemiGroup"/>
  </OMA>
  <OMV name="SemiGroup"/>
 </OMA>
</OMOBJ>
</Signature>

<Signature name="divide">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMV name="AbelianGroup"/> 
  <OMV name="AbelianGroup"/> 
  <OMV name="AbelianGroup"/> 
 </OMA>
</OMOBJ>
</Signature>

<Signature name="power">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMS name="NumericalValue" cd="sts"/> 
  <OMS name="NumericalValue" cd="sts"/> 
  <OMS name="NumericalValue" cd="sts"/> 
 </OMA>
</OMOBJ>
</Signature>

<Signature name="abs">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMS name="C" cd="setname1"/> 
  <OMS name="R" cd="setname1"/> 
 </OMA>
</OMOBJ>
</Signature>

<Signature name="root">
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts"/>
  <OMS name="NumericalValue" cd="sts"/> 
  <OMS name="NumericalValue" cd="sts"/> 
  <OMS name="NumericalValue" cd="sts"/> 
 </OMA>
</OMOBJ>
</Signature>


<Signature name="sum" >
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts" />
  <OMV name="IntegerRange" />
  <OMA>
   <OMS name="mapsto" cd="sts" />
   <OMS name="Z" cd="setname1" />
   <OMV name="AbelianMonoid" />
  </OMA>
  <OMV name="AbelianMonoid" />
 </OMA>
</OMOBJ>
</Signature>

<Signature name="product" >
<OMOBJ>
 <OMA>
  <OMS name="mapsto" cd="sts" />
  <OMV name="IntegerRange" />
  <OMA>
   <OMS name="mapsto" cd="sts" />
   <OMS name="Z" cd="setname1" />
   <OMV name="AbelianMonoid" />
  </OMA>
  <OMV name="AbelianMonoid" />
 </OMA>
</OMOBJ>
</Signature>

</CDSignatures>
\end{verbatim}


ß

\clearpage£
\section£The  \textbf£MathMLß CDGroupß\label£mathml.cdgß





\begin£verbatimß
<CDGroup>
<CDGroupName>mathml</CDGroupName>
<CDGroupVersion> 2 </CDGroupVersion>
<CDGroupRevision> 0 </CDGroupRevision>
<CDGroupURL>
http://www.openmath.org/cdfiles/cdgroups/mathml.ocd</CDGroupURL>
<CDGroupDescription> MathML compatibility CD Group </CDGroupDescription>
<CDComment>This is the first version of the Core CD group.
It was created by D Carlisle based on MathML CD Group.</CDComment>
<CDComment>Algebra</CDComment>
<CDGroupMember>
<CDName>alg1</CDName>
<CDURL>http://www.openmath.org/cd/alg1.ocd</CDURL></CDGroupMember>
<CDComment>Arithmetic</CDComment>
<CDGroupMember>
<CDName>arith1</CDName>
<CDURL>http://www.openmath.org/cd/arith1.ocd</CDURL></CDGroupMember>
<CDComment>Constructor for Floating Point Numbers</CDComment>
<CDGroupMember>
<CDName>bigfloat1</CDName>
<CDURL>http://www.openmath.org/cd/bigfloat1.ocd</CDURL></CDGroupMember>
<CDComment>Calculus</CDComment>
<CDGroupMember>
<CDName>calculus1</CDName>
<CDURL>http://www.openmath.org/cd/calculus1.ocd</CDURL></CDGroupMember>
<CDComment>Operations on and constructors for complex numbers</CDComment>
<CDGroupMember>
<CDName>complex1</CDName>
<CDURL>http://www.openmath.org/cd/complex1.ocd</CDURL></CDGroupMember>
<CDComment>Functions on functions</CDComment>
<CDGroupMember>
<CDName>fns1</CDName>
<CDURL>http://www.openmath.org/cd/fns1.ocd</CDURL></CDGroupMember>
<CDComment>Integer arithmetic</CDComment>
<CDGroupMember>
<CDName>integer1</CDName>
<CDURL>http://www.openmath.org/cd/integer1.ocd</CDURL></CDGroupMember>
<CDComment>Intervals</CDComment>
<CDGroupMember>
<CDName>interval1</CDName>
<CDURL>http://www.openmath.org/cd/interval1.ocd</CDURL></CDGroupMember>
<CDComment>Linear Algebra - vector &amp; matrix constructors, those symbols which are independant of orientation, but in MathML</CDComment>
<CDGroupMember>
<CDName>linalg1</CDName>
<CDURL>http://www.openmath.org/cd/linalg1.ocd</CDURL></CDGroupMember>
<CDComment>Linear Algebra - vector &amp; matrix constructors, those symbols which are dependant of orientation, and in MathML</CDComment>
<CDGroupMember>
<CDName>linalg2</CDName>
<CDURL>http://www.openmath.org/cd/linalg2.ocd</CDURL></CDGroupMember>
<CDComment>Limits of unary functions</CDComment>
<CDGroupMember>
<CDName>limit1</CDName>
<CDURL>http://www.openmath.org/cd/limit1.ocd</CDURL></CDGroupMember>
<CDComment>List constructors</CDComment>
<CDGroupMember>
<CDName>list1</CDName>
<CDURL>http://www.openmath.org/cd/list1.ocd</CDURL></CDGroupMember>
<CDComment>Basic logical operators</CDComment>
<CDGroupMember>
<CDName>logic1</CDName>
<CDURL>http://www.openmath.org/cd/logic1.ocd</CDURL></CDGroupMember>
<CDComment>
MathML Numerical Types
</CDComment>
<CDGroupMember>
<CDName>mathmltypes</CDName>
<CDURL>http://www.openmath.org/cd/mathmltypes.ocd</CDURL>
</CDGroupMember>
<CDComment>Minima and maxima</CDComment>
<CDGroupMember>
<CDName>minmax1</CDName>
<CDURL>http://www.openmath.org/cd/minmax1.ocd</CDURL></CDGroupMember>
<CDComment>Multset-theoretic operators and constructors</CDComment>
<CDGroupMember>
<CDName>multiset1</CDName>
<CDURL>http://www.openmath.org/cd/multiset1.ocd</CDURL></CDGroupMember>
<CDComment>Symbols for creating numbers, including some defined constants
(which can be seen as nullary constructors)</CDComment>
<CDGroupMember>
<CDName>nums1</CDName>
<CDURL>http://www.openmath.org/cd/nums1.ocd</CDURL></CDGroupMember>
<CDComment>Symbols for creating piecewise definitions</CDComment>
<CDGroupMember>
<CDName>piece1</CDName>
<CDURL>http://www.openmath.org/cd/piece1.ocd</CDURL></CDGroupMember>
<CDComment>The basic quantifiers forall and exists.</CDComment>
<CDGroupMember>
<CDName>quant1</CDName>
<CDURL>http://www.openmath.org/cd/quant1.ocd</CDURL></CDGroupMember>
<CDComment>Common arithmetic relations</CDComment>
<CDGroupMember>
<CDName>relation1</CDName>
<CDURL>http://www.openmath.org/cd/relation1.ocd</CDURL></CDGroupMember>
<CDComment>Number sets</CDComment>
<CDGroupMember>
<CDName>setname1</CDName>
<CDURL>http://www.openmath.org/cd/setname1.ocd</CDURL></CDGroupMember>
<CDComment>Rounding</CDComment>
<CDGroupMember>
<CDName>rounding1</CDName>
<CDURL>http://www.openmath.org/cd/rounding1.ocd</CDURL></CDGroupMember>
<CDComment>Set-theoretic operators and constructors</CDComment>
<CDGroupMember>
<CDName>set1</CDName>
<CDURL>http://www.openmath.org/cd/set1.ocd</CDURL></CDGroupMember>
<CDComment>Basic data orientated statistical operators</CDComment>
<CDGroupMember>
<CDName>s_data1</CDName>
<CDURL>http://www.openmath.org/cd/s_data1.ocd</CDURL></CDGroupMember>
<CDComment>Basic random variable orientated statistical operators</CDComment>
<CDGroupMember>
<CDName>s_dist1</CDName>
<CDURL>http://www.openmath.org/cd/s_dist1.ocd</CDURL></CDGroupMember>
<CDComment>Basic transcendental functions</CDComment>
<CDGroupMember>
<CDName>transc1</CDName>
<CDURL>http://www.openmath.org/cd/transc1.ocd</CDURL></CDGroupMember>
<CDComment>Vector calculus functions</CDComment>
<CDGroupMember>
<CDName>veccalc1</CDName>
<CDURL>http://www.openmath.org/cd/veccalc1.ocd</CDURL></CDGroupMember>
<CDComment>Alternative encoding symbols for compatibility with the MathML
Semantic mapping constructs.</CDComment>
<CDGroupMember>
<CDName>altenc</CDName>
<CDURL>http://www.openmath.org/cd/altenc.ocd</CDURL></CDGroupMember>
</CDGroup>
\end{verbatim}




ß

\clearpage£
\section£The \textbf£errorß Content Dictionaryß\label£errorcdß




\begin£verbatimß
<CD>
<CDName> error </CDName>
<CDURL> http://www.openmath.org/cd/error.ocd </CDURL>
<CDReviewDate> 2003-04-01 </CDReviewDate>
<CDStatus> official </CDStatus>
<CDDate> 2001-03-12 </CDDate>
<CDVersion> 2 </CDVersion>
<CDRevision> 0 </CDRevision>
<CDUses>
<CDName> arith1 </CDName>
<CDName> specfun1 </CDName>
</CDUses>

<CDDefinition>
<Name> unhandled_symbol </Name>
<Description>
This symbol represents the error which is raised when an application
reads a symbol which is present in the mentioned content
dictionary, but which it has not implemented.

When receiving such a symbol, the application should act as if it had
received the OpenMath error object constructed from unhandled_symbol
and the unhandled symbol as in the example below.
</Description>

<Example>
The application does not implement the Complex numbers:
<OMOBJ>
  <OME>
    <OMS cd="error" name="unhandled_symbol"/>
    <OMS cd="setname1" name="C"/>
  </OME>
</OMOBJ>
</Example>
</CDDefinition>

<CDDefinition>
<Name> unexpected_symbol </Name>
<Description>
This symbol represents the error which is raised when an application
reads a symbol which is not present in the mentioned content dictionary.

When receiving such a symbol, the application should act as if it had
received the OpenMath error object constructed from unexpected_symbol
and the unexpected symbol as in the example below.
</Description>
<Example>
The application received a mistyped symbol
<OMOBJ>
  <OME>
    <OMS cd="error" name="unexpected_symbol"/>
    <OMS cd="arith1" name="plurse"/>
  </OME>
</OMOBJ>
</Example>
</CDDefinition>

<CDDefinition>
<Name> unsupported_CD </Name>
<Description>
This symbol represents the error which is raised when an application
reads a symbol where the mentioned content dictionary is not
present.

When receiving such a symbol, the application should act as if it had
received the OpenMath error object constructed from unsupported_CD and
the symbol from the unsupported Content Dictionary as in the example
below.
</Description>
<Example>
The application does not know about the CD specfun1
<OMOBJ>
  <OME>
    <OMS cd="error" name="unsupported_CD"/>
    <OMS cd="specfun1" name="BesselJ"/>
  </OME>
</OMOBJ>
</Example>
</CDDefinition>

</CD>
\end{verbatim}


ß






\begin£thebibliographyߣ99ß


\bibitem£Abbott_Leeuwen_Strotmann_98ß
John A. Abbott, André van Leeuwen and A. Strotmann OpenMath: Communicating Mathematical Information 
between Co-operating Agents in a Knowledge Network.


\bibitem£rfc1521ß
N. Borenstein and N Freed MIME (Multipurpose Internet Mail Extensions) Part One: Mechanism for Specifying and Describing the Format of Internet Message Bodies


\bibitem£MathML_98ß
Stephen Buswell, Stan Devitt, Angel Diaz, Nico Poppelier, Bruce Smith, Neil Soiffer, Robert Sutor and Stephen Watt Mathematical Markup Language (MathML) 1.0 Specification


\bibitem£OM_D131bß
O. Caprotti and A. M. Cohen A Type System for OpenMath


\bibitem£OMD132bß
Olga Caprotti and Arjeh M. Cohen A Type System for OpenMath


\bibitem£Dalmas_Gaetano_Watt_97ß
S. Dalmas, M. Gaëtano and S. Watt An OpenMath 1.0 Implementation


\bibitem£OM_D132cß
J. Davenport A Small OpenMath Type System


\bibitem£ieee754_85ß
 IEEE Standard for binary Floating-Point Arithmetic


\bibitem£iso646_83ß
 ISO 7-bit coded character set for information interchange


\bibitem£OM_98ß
OpenMath Consortium OpenMath Version 1 - Draft


\bibitem£MathML_2000ß
Nico Poppelier, Robert Miner, Patrick Ion, David Carlisle, Ron Ausbrooks, Stephen Buswell, Stéphane Dalmas, Stan Devitt, Angel Diaz, Roger Hunter, Bruce Smith, Neil Soiffer, Robert Sutor and Stephen Watt Mathematical Markup Language (MathML) 2.0 Specification


\bibitem£ISO9660ß
Technical committee / subcommittee: JTC 1 ISO 9660:1988 Information processing \textendash  Volume and File Structure of CDROM for Information Interchange


\bibitem£UNICODEß
Unicode Consortium The Unicode Standard: Version 2.0


\bibitem£xmlnsß
W3C Namespaces in XML


\bibitem£xmlß
W3C Extensible Markup Language XML 1.0


\bibitem£XSL_99ß
W3C Extensible Stylesheet Language (XSL) Specification


\bibitem£utf8ß
F. Yergeau UTF-8, a transformation format of ISO 10646

\end£thebibliographyß






\catcode`\{=1
\catcode`\}=2
\end£documentß