Stephen Buswell: overall design; organization and original text
of documentation.
Stan Devitt: design revision.
-->
<div2 id = "contm_intro">
<head>Introduction</head>
<div3>
<head>The Intent of Content Markup</head>
<p>As has been noted in the introductory section of this Recommendation, mathematics can be distinguished by its use of a (relatively) formal language, mathematical notation. However, mathematics and its presentation should not be viewed as one and the same thing. Mathematical sums or products exist and are meaningful to many applications completely without regard to how they are rendered aurally or visually. The intent of the content markup in the Mathematical Markup Language is to provide an explicit encoding of the
<emph>underlying mathematical structure</emph> of an expression, rather than any particular rendering for the expression.</p>
<p>There are many reasons for providing a specific encoding for content. Even a disciplined and systematic use of presentation tags cannot properly capture this semantic information. This is because without additional information it is impossible to decide whether a particular presentation was chosen deliberately to encode the mathematical structure or simply to achieve a particular visual or aural effect. Furthermore, an author using the same encoding to deal with both the presentation and mathematical structure might find a particular presentation encoding unavailable simply because convention had reserved it for a different semantic meaning.</p>
<p>The difficulties stem from the fact that there are many to one mappings from presentation to semantics and vice versa. For example the mathematical construct
<quote>
<mi>H</mi> multiplied by
<mi>e</mi></quote> is often encoded using an explicit operator as in
<mi>H</mi> ×
<mi>e</mi>. In different presentational contexts, the multiplication operator might be invisible
<quote>
<mi>H</mi>
<mi>e</mi></quote>, or rendered as the spoken word
<quote>times</quote>. Generally, many different presentations are possible depending on the context and style preferences of the author or reader. Thus, given
<quote>
<mi>H</mi>
<mi>e</mi></quote> out of context it may be impossible to decide if this is the name of a chemical or a mathematical product of two variables
<mi>H</mi> and
<mi>e</mi>.</p>
<p>Mathematical presentation also changes with culture and time: some expressions in combinatorial mathematics today have one meaning to a Russian mathematician, and quite another to a French mathematician; see
<specref ref = "mixing_notsheet"/> for an example. Notations may lose currency, for example the use of musical sharp and flat symbols to denote maxima and minima
<bibref ref = "Chaundy1954"/>. A notation in use in 1644 for the multiplication mentioned above was
<graphic role = "inline" source = "image/f4001.gif" alt = "\blacksquare"/>
<mi>H</mi>
<mi>e</mi>
<bibref ref = "Cajori1928"/>.</p>
<p>When we encode the underlying mathematical structure explicitly, without regard to how it is presented aurally or visually, we are able to interchange information more precisely with those systems that are able to manipulate the mathematics. In the trivial example above, such a system could substitute values for the variables
<mi>H</mi> and
<mi>e</mi> and evaluate the result. Further interesting application areas include interactive textbooks and other teaching aids.</p></div3>
<div3>
<head>The Scope of Content Markup</head>
<p>The semantics of general mathematical notation is not a matter of consensus. It would be an enormous job to systematically codify most of mathematics – a task that can never be complete. Instead, MathML makes explicit a relatively small number of commonplace mathematical constructs, chosen carefully to be sufficient in a large number of applications. In addition, it provides a mechanism for associating semantics with new notational constructs. In this way, mathematical concepts that are not in the base collection of elements can still be encoded (<specref ref = "contm_synsem"/>).</p>
<p>The base set of content elements is chosen to be adequate for simple coding of most of the formulas used from kindergarten to the end of high school in the United States, and probably beyond through the first two years of college, that is up to A-Level or Baccalaureate level in Europe. Subject areas covered to some extent in MathML are:
<ulist>
<item>
<p>arithmetic, algebra, logic and relations</p></item>
<item>
<p>calculus and vector calculus</p></item>
<item>
<p>set theory</p></item>
<item>
<p>sequences and series</p></item>
<item>
<p>elementary classical functions</p></item>
<item>
<p>statistics</p></item>
<item>
<p>linear algebra</p></item></ulist>It is not claimed, or even suggested, that the proposed set of elements is complete for these areas, but the provision for author extensibility greatly alleviates any problem omissions from this finite list might cause.</p></div3>
<div3>
<head>Basic Concepts of Content Markup</head>
<p>The design of the MathML content elements are driven by the following principles:
<ulist>
<item>
<p>The expression tree structure of a mathematical expression should be directly encoded by the MathML content elements.</p></item>
<item>
<p>The encoding of an expression tree should be explicit, and not dependent on the special parsing of
<kw>PCDATA</kw> or on additional processing such as operator precedence parsing.</p></item>
<item>
<p>The basic set of mathematical content constructs that are provided should have default mathematical semantics.</p></item>
<item>
<p>There should be a mechanism for associating specific mathematical semantics with the constructs.</p></item></ulist></p>
<p>The primary goal of the content encoding is to establish explicit connections between mathematical structures and their mathematical meanings. The content elements correspond directly to parts of the underlying mathematical expression tree. Each structure has an associated default semantics and there is a mechanism for associating new mathematical definitions with new constructs.</p>
<p>Significant advantages to the introduction of content-specific tags include:
<ulist>
<item>
<p>Usage of presentation elements is less constrained. When mathematical semantics are inferred from presentation markup, processing agents must either be quite sophisticated, or they run the risk of inferring incomplete or incorrect semantics when irregular constructions are used to achieve a particular aural or visual effect.</p></item>
<item>
<p>It is immediately clear which kind of information is being encoded simply by the kind of elements that are used.</p></item>
<item>
<p>Combinations of semantic and presentation elements can be used to convey both the appearance and its mathematical meaning much more effectively than simply trying to infer one from the other.</p></item></ulist></p>
<p>Expressions described in terms of content elements must still be rendered. For common expressions, default visual presentations are usually clear.
<quote>Take care of the sense and the sounds will take care of themselves</quote> wrote Lewis Carroll
<bibref ref = "Carroll1871"/>. Default presentations are included in the detailed description of each element occurring in
<specref ref = "contm_elem"/>.</p>
<p>To accomplish these goals, the MathML content encoding is based on the concept of an expression tree. A content expression tree is constructed from a collection of more primitive objects, referred to herein as
<emph>containers</emph> and
<emph>operators</emph>. MathML possesses a rich set of predefined container and operator objects, as well as constructs for combining containers and operators in mathematically meaningful ways. The syntax and usage of these content elements and constructions is described in the next section.</p></div3></div2>
<div2 id = "contm_usage">
<head>Content Element Usage Guide</head>
<p>Since the intent of MathML content markup is to encode mathematical expressions in such a way that the mathematical structure of the expression is clear, the syntax and usage of content markup must be consistent enough to facilitate automated semantic interpretation. There must be no doubt when, for example, an actual sum, product or function application is intended and if specific numbers are present, there must be enough information present to reconstruct the correct number for purposes of computation. Of course, it is still up to a MathML-compliant processor to decide what is to be done with such a content-based expression, and computation is only one of many options. A renderer or a structured editor might simply use the data and its own built-in knowledge of mathematical structure to render the object. Alternatively, it might manipulate the object to build a new mathematical object. A more computationally oriented system might attempt to carry out the indicated operation or function evaluation.</p>
<p>The purpose of this section is to describe the intended, consistent usage. The requirements involve more than just satisfying the syntactic structure specified by an XML DTD. Failure to conform to the usage as described below will result in a MathML error, even though the expression may be syntactically valid according to the DTD.</p>
<p>In addition to the usage information contained in this section,
<specref ref = "contm_elem"/> gives a complete listing of each content element, providing reference information about their attributes, syntax, examples and suggested default semantics and renderings. The rules for using presentation markup within content markup are explained in
<specref ref = "mixing_pmincm"/>. An informal EBNF grammar describing the syntax for the content markup is given in
<specref ref = "cmvg"/>.</p>
<div3 id = "contm_cats">
<head>Overview of Syntax and Usage</head>
<p>MathML content encoding is based on the concept of an expression tree. As a general rule, the terminal nodes in the tree represent basic mathematical objects, such as numbers, variables, arithmetic operations and so on. The internal nodes in the tree generally represent some kind of function application or other mathematical construction that builds up a compound object. Function application provides the most important example; an internal node might represent the application of a function to several arguments, which are themselves represented by the terminal nodes underneath the internal node.</p>
<p>The MathML content elements can be grouped into the following categories based on their usage:
<ulist>
<item>
<p>containers</p></item>
<item>
<p>operators and functions</p></item>
<item>
<p>qualifiers</p></item>
<item>
<p>relations</p></item>
<item>
<p>conditions</p></item>
<item>
<p>semantic mappings</p></item>
<item>
<p>constants and symbols</p></item></ulist>These are the building blocks out of which MathML content expressions are constructed. Each category is discussed in a separate section below. In the remainder of this section, we will briefly introduce some of the most common elements of each type, and consider the general constructions for combining them in mathematically meaningful ways.</p>
<div4>
<head>Constructing Mathematical Objects</head>
<p>Content expression trees are built up from basic mathematical objects. At the lowest level,
<emph>leaf nodes</emph> are encapsulated in non-empty elements that define their type. Numbers and symbols are marked by the
<emph>token</emph> elements
<kw role = "element">cn</kw> and
<kw role = "element">ci</kw>. More elaborate constructs such as sets, vectors and matrices are also marked using elements to denote their types, but rather than containing data directly, these
<emph>container</emph> elements are constructed out of other elements. Elements are used in order to clearly identify the underlying objects. In this way, standard XML parsing can be used and attributes can be used to specify global properties of the objects.</p>
<p>The containers such as
<code><![CDATA[<cn>12345</cn>]]></code> ,
<code><![CDATA[<ci>x</ci>]]></code> and
<code><![CDATA[<csymbol definitionURL="mySymbol.htm" encoding="text">S</csymbol>]]></code>represent mathematical numbers , identifiers and externally defined symbols. Below, we will look at
<kw role = "element">operator</kw> elements such as
<kw role = "element">plus</kw> or
<kw role = "element">sin</kw>, which provide access to the basic mathematical operations and functions applicable to those objects. Additional containers such as
<kw role = "element">set</kw> for sets, and
<kw role = "element">matrix</kw> for matrices are provided for representing a variety of common compound objects.</p>
<p>For example, the number 12345 is encoded as
<eg role = "mathml"><![CDATA[
<cn>12345</cn>
]]></eg> The attributes and
<kw>PCDATA</kw> content together provide the data necessary for an application to parse the number. For example, a default base of 10 is assumed, but to communicate that the underlying data was actually written in base 8, simply set the
<kw role = "attrib">base</kw> attribute to 8 as in
<eg role = "mathml"><![CDATA[
<cn base="8">12345</cn>
]]></eg>while the complex number 3 + 4i can be encoded as
<eg role = "mathml"><![CDATA[
<cn type="complex-cartesian">3<sep/>4</cn>
]]></eg>Such information makes it possible for another application to easily parse this into the correct number.</p>
<p>As another example, the scalar symbol
<mi>v</mi> is encoded as
<eg role = "mathml"><![CDATA[
<ci>v</ci>
]]></eg>By default,
<kw role = "element">ci</kw> elements represent elements from a commutative field (see
<specref ref = "cedef"/>). If a vector is intended then this fact can be encoded as
<eg role = "mathml"><![CDATA[
<ci type="vector">v</ci>
]]></eg>This invokes default semantics associated with the
<kw role = "element">vector</kw> element, namely an arbitrary element of a finite-dimensional vector space.</p>
<p>By using the
<kw role = "element">ci</kw> and
<kw role = "element">csymbol</kw> elements we have made clear that we are referring to a mathematical identifier or symbol but this does not say anything about how it should be rendered. By default a symbol is rendered as if the
<kw role = "element">ci</kw> or
<kw role = "element">csymbol</kw> element were actually the presentation element
<kw role = "element">mi</kw> (see
<specref ref = "presm_mi"/>). The actual rendering of a mathematical symbol can be made as elaborate as necessary simply by using the more elaborate presentational constructs (as described in
<specref ref = "presm"/>) in the body of the
<kw role = "element">ci</kw> or
<kw role = "element">csymbol</kw> element.</p>
<p>The default rendering of a simple
<kw role = "element">cn</kw>-tagged object is the same as for the presentation element
<kw role = "element">mn</kw> with some provision for overriding the presentation of the
<kw>PCDATA</kw> by providing explicit
<kw role = "element">mn</kw> tags. This is described in detail in
<specref ref = "contm_elem"/>.</p>
<p>The issues for compound objects such as sets, vectors and matrices are all similar to those outlined above for numbers and symbols. Each such object has global properties as a mathematical object that impact how it is to be parsed. This may affect everything from the interpretation of operations that are applied to it to how to render the symbols representing it. These mathematical properties are captured by setting attribute values.</p></div4>
<div4>
<head>Constructing General Expressions</head>
<p>The notion of constructing a general expression tree is essentially that of applying an operator to sub-objects. For example, the sum
<mi>a</mi> +
<mi>b</mi> can be thought of as an application of the addition operator to two arguments
<mi>a</mi> and
<mi>b</mi>. In MathML, elements are used for operators for much the same reason that elements are used to contain objects. They are recognized at the level of XML parsing, and their attributes can be used to record or modify the intended semantics. For example, with the MathML
<kw role = "element">plus</kw> element, setting the
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes as in
]]></eg>can communicate that the intended operation is vector-based.</p>
<p>There is also another reason for using elements to denote operators. There is a crucial semantic distinction between the function itself and the expression resulting from applying that function to zero or more arguments which must be captured. This is addressed by making the functions self-contained objects with their own properties and providing an explicit
<kw role = "element">apply</kw> construct corresponding to function application. We will consider the
<kw role = "element">apply</kw> construct in the next section.</p>
<p>MathML contains many pre-defined operator elements, covering a range of mathematical subjects. However, an important class of expressions involve unknown or user-defined functions and symbols. For these situations, MathML provides a general
<kw role = "element">csymbol</kw> element, which is discussed below.</p></div4>
<div4>
<head>The
<kw role = "element">apply</kw> construct</head>
<p>The most fundamental way of building up a mathematical expression in MathML content markup is the
<kw role = "element">apply</kw> construct. An
<kw role = "element">apply</kw> element typically applies an operator to its arguments. It corresponds to a complete mathematical expression. Roughly speaking, this means a piece of mathematics that could be surrounded by parentheses or
<quote>logical brackets</quote> without changing its meaning.</p>
<p>For example, (<mi>x</mi> +
<mi>y</mi>) might be encoded as
<eg role = "mathml"><![CDATA[
<apply>
<plus/>
<ci> x </ci>
<ci> y </ci>
</apply>
]]></eg>The opening and closing tags of
<kw role = "element">apply</kw> specify exactly the scope of any operator or function. The most typical way of using
<kw role = "element">apply</kw> is simple and recursive. Symbolically, the content model can be described as:
<eg role = "mathml-extension"><apply>
<emph>op</emph>
<emph>a</emph>
<emph>b</emph> </apply></eg>where the
<emph>operands</emph> a and b are containers or other content-based elements themselves, and
<emph>op</emph> is an operator or function. Note that since
<kw role = "element">apply</kw> is a container, this allows
<kw role = "element">apply</kw> constructs to be nested to arbitrary depth.</p>
<p>An
<kw role = "element">apply</kw> may in principle have any number of operands:
<eg role = "mathml-extension"><![CDATA[
<apply> op a b [c...] <apply>
]]></eg>For example, (<mi>x</mi> +
<mi>y</mi> +
<mi>z</mi>) can be encoded as
<eg role = "mathml"><![CDATA[
<apply>
<plus/>
<ci> x </ci>
<ci> y </ci>
<ci> z </ci>
</apply>
]]></eg></p>
<p>Mathematical expressions involving a mixture of operations result in nested occurrences of
<kw role = "element">apply</kw>. For example,
<mi>a</mi>
<mi>x</mi> +
<mi>b</mi> would be encoded as
<eg role = "mathml"><![CDATA[
<apply>
<plus/>
<apply>
<times/>
<ci> a </ci>
<ci> x </ci>
</apply>
<ci> b </ci>
</apply>
]]></eg></p>
<p>There is no need to introduce parentheses or to resort to operator precedence in order to parse the expression correctly. The
<kw role = "element">apply</kw> tags provide the proper grouping for the re-use of the expressions within other constructs. Any expression enclosed by an
<kw role = "element">apply</kw> element is viewed as a single coherent object.</p>
<p>An expression such as (<mi>F</mi> +
<mi>G</mi>)(<mi>x</mi>) might be a product, as in
<eg role = "mathml"><![CDATA[
<apply>
<times/>
<apply>
<plus/>
<ci> F </ci>
<ci> G </ci>
</apply>
<ci> x </ci>
</apply>
]]></eg>or it might indicate the application of the function
<mi>F</mi> +
<mi>G</mi> to the argument
<mi>x</mi>. This is indicated by constructing the sum
<eg role = "mathml"><![CDATA[
<apply>
<plus/>
<ci> F </ci>
<ci> G </ci>
</apply>
]]></eg>and applying it to the argument
<mi>x</mi> as in
<eg role = "mathml"><![CDATA[
<apply>
<apply>
<plus/>
<ci> F </ci>
<ci> G </ci>
</apply>
<ci> x </ci>
</apply>
]]></eg>Both the function and the arguments may be simple identifiers or more complicated expressions.</p>
<p>In MathML 1.0 , another construction closely related to the use of the
<kw role = "element">apply</kw> element with operators and arguments was the
<kw role = "element">reln</kw> element. The
<kw role = "element">reln</kw> element was used to denote that a mathematical relation holds between its arguments, as opposed to applying an operator. Thus, the MathML markup for the expression
<mi>x</mi> <
<mi>y</mi> was given in MathML 1.0 by:
<eg role = "mathml"><![CDATA[
<reln>
<lt/>
<ci> x </ci>
<ci> y </ci>
</reln>
]]></eg>In MathML 2.0, the
<kw role = "element">apply</kw> construct is used with all operators, including logical operators. The expression above becomes
<eg role = "mathml"><![CDATA[
<apply>
<lt/>
<ci> x </ci>
<ci> y </ci>
</apply>
]]></eg>in MathML 2.0. The use of
<kw role = "element">reln</kw> with relational operators is supported
for reasons of backwards compatibility, but <intref ref =
"interf_deprec">deprecated</intref>. Authors creating new content are
encouraged to use
<kw role = "element">apply</kw> in all cases.</p></div4><!--
removed 'and the <kw role="element">csymbol</kw> and
<kw role="element">fn</kw> constructs' from this very long
title, because references to this section looked terrible.
-->
<div4 id = "contm_deffun">
<head>Explicitly defined functions and operators</head>
<p>The most common operations and functions such as
<kw role = "element">plus</kw> and
<kw role = "element">sin</kw> have been predefined explicitly as empty elements (see
<specref ref = "contm_elem"/>). They have
<kw role = "attrib">type</kw> and
<kw role = "attrib">definitionURL</kw> attributes, and by changing these attributes, the author can record that a different sort of algebraic operation is intended. This allows essentially the same notation to be re-used for a discussion taking place in a different algebraic domain.</p>
<p>Due to the nature of mathematics the notation must be extensible. The key to extensibility is the ability of the user to define new functions and other symbols to expand the terrain of mathematical discourse.</p>
<p>It is always possible to create arbitrary expressions, and then to use them as symbols in the language. Their properties can then be inferred directly from that usage as was done in the previous section. However, such an approach would preclude being able to encode the fact that the construct was a known symbol, or to record its mathematical properties except by actually using it. The
<kw role = "element">csymbol</kw> element is used as a container to construct a new symbol in much the same way that
<kw role = "element">ci</kw> is used to construct an identifier. (Note that
<quote>symbol</quote> is used here in the abstract sense and has no connection with any presentation of the construct on screen or paper). The difference in usage is that
<kw role = "element">csymbol</kw> should refer to some mathematically defined concept with an external definition referenced via the
<kw role = "attrib">definitionURL</kw> attribute, whereas
<kw role = "element">ci </kw> is used for identifiers that are essentially
<quote>local</quote> to the MathML expression and do not use any external definition mechanism. The target of the
<kw role = "attrib">definitionURL</kw> attribute on the
<kw role = "element">csymbol</kw> element may encode the definition in any format; the particular encoding in use is given by the
<kw role = "attrib">encoding</kw> attribute.</p>
<p>To use
<kw role = "element">csymbol</kw> to describe a completely new function, we write for example
<kw role = "attrib">definitionURL</kw> attribute specifies a URI that provides a written definition for the
<kw>Christoffel</kw> symbol. Suggested default definitions for the content elements of MathML appear in
<specref ref = "cedef"/> in a format based on OpenMath, although there is no requirement that a particular format be used. The role of the
<kw role = "attrib">definitionURL</kw> attribute is very similar to the role of definitions included at the beginning of many mathematical papers, and which often just refer to a definition used by a particular book.</p>
<p>MathML 1.0 supported the use of the
<kw>fn</kw> to encode the fact that a construct is explicitly being used as a function or operator. To record the fact that
<mi>F</mi>+
<mi>G</mi> is being used semantically as if it were a function, it was encoded as:
<eg role = "mathml"><![CDATA[
<fn>
<apply>
<plus/>
<ci>F</ci>
<ci>G</ci>
</apply>
</fn>
]]></eg>This usage, although allowed in MathML 2.0 for reasons of backwards compatibility,
is now <intref ref="interf_deprec">deprecated</intref>.
The fact that a construct is being used as an operator is clear from the position of the construct as the
first child of the
<kw>apply</kw>. If it is required to add additional information to the construct, it should be wrapped in a
<p>Given functions, it is natural to have functional inverses. This is handled by the
<kw role = "element">inverse</kw> element.</p>
<p>Functional inverses can be problematic from a mathematical point of view in that they implicitly involve the definition of an inverse for an arbitrary function
<mi>F</mi>. Even at the K-through-12 level the concept of an inverse
<mi>F</mi>
<sup>-1</sup> of many common functions
<mi>F</mi> is not used in a uniform way. For example, the definitions used for the inverse trigonometric functions may differ slightly depending on the choice of domain and/or branch cuts.</p>
<p>MathML adopts the view: if
<mi>F</mi> is a function from a domain
<mi>D</mi> to
<mi>D</mi>', then the inverse
<mi>G</mi> of
<mi>F</mi> is a function over
<mi>D</mi>' such that
<mi>G</mi>(<mi>F</mi>(<mi>x</mi>)) =
<mi>x</mi> for
<mi>x</mi> in
<mi>D</mi>. This definition does not assert that such an inverse exists for all or indeed any
<mi>x</mi> in
<mi>D</mi>, or that it is single-valued anywhere. Also, depending on the functions involved, additional properties such as
<mi>F</mi>(<mi>G</mi>(<mi>y</mi>)) =
<mi>y</mi> for
<mi>y</mi> in
<mi>D</mi>' may hold.</p>
<p>The
<kw role = "element">inverse</kw> element is applied to a function whenever an inverse is required. For example, application of the inverse sine function to
<mi>x</mi>, i.e. sin<sup>-1</sup> (<mi>x</mi>), is encoded as:
<eg role = "mathml"><![CDATA[
<apply>
<apply> <inverse/> <sin/> </apply>
<ci> x </ci>
</apply>
]]></eg>While
<kw role = "element">arcsin</kw> is one of the predefined MathML functions, an explicit reference to sin<sup>-1</sup>(<mi>x</mi>) might occur in a document discussing possible definitions of
<kw role = "element">arcsin</kw>.</p></div4>
<div4>
<head>The declare construct</head>
<p>Consider a document discussing the vectors
<mi>A</mi> = (<mi>a</mi>, <mi>b</mi>,
<mi>c</mi>) and
<mi>B</mi> = (<mi>d</mi>, <mi>e</mi>,
<mi>f</mi>), and later including the expression
<mi>V</mi> =
<mi>A</mi> +
<mi>B</mi>. It is important to be able to communicate the fact that wherever
<mi>A</mi> and
<mi>B</mi> are used they represent a particular vector. The properties of that vector may determine aspects of operators such as
<kw role = "element">plus</kw>.</p>
<p>The simple fact that
<mi>A</mi> is a vector can be communicated by using the markup
<eg role = "mathml"><![CDATA[
<ci type="vector">A</ci>
]]></eg>
but this still does not communicate, for example, which vector is involved
or its dimensions.</p>
<p>The <kw role="element">declare</kw> construct is used to associate
specific properties or meanings with an object. The actual declaration
itself is not rendered visually (or in any other form). However, it
indirectly impacts the semantics of all affected uses of the declared
object.</p>
<p>Declarations must occur at the beginning of a <kw role="element">math</kw>
element. The scope of a declaration is the entire
<kw role="element">math</kw> element in which the declaration is made.
The <kw role="attrib">scope</kw> attribute of a <kw role="element">declare</kw>
may be included but has no effect since the two possible values of
<kw role="attval">local</kw> or <kw role="attval">global</kw>
now have the same meaning. The <kw role="attval">global</kw> attribute value
is still allowed for backwards compatibility with MathML 1.0.,
but is <intref ref="interf_deprec">deprecated</intref> in MathML 2.0.</p>
<p>The uses of the <kw role="element">declare</kw> element range from
resetting default attribute values to associating an expression with a
particular instance of a more elaborate structure. Subsequent uses of the
original expression (within the scope of the <kw
role="element">declare</kw>) play the same semantic role as would the
paired object.</p>
<p>For example, the declaration
<eg role = "mathml"><![CDATA[
<declare>
<ci> A </ci>
<vector>
<ci> a </ci>
<ci> b </ci>
<ci> c </ci>
</vector>
</declare>
]]></eg>
specifies that <mi>A</mi> stands for the particular vector (<mi>a</mi>,
<mi>b</mi>, <mi>c</mi>) so that subsequent uses of <mi>A</mi> as in
<mi>V</mi> = <mi>A</mi> + <mi>B</mi> can take this into account. When <kw
role="element">declare</kw> is used in this way, the actual encoding
<eg role="mathml"><![CDATA[
<apply>
<eq/>
<ci> V </ci>
<apply>
<plus/>
<ci> A </ci>
<ci> B </ci>
</apply>
</apply>
]]></eg>remains unchanged but the expression can be interpreted properly as vector addition.</p>
<p>There is no requirement to declare an expression to stand for a specific object. For example, the declaration
<eg role = "mathml"><![CDATA[
<declare type="vector">
<ci> A </ci>
</declare>
]]></eg>specifies that
<mi>A</mi> is a vector without indicating the number of components or the values of specific components. The possible values for the
<kw role = "attrib">type</kw> attribute include all the predefined container element names such as
<kw role = "element">vector</kw>,
<kw role = "element">matrix</kw> or
<kw role = "element">set</kw> (see
<specref ref = "contm_typeattrib"/>).</p></div4>
<div4>
<head>The lambda construct</head>
<p>The lambda calculus allows a user to construct a function from a variable and an expression. For example, the lambda construct underlies the common mathematical idiom illustrated here:
<eg role = "text">Let
<mi>f</mi> be the function taking
<mi>x</mi> to
<mi>x</mi><sup>2</sup> + 2</eg></p>
<p>There are various notations for this concept in mathematical literature, such as
[<mi>F</mi>]) =<mi>F</mi>, where <mi>x</mi> is a free variable in <mi>F</mi>.</p>
<p>This concept is implemented in MathML with the <kw
role="element">lambda</kw> element. A lambda construct with <mi>n</mi>
internal variables is encoded by a <kw role="element">lambda</kw> element
with <mi>n</mi>+1 children. All but the last child must be <kw
role="element">bvar</kw> elements containing the identifiers of the
internal variables. The last child is an expression defining the
function. This is typically an <kw role="element">apply</kw>, but can also
be any container element.</p>
<p>The following constructs
<graphic role = "inline" source = "image/f4002.gif" alt = "\lambda"/>
(<mi>x</mi>, sin(<mi>x</mi>+1)):
<eg role = "mathml"><![CDATA[
<lambda>
<bvar><ci> x </ci></bvar>
<apply>
<sin/>
<apply>
<plus/>
<ci> x </ci>
<cn> 1 </cn>
</apply>
</apply>
</lambda>
]]></eg></p>
<p>To use
<kw role = "element">declare</kw> and
<kw role = "element">lambda</kw> to construct the function
<mi>f</mi> for which
<mi>f</mi>(
<mi>x</mi>) =
<mi>x</mi><sup>2</sup> +
<mi>x</mi> + 3 use:
<eg role = "mathml"><![CDATA[
<declare type="fn">
<ci> f </ci>
<lambda>
<bvar><ci> x </ci></bvar>
<apply>
<plus/>
<apply>
<power/>
<ci> x </ci>
<cn> 2 </cn>
</apply>
<ci> x </ci>
<cn> 3 </cn>
</apply>
</lambda>
</declare>
]]></eg>The following markup declares and constructs the function
<mi>J</mi> such that
<mi>J</mi>(<mi>x</mi>,
<mi>y</mi>) is the integral from
<mi>x</mi> to
<mi>y</mi> of
<mi>t</mi><sup>4</sup> with respect to <mi>t</mi>.
<eg role = "mathml"><![CDATA[
<declare type="fn">
<ci> J </ci>
<lambda>
<bvar><ci> x </ci></bvar>
<bvar><ci> y </ci></bvar>
<apply> <int/>
<bvar>
<ci> t </ci>
</bvar>
<lowlimit>
<ci> x </ci>
</lowlimit>
<uplimit>
<ci> y </ci>
</uplimit>
<apply> <power/>
<ci>t</ci>
<cn>4</cn>
</apply>
</apply>
</lambda>
</declare>
]]></eg>The function
<mi>J</mi> can then in turn be applied to an argument pair.</p></div4>
<div4>
<head>The use of qualifier elements and the condition construct</head>
<p>The last example of the preceding section illustrates the use of
<emph>qualifier</emph> elements
<kw role = "element">lowlimit</kw>,
<kw role = "element">uplimit</kw>, and
<kw role = "element">bvar</kw> used in conjunction with the
<kw role = "element">int</kw> element. A number of common mathematical constructions involve additional data that is either implicit in conventional notation, such as a bound variable, or thought of as part of the operator rather than an argument, as is the case with the limits of a definite integral.</p>
<p>Content markup uses qualifier elements in conjunction with a number of operators, including integrals, sums, series, and certain differential operators. Qualifier elements appear in the same
<kw role = "element">apply</kw> element with one of these operators. In general, they must appear in a certain order, and their precise meaning depends on the operators being used. For details, see
<specref ref = "contm_opwithqual"/>.</p>
<p>The qualifier element
<kw role = "element">bvar</kw> is also used in another important MathML construction. The
<kw role = "element">condition</kw> element is used to place conditions on bound variables in other expressions. This allows MathML to define sets by rule, rather than enumeration, for example. The following markup, for instance, encodes the set {
<mi>x</mi> |
<mi>x</mi> < 1}:
<eg role = "mathml"><![CDATA[
<set>
<bvar><ci> x </ci></bvar>
<condition>
<apply>
<lt/>
<ci> x </ci>
<cn> 1 </cn>
</apply>
</condition>
</set>
]]></eg></p></div4>
<div4>
<head>Rendering of Content elements</head>
<p>While the primary role of the MathML content element set is to directly encode the mathematical structure of expressions independent of the notation used to present the objects, rendering issues cannot be ignored. Each content element has a default rendering, given in
<specref ref = "contm_elem"/>, and several mechanisms (including
<specref ref = "contm_genatt"/>) are provided for associating a particular rendering with an object.</p></div4></div3>
<div3 id = "contm_container">
<head>Containers</head>
<p>Containers provide a means for the construction of mathematical objects of a given type.
<table border = "1">
<tbody>
<tr>
<td>Tokens</td>
<td>
<kw role = "element">ci</kw>,
<kw role = "element">cn</kw>,
<kw role = "element">csymbol</kw></td></tr>
<tr>
<td>Constructors</td>
<td>
<kw role = "element">interval</kw>,
<kw role = "element">list</kw>,
<kw role = "element">matrix</kw>,
<kw role = "element">matrixrow</kw>,
<kw role = "element">set</kw>,
<kw role = "element">vector</kw>,
<kw role = "element">apply</kw>,
<kw role = "element">reln</kw>,
<kw role = "element">fn</kw>,
<kw role = "element">lambda</kw>,
<kw role = "element">piecewise, piece, otherwise</kw>
</td>
</tr>
<tr>
<td>Specials</td>
<td>
<kw role = "element">declare</kw></td></tr></tbody></table></p>
<div4>
<head>Tokens</head>
<p>Token elements are typically the leaves of the MathML expression tree. Token elements are used to indicate mathematical identifiers, numbers and symbols.</p>
<p>It is also possible for the canonically empty operator elements such as
<kw role = "element">exp</kw>,
<kw role = "element">sin</kw> and
<kw role = "element">cos</kw> to be leaves in an expression tree. The usage of operator elements is described in
<specref ref = "contm_funopqual"/>.
<glist>
<gitem>
<label>cn</label>
<def>
<p>The
<kw role = "element">cn</kw> element is the MathML token element used to represent numbers. The supported types of numbers include:
<kw role = "attval">real</kw>,
<kw role = "attval">integer</kw>,
<kw role = "attval">rational</kw>,
<kw role = "attval">complex-cartesian</kw>, and
<kw role = "attval">complex-polar</kw>, with
<kw role = "attval">real</kw> being the default type. An attribute
<kw role = "attrib">base</kw> (with default value
<kw role = "attval">10</kw>) is used to help specify how the content is to be parsed. The content itself is essentially
<kw>PCDATA</kw>, separated by
<kw role = "emptytag">sep</kw> when two parts are needed in order to fully describe a number. For example, the real number 3 is constructed by
<code><![CDATA[<cn type="real"> 3 </cn>]]></code>, while the rational number 3/4 is constructed as
<code><![CDATA[<cn type="rational"> 3<sep/>4 </cn>]]></code>. The detailed structure and specifications are provided in
<specref ref = "contm_cn"/>.</p></def></gitem>
<gitem>
<label>ci</label>
<def>
<p>The
<kw role = "element">ci</kw> element, or
<quote>content identifier</quote> is used to construct a variable, or an identifier. A
<kw role = "attrib">type</kw> attribute indicates the type of object the symbol represents. Typically,
<kw role = "element">ci</kw> represents a real scalar, but no default is specified. The content is either
<kw>PCDATA</kw> or a general presentation construct (see
<specref ref = "presm_summary"/>). For example,
<eg role = "mathml"><![CDATA[
<ci>
<msub>
<mi>c</mi>
<mn>1</mn>
</msub>
</ci>
]]></eg>encodes an atomic symbol that displays visually as
<mi>c</mi><sub>1</sub>
which, for purposes of content, is treated as a single symbol representing a real number. The detailed structure and specifications are provided in
<specref ref = "contm_ci"/>.</p></def></gitem>
<gitem>
<label>csymbol</label>
<def>
<p>The
<kw role = "element">csymbol</kw> element, or
<quote>content symbol</quote> is used to construct a symbol whose semantics are not part of the core content elements provided by MathML, but defined externally.
<kw role = "element">csymbol</kw> does not make any attempt to describe how to map the arguments occurring in any application of the function into a new MathML expression. Instead, it depends on its
<kw role = "attrib">definitionURL</kw> attribute to point to a particular meaning, and the
<kw role = "attrib">encoding</kw> attribute to give the syntax of this definition. The content of a
<kw role = "element">csymbol</kw> is either
<kw>PCDATA</kw> or a general presentation construct (see
]]></eg>encodes an atomic symbol that displays visually as
<mi>C</mi><sup>2</sup> and that, for purposes of content, is treated as a single symbol representing the space of twice-differentiable continuous functions. The detailed structure and specifications are provided in
<p>MathML provides a number of elements for combining elements into familiar compound objects. The compound objects include things like lists and sets. Each constructor produces a new type of object.
<glist>
<gitem>
<label>interval</label>
<def>
<p>The
<kw role = "element">interval</kw> element is described in detail in
<specref ref = "contm_interval"/>. It denotes an interval on the real line with the values represented by its children as end points. The
<kw role = "attrib">closure</kw> attribute is used to qualify the type of interval being represented. For example,
<eg role = "mathml"><![CDATA[
<interval closure="open-closed">
<ci> a </ci>
<ci> b </ci>
</interval>
]]></eg>represents the open-closed interval often written (<mi>a</mi>,
<mi>b</mi>].</p></def></gitem>
<gitem>
<label>set and list</label>
<def>
<p>The
<kw role = "element">set</kw> and
<kw role = "element">list</kw> elements are described in detail in
<specref ref = "contm_set"/> and
<specref ref = "contm_list"/>. Typically, the child elements of a possibly empty
<kw role = "element">list</kw> element are the actual components of an ordered
<emph>list</emph>. For example, an ordered list of the three symbols
<mi>a</mi>,
<mi>b</mi>, and
<mi>c</mi> is encoded as
<eg role = "mathml"><![CDATA[
<list> <ci> a </ci> <ci> b </ci> <ci> c </ci> </list>
]]></eg>Alternatively,
<kw role = "element">bvar</kw> and
<kw role = "element">condition</kw> elements can be used to define lists where membership depends on satisfying certain conditions.</p>
<p>An
<kw role = "attrib">order</kw> attribute can be used to specify what ordering is to be used. When the nature of the child elements permits, the ordering defaults to a numeric or lexicographic ordering.</p>
<p>Sets are structured much the same as lists except that there is no implied ordering and the
<kw role = "attrib">type</kw> of set may be
<kw role = "attval">normal</kw> or
<kw role = "attval">multiset</kw> with
<kw role = "attval">multiset</kw> indicating that repetitions are allowed.</p>
<p>For both sets and lists, the child elements must be valid MathML content elements. The type of the child elements is not restricted. For example, one might construct a list of equations, or of inequalities.</p></def></gitem>
<gitem>
<label>matrix and matrixrow</label>
<def>
<p>The
<kw role = "element">matrix</kw> element is used to represent mathematical matrices. It is described in detail in
<specref ref = "contm_matrix"/>. It has zero or more child elements, all of which are
<kw role = "element">matrixrow</kw> elements. These in turn expect zero or more child elements that evaluate to algebraic expressions or numbers. These sub-elements are often real numbers, or symbols as in
<kw role = "element">matrixrow</kw> elements must always be contained inside of a matrix, and all rows in a given matrix must have the same number of elements.</p>
<p>Note that the behavior of the
<kw role = "element">matrix</kw> and
<kw role = "element">matrixrow</kw> elements is substantially different from the
<kw role = "element">mtable</kw> and
<kw role = "element">mtr</kw> presentation elements.</p></def></gitem>
<gitem>
<label>vector</label>
<def>
<p>The
<kw role = "element">vector</kw> element is described in detail in
<specref ref = "contm_vector"/>. It constructs vectors from an
<mi>n</mi>-dimensional vector space so that its
<mi>n</mi> child elements typically represent real or complex valued scalars as in the three-element vector
<eg role = "mathml"><![CDATA[
<vector>
<apply>
<plus/>
<ci> x </ci>
<ci> y </ci>
</apply>
<cn> 3 </cn>
<cn> 7 </cn>
</vector>
]]></eg></p></def></gitem>
<gitem>
<label>apply</label>
<def>
<p>The
<kw role = "element">apply</kw> element is described in detail in
<specref ref = "contm_apply"/>. Its purpose is to apply a function or operator to its arguments to produce an expression representing an element of the codomain of the function. It is involved in everything from forming sums such as
<mi>a</mi> +
<mi>b</mi> as in
<eg role = "mathml"><![CDATA[
<apply>
<plus/>
<ci> a </ci>
<ci> b </ci>
</apply>
]]></eg>through to using the sine function to construct sin(<mi>a</mi>) as in
<eg role = "mathml"><![CDATA[
<apply>
<sin/>
<ci> a </ci>
</apply>
]]></eg>or constructing integrals. Its usage in any particular setting is determined largely by the properties of the function (the first child element) and as such its detailed usage is covered together with the functions and operators in
<kw role = "element">reln</kw> element is described in detail in
<specref ref = "contm_reln"/>. It was used in MathML 1.0 to construct an expression such as
<mi>a</mi> =
<mi>b</mi>, as in
<eg role = "mathml"><![CDATA[
<reln><eq/>
<ci> a </ci>
<ci> b </ci>
</reln>
]]></eg>indicating an intended comparison between two mathematical values.</p>
<p>MathML 2.0 takes the view that this should be regarded as the application of a boolean function, and as such could be constructed using
<kw role = "element">apply</kw>. The use of
<kw>reln</kw> with logical operators is supported
for reasons of backwards compatibility, but <intref
ref="interf_deprec">deprecated</intref> in favor of
<kw>apply</kw>.</p></def></gitem>
<gitem>
<label>fn</label>
<def>
<p>The
<kw role = "element">fn</kw> element was used in MathML 1.0 to make
explicit the fact that an expression is being used as a function or
operator. This is allowed in MathML 2.0 for backwards compatibility,
but is <intref ref="interf_deprec">deprecated</intref>, as the use of
an expression as a function or operator is clear from its position as
the first child of an
<kw role = "element">apply</kw>.
<kw role = "element">fn</kw> is discussed in detail in
<specref ref = "contm_fn"/>.</p></def></gitem>
<gitem>
<label>lambda</label>
<def>
<p>The
<kw role = "element">lambda</kw> element is used to construct a user-defined function from an expression and one or more free variables. The lambda construct with
<mi>n</mi> internal variables takes
<mi>n</mi>+1 children. The first (second, up to
<mi>n</mi>) is a
<kw role = "element">bvar</kw> containing the identifiers of the internal variables. The last is an expression defining the function. This is typically an
<kw role = "element">apply</kw>, but can also be any container element. The following constructs
<graphic role = "inline" source = "image/f4002.gif" alt = "\lambda"/>
(<mi>x</mi>, sin
<mi>x</mi>)
<eg role = "mathml"><![CDATA[
<lambda>
<bvar><ci> x </ci></bvar>
<apply>
<sin/>
<ci> x </ci>
</apply>
</lambda>
]]></eg>The following constructs the constant function
<graphic role = "inline" source = "image/f4002.gif" alt = "\lambda"/>
(<mi>x</mi>, 3)
<eg role = "mathml"><![CDATA[
<lambda>
<bvar><ci> x </ci></bvar>
<cn> 3 </cn>
</lambda>
]]></eg></p></def></gitem>
<gitem>
<label>piecewise, piece, otherwise</label>
<def>
<p>The
<kw role = "element">piecewise</kw>,
<kw role = "element">piece</kw>,
<kw role = "element">otherwise</kw>
elements are used to support <quote>piecewise</quote> declarations of the form <quote>
<mi>H</mi>(<mi>x</mi>) = 0 if <mi>x</mi> less than 0,
<mi>H</mi>(<mi>x</mi>) = 1 otherwise</quote>.</p>
<p>
<eg role = "mathml"><![CDATA[
<piecewise>
<piece>
<cn> 0 </cn>
<apply><lt/><ci> x </ci> <cn> 0 </cn></apply>
</piece>
<otherwise>
<ci> x </ci>
</otherwise>
</piecewise>
]]></eg>
The <kw role = "element">piecewise</kw> elements are discussed in detail in
<specref ref = "contm_piecewise"/>.
</p></def></gitem>
</glist></p></div4>
<div4>
<head>Special Constructs</head>
<p>The
<kw role = "element">declare</kw> construct is described in detail in
<specref ref = "contm_declare"/>. It is special in that its entire purpose is to modify
the semantics of other objects. It is not rendered visually or aurally.</p>
<p>The need for declarations arises any time a symbol (including more general presentations)
is being used to represent an instance of an object of a particular type. For example,
you may wish to declare that the symbolic identifier <mi>V</mi> represents a vector.
The single argument form can be used to set properties of objects by setting
the default values of implied attribute values to specific values.</p>
<p>The declaration
<eg role = "mathml"><![CDATA[
<declare type="vector"><ci>V</ci></declare>
]]></eg>resets the default type attribute of
<code><![CDATA[<ci>V</ci>]]></code> to
<kw role = "attval">vector</kw> for all affected occurrences of
<code><![CDATA[<ci>V</ci>]]></code>. This avoids having to write
<code><![CDATA[<ci type="vector">V</ci>]]></code> every time you use the symbol.</p>
<p>More generally,
<kw role = "element">declare</kw> can be used to associate expressions with specific content. For example, the declaration
<eg role = "mathml"><![CDATA[
<declare>
<ci>F</ci>
<lambda>
<bvar><ci> U </ci></bvar>
<apply>
<int/>
<bvar><ci> x </ci></bvar>
<lowlimit><cn> 0 </cn></lowlimit>
<uplimit><ci> a </ci></uplimit>
<ci> U </ci>
</apply>
</lambda>
</declare>
]]></eg>associates the symbol
<mi>F</mi> with a new function defined by the
<kw role = "element">lambda</kw> construct. Within the scope where the declaration is in effect, the expression
<eg role = "mathml"><![CDATA[
<apply>
<ci>F</ci>
<ci> U </ci>
</apply>
]]></eg>stands for the integral of
<mi>U</mi> from 0 to
<mi>a</mi>.</p>
<p>The
<kw role = "element">declare</kw> element can also be used to change the definition of a function or operator. For example, if the URL
<code>http://.../MathML:noncommutplus</code> described a non-commutative plus operation encoded in Maple syntax, then the declaration
<kw role = "element">plus</kw> are to be interpreted as having that definition of
<kw role = "element">plus</kw>.</p></div4></div3>
<div3 id = "contm_funopqual">
<head>Functions, Operators and Qualifiers</head>
<p>The operators and functions defined by MathML can be divided into categories as shown in the table below. <!-- TODO: the second column should be a p column in LaTeX -->
<table id = "contm_table-funopqual" border = "1">
<tbody>
<tr>
<td>unary arithmetic</td>
<td>
<kw role = "element">factorial</kw>,
<kw role = "element">minus</kw>,
<kw role = "element">abs</kw>,
<kw role = "element">conjugate</kw>,
<kw role = "element">arg</kw>,
<kw role = "element">real</kw>,
<kw role = "element">imaginary</kw>,
<kw role = "element">floor</kw>,
<kw role = "element">ceiling</kw>
</td></tr>
<tr>
<td>unary logical</td>
<td>
<kw role = "element">not</kw></td></tr>
<tr>
<td>unary functional</td>
<td>
<kw role = "element">inverse</kw>,
<kw role = "element">ident</kw>,
<kw role = "element">domain</kw>,
<kw role = "element">codomain</kw>,
<kw role = "element">image</kw>
</td></tr>
<tr>
<td>unary elementary classical functions</td>
<td>
<kw role = "element">sin</kw>,
<kw role = "element">cos</kw>,
<kw role = "element">tan</kw>,
<kw role = "element">sec</kw>,
<kw role = "element">csc</kw>,
<kw role = "element">cot</kw>,
<kw role = "element">sinh</kw>,
<kw role = "element">cosh</kw>,
<kw role = "element">tanh</kw>,
<kw role = "element">sech</kw>,
<kw role = "element">csch</kw>,
<kw role = "element">coth</kw>,
<kw role = "element">arcsin</kw>,
<kw role = "element">arccos</kw>,
<kw role = "element">arctan</kw>,
<kw role = "element">arccosh</kw>,
<kw role = "element">arccot</kw>,
<kw role = "element">arccoth</kw>,
<kw role = "element">arccsc</kw>,
<kw role = "element">arccsch</kw>,
<kw role = "element">arcsec</kw>,
<kw role = "element">arcsech</kw>,
<kw role = "element">arcsinh</kw>,
<kw role = "element">arctanh</kw>,
<kw role = "element">exp</kw>,
<kw role = "element">ln</kw>,
<kw role = "element">log</kw></td></tr>
<tr>
<td>unary linear algebra</td>
<td>
<kw role = "element">determinant</kw>,
<kw role = "element">transpose</kw></td></tr>
<tr>
<td>unary calculus and vector calculus</td>
<td>
<kw role = "element">divergence</kw>,
<kw role = "element">grad</kw>,
<kw role = "element">curl</kw>,
<kw role = "element">laplacian</kw></td></tr>
<tr>
<td>unary set-theoretic</td>
<td>
<kw role = "element">card</kw></td></tr>
<tr>
<td>binary arithmetic</td>
<td>
<kw role = "element">quotient</kw>,
<kw role = "element">divide</kw>,
<kw role = "element">minus</kw>,
<kw role = "element">power</kw>,
<kw role = "element">rem</kw></td></tr>
<tr>
<td>binary logical</td>
<td>
<kw role = "element">implies</kw>,
<kw role = "element">equivalent</kw>,
<kw role = "element">approx</kw></td></tr>
<tr>
<td>binary set operators</td>
<td>
<kw role = "element">setdiff</kw></td></tr>
<tr>
<td>binary linear algebra</td>
<td>
<kw role = "element">vectorproduct</kw>,
<kw role = "element">scalarproduct</kw>,
<kw role = "element">outerproduct</kw></td></tr>
<tr>
<td>n-ary arithmetic</td>
<td>
<kw role = "element">plus</kw>,
<kw role = "element">times</kw>,
<kw role = "element">max</kw>,
<kw role = "element">min</kw>,
<kw role = "element">gcd</kw>,
<kw role = "element">lcm</kw>
</td></tr>
<tr>
<td>n-ary statistical</td>
<td>
<kw role = "element">mean</kw>,
<kw role = "element">sdev</kw>,
<kw role = "element">variance</kw>,
<kw role = "element">median</kw>,
<kw role = "element">mode</kw></td></tr>
<tr>
<td>n-ary logical</td>
<td>
<kw role = "element">and</kw>,
<kw role = "element">or</kw>,
<kw role = "element">xor</kw></td></tr>
<tr>
<td>n-ary linear algebra</td>
<td>
<kw role = "element">selector</kw></td></tr>
<tr>
<td>n-ary set operator</td>
<td>
<kw role = "element">union</kw>,
<kw role = "element">intersect</kw>,
<kw role = "element">cartesianproduct</kw>
</td></tr>
<tr>
<td>n-ary functional</td>
<td>
<kw role = "element">fn</kw>,
<kw role = "element">compose</kw></td></tr>
<tr>
<td>integral, sum, product operators</td>
<td>
<kw role = "element">int</kw>,
<kw role = "element">sum</kw>,
<kw role = "element">product</kw></td></tr>
<tr>
<td>differential operator</td>
<td>
<kw role = "element">diff</kw>,
<kw role = "element">partialdiff</kw></td></tr>
<tr>
<td>quantifier</td>
<td>
<kw role = "element">forall</kw>,
<kw role = "element">exists</kw></td></tr></tbody></table></p>
<p>From the point of view of usage, MathML regards functions (for example
<kw role = "element">sin</kw> and
<kw role = "element">cos</kw>) and operators (for example
<kw role = "element">plus</kw> and
<kw role = "element">times</kw>) in the same way. MathML predefined functions and operators are all canonically empty elements.</p>
<p>Note that the
<kw role = "element">csymbol</kw> element can be used to construct a user-defined symbol that can be used as a function or operator.</p>
<div4>
<head>Predefined functions and operators</head>
<p>MathML functions can be used in two ways. They can be used as the operator within an
<kw role = "element">apply</kw> element, in which case they refer to a function evaluated at a specific value. For example,
<eg role = "mathml"><![CDATA[
<apply>
<sin/>
<cn>5</cn>
</apply>
]]></eg>denotes a real number, namely sin(5).</p>
<p>MathML functions can also be used as arguments to other operators, for example
<eg role = "mathml"><![CDATA[
<apply>
<plus/><sin/><cos/>
</apply>
]]></eg>denotes a function, namely the result of adding the sine and cosine functions in some function space. (The default semantic definition of
<kw role = "element">plus</kw> is such that it infers what kind of operation is intended from the type of its arguments.)</p>
<p>The number of child elements in the
<kw role = "element">apply</kw> is defined by the element in the first (i.e. operator) position.</p>
<p>
<emph>Unary</emph> operators are followed by exactly one other child element within the
<kw role = "element">apply</kw>.</p>
<p>
<emph>Binary</emph> operators are followed by exactly two child elements.</p>
<p>
<emph>N-ary</emph> operators are followed by two or more child elements.</p>
<p>The one exception to these rules is that
<kw role = "element">declare</kw> elements may be inserted in any position except the first.
<kw role = "element">declare</kw> elements are not counted when satisfying the child element count for an
<kw role = "element">apply</kw> containing a unary or binary operator element.</p>
<p>Integral, sum, product and differential operators are discussed below in
<specref ref = "contm_opwithqual"/>.</p></div4>
<div4 id = "contm_opwithqual">
<head>Operators taking Qualifiers</head>
<p>The table below contains the qualifiers and the operators defined as taking qualifiers in MathML.
<table border = "1">
<tbody>
<tr>
<td>qualifiers</td>
<td>
<kw role = "element">lowlimit</kw>,
<kw role = "element">uplimit</kw>,
<kw role = "element">bvar</kw>,
<kw role = "element">degree</kw>,
<kw role = "element">logbase</kw>,
<kw role = "element">interval</kw>,
<kw role = "element">condition</kw>,
<kw role = "element">domainofapplication</kw>,
<kw role = "element">momentabout</kw>
</td></tr>
<tr>
<td>operators</td>
<td>
<kw role = "element">int</kw>,
<kw role = "element">sum</kw>,
<kw role = "element">product</kw>,
<kw role = "element">root</kw>,
<kw role = "element">diff</kw>,
<kw role = "element">partialdiff</kw>,
<kw role = "element">limit</kw>,
<kw role = "element">log</kw>,
<kw role = "element">moment</kw>,
<kw role = "element">min</kw>,
<kw role = "element">max</kw>,
<kw role = "element">forall</kw>,
<kw role = "element">exists</kw></td></tr></tbody></table></p>
<p>Operators taking qualifiers are canonically empty functions that differ from ordinary empty functions only in that they support the use of special
<emph>qualifier</emph> elements to specify their meaning more fully. They are used in exactly the same way as ordinary operators, except that when they are used as operators, certain qualifier elements are also permitted to be in the enclosing
<kw role = "element">apply</kw>. Qualifiers always follow the operator and precede the argument if it is present. If more than one qualifier is present, they appear in the order
<kw role = "element">bvar</kw>,
<kw role = "element">lowlimit</kw>,
<kw role = "element">uplimit</kw>,
<kw role = "element">interval</kw>,
<kw role = "element">condition</kw>,
<kw role = "element">domainofapplication</kw>,
<kw role = "element">degree</kw>,
<kw role = "element">momentabout</kw>,
<kw role = "element">logbase</kw>. A typical example is:
<eg role = "mathml"><![CDATA[
<apply>
<int/>
<bvar><ci>x</ci></bvar>
<interval><cn>0</cn><cn>1</cn></interval>
<apply>
<power/>
<ci>x</ci>
<cn>2</cn>
</apply>
</apply>
]]></eg></p>
<p>It is also valid to use qualifier schema with a function not applied to an argument. For example, a function acting on integrable functions on the interval [0,1] might be denoted:
<eg role = "mathml"><![CDATA[
<fn>
<apply>
<int/>
<bvar><ci>x</ci></bvar>
<lowlimit><cn>0</cn></lowlimit>
<uplimit><cn>1</cn></uplimit>
</apply>
</fn>
]]></eg></p>
<p>In addition to the defined usage in MathML, qualifier schema may be used with any user-defined symbol
(e.g. using <kw role = "element">csymbol</kw>) or construct. The meaning of such a usage is not defined by MathML;
it would normally be user-defined using the <kw role = "attrib">definitionURL</kw> attribute.</p>
<p>The meaning and usage of qualifier schema varies from function to function. The following list summarizes the usage of qualifier schema with the MathML functions taking qualifiers.
<glist>
<gitem>
<label>int</label>
<def>
<p>The
<kw role = "element">int</kw> function accepts the
<kw role = "element">lowlimit</kw>,
<kw role = "element">uplimit</kw>,
<kw role = "element">bvar</kw>,
<kw role = "element">interval</kw>,
<kw role = "element">condition</kw> and
<kw role = "element">domainofapplication</kw> schemata. If both
<kw role = "element">lowlimit</kw> and
<kw role = "element">uplimit</kw> schemata are present, they denote the limits of a definite integral. The domain of integration may alternatively be specified using
<kw role = "element">interval</kw>,
<kw role = "element">condition</kw> or
<kw role = "element">domainofapplication</kw>. The
<kw role = "element">bvar</kw> schema signifies the variable of integration. When used with
<kw role = "element">int</kw>, each qualifier schema is expected to contain a single child schema; otherwise an error is generated.</p></def></gitem>
<gitem>
<label>diff</label>
<def>
<p>The
<kw role = "element">diff</kw> function accepts the
<kw role = "element">bvar</kw> schema. The
<kw role = "element">bvar</kw> schema specifies with respect to which variable the derivative is being taken. The
<kw role = "element">bvar</kw> may itself contain a
<kw role = "element">degree</kw> schema that is used to specify the order of the derivative, i.e. a first derivative, a second derivative, etc. For example, the second derivative of
<mi>f</mi> with respect to
<mi>x</mi> is:
<eg role = "mathml"><![CDATA[
<apply>
<diff/>
<bvar>
<ci> x </ci>
<degree>
<cn> 2 </cn>
</degree>
</bvar>
<apply><fn><ci>f</ci></fn>
<ci> x </ci>
</apply>
</apply>
]]></eg></p></def></gitem>
<gitem>
<label>partialdiff</label>
<def>
<p>The
<kw role = "element">partialdiff</kw> operator accepts zero or more
<kw role = "element">bvar</kw> schemata, and an optional <kw role = "element">degree</kw> qualifier schema. The
<kw role = "element">bvar</kw> schema specify, in order, the variables with respect to which the derivative is being taken. Each
<kw role = "element">bvar</kw> element may contain a
<kw role = "element">degree</kw> schema which is used to specify the order of the derivative being taken with respect to that
variable. The optional <kw role = "element">degree</kw> schema qualifier associated with the
<kw role = "element">partialdiff</kw> element itself (that is, appearing as a child of the enclosing
<kw role = "element">apply</kw> element rather than of one of the <kw role = "element">bvar</kw> qualifiers) is used to represent
the total degree of the differentiation. Each
<kw role = "element">degree</kw> schema used with <kw role = "element">partialdiff</kw> is expected
to contain a single child schema. For example,
<eg role = "mathml"><![CDATA[
<apply>
<partialdiff/>
<bvar>
<degree><cn>2</cn></degree>
<ci>x</ci>
</bvar>
<bvar><ci>y</ci></bvar>
<bvar><ci>x</ci></bvar>
<degree><cn>4</cn></degree>
<ci type="fn">f</ci>
</apply>
]]></eg>denotes the mixed partial derivative ( d<sup>4</sup> /
<kw role = "element">product</kw> functions accept the
<kw role = "element">bvar</kw>,
<kw role = "element">lowlimit</kw>,
<kw role = "element">uplimit</kw>,
<kw role = "element">interval</kw>,
<kw role = "element">condition</kw> and
<kw role = "element">domainofapplication</kw> schemata. If both
<kw role = "element">lowlimit</kw> and
<kw role = "element">uplimit</kw> schemata are present, they denote the limits of the sum or product. The limits may alternatively be specified using the
<kw role = "element">interval</kw>,
<kw role = "element">condition</kw> or
<kw role = "element">domainofapplication</kw> schema. The
<kw role = "element">bvar</kw> schema signifies the internal variable in the sum or product. A typical example might be:
<eg role = "mathml"><![CDATA[
<apply>
<sum/>
<bvar><ci>i</ci></bvar>
<lowlimit><cn>0</cn></lowlimit>
<uplimit><cn>100</cn></uplimit>
<apply>
<power/>
<ci>x</ci>
<ci>i</ci>
</apply>
</apply>
]]></eg>When used with
<kw role = "element">sum</kw> or
<kw role = "element">product</kw>, each qualifier schema is expected to contain a single child schema; otherwise an error is generated.</p></def></gitem>
<gitem>
<label>limit</label>
<def>
<p>The
<kw role = "element">limit</kw> function accepts zero or more
<kw role = "element">bvar</kw> schemata, and optional
<kw role = "element">condition</kw> and
<kw role = "element">lowlimit</kw> schemata. A
<kw role = "element">condition</kw> may be used to place constraints on the
<kw role = "element">bvar</kw>. The
<kw role = "element">bvar</kw> schema denotes the variable with respect to which the limit is being taken. The
<kw role = "element">lowlimit</kw> schema denotes the limit point. When used with
<kw role = "element">limit</kw>, the
<kw role = "element">bvar</kw> and
<kw role = "element">lowlimit</kw> schemata are expected to contain a single child schema; otherwise an error is generated.</p></def></gitem>
<gitem>
<label>log</label>
<def>
<p>The
<kw role = "element">log</kw> function accepts only the
<kw role = "element">logbase</kw> schema. If present, the
<kw role = "element">logbase</kw> schema denotes the base with respect to which the logarithm is being taken. Otherwise, the log is assumed to be base 10. When used with
<kw role = "element">log</kw>, the
<kw role = "element">logbase</kw> schema is expected to contain a single child schema; otherwise an error is generated.</p></def></gitem>
<gitem>
<label>moment</label>
<def>
<p>The
<kw role = "element">moment</kw> function accepts the
<kw role = "element">degree</kw> and <kw role = "element">momentabout</kw> schema. If present, the
<kw role = "element">degree</kw> schema denotes the order of the moment. Otherwise, the moment is assumed to be the first order moment. When used with
<kw role = "element">moment</kw>, the
<kw role = "element">degree</kw> schema is expected to contain a single child schema; otherwise an error is generated. If present, the
<kw role = "element">momentabout</kw> schema denotes the point about which the moment is taken. Otherwise, the moment is assumed to be the moment about zero.</p></def></gitem>
<gitem>
<label>min, max</label>
<def>
<p>The
<kw role = "element">min</kw> and
<kw role = "element">max</kw> functions accept a
<kw role = "element">bvar</kw> schema in cases where the maximum or minimum is being taken over a set of values specified by a
<kw role = "element">condition</kw> schema together with an expression to be evaluated on that set.
<kw role = "element"></kw>In MathML1.0, the
<kw role = "element">bvar</kw> element was optional when using a
<kw role = "element">condition</kw>; if a
<kw role = "element">condition</kw> element containing a single variable was given by itself following a
<kw role = "element">min</kw> or
<kw role = "element">max</kw> operator, the variable was implicitly
assumed to be bound, and the expression to be maximized or minimized
(if absent) was assumed to be the single bound variable. This usage
is <intref ref="interf_deprec">deprecated</intref> in MathML 2.0 in
favor of explicitly stating the bound variable(s) and the expression
to be maximized or minimized in all cases.</p>
<p>The
<kw role = "element">min</kw> and
<kw role = "element">max</kw> elements may also be applied to a list of values in which case no qualifier schemata are used. For examples of all three usages, see
<p>The universal and existential quantifier operators
<kw role = "element">forall</kw> and
<kw role = "element">exists</kw> are used in conjunction with one or more
<kw role = "element">bvar</kw> schemata to represent simple logical assertions. There are two ways of using the logical quantifier operators. The first usage is for representing a simple, quantified assertion. For example, the statement
<quote>there exists
<mi>x</mi>< 9</quote> would be represented as:
<eg role = "mathml"><![CDATA[
<apply>
<exists/>
<bvar><ci> x </ci></bvar>
<apply><lt/>
<ci> x </ci><cn> 9 </cn>
</apply>
</apply>
]]></eg>The second usage is for representing implications. Hypotheses are given by a
<kw role = "element">condition</kw> element following the bound variables. For example the statement
<quote>for all
<mi>x</mi> < 9,
<mi>x</mi> < 10</quote> would be represented as:
<eg role = "mathml"><![CDATA[
<apply>
<forall/>
<bvar><ci> x </ci></bvar>
<condition>
<apply><lt/>
<ci> x </ci><cn> 9 </cn>
</apply>
</condition>
<apply><lt/>
<ci> x </ci><cn> 10 </cn>
</apply>
</apply>
]]></eg>Note that in both usages one or more
<kw role = "element">bvar</kw> qualifiers are mandatory.</p></def></gitem></glist></p></div4></div3>
<div3 id = "contm_relation">
<head>Relations</head>
<table>
<tbody>
<tr>
<td>binary relation</td>
<td>
<kw role = "element">neq</kw>,
<kw role = "element">equivalent</kw>,
<kw role = "element">approx</kw>,
<kw role = "element">factorof</kw>
</td></tr>
<tr>
<td>binary logical relation</td>
<td>
<kw role = "element">implies</kw></td></tr>
<tr>
<td>binary set relation</td>
<td>
<kw role = "element">in</kw>,
<kw role = "element">notin</kw>,
<kw role = "element">notsubset</kw>,
<kw role = "element">notprsubset</kw></td></tr>
<tr>
<td>binary series relation</td>
<td>
<kw role = "element">tendsto</kw></td></tr>
<tr>
<td>n-ary relation</td>
<td>
<kw role = "element">eq</kw>,
<kw role = "element">leq</kw>,
<kw role = "element">lt</kw>,
<kw role = "element">geq</kw>,
<kw role = "element">gt</kw></td></tr>
<tr>
<td>n-ary set relation</td>
<td>
<kw role = "element">subset</kw>,
<kw role = "element">prsubset</kw></td></tr></tbody></table>
<p>The MathML content tags include a number of canonically empty elements which denote arithmetic and logical relations. Relations are characterized by the fact that, if an external application were to evaluate them (MathML does not specify how to evaluate expressions), they would typically return a truth value. By contrast, operators generally return a value of the same type as the operands. For example, the result of evaluating
<mi>a</mi> <
<mi>b</mi> is either true or false (by contrast, 1 + 2 is again a number).</p>
<p>Relations are bracketed with their arguments using the
<kw role = "element">apply</kw> element in the same way as other functions. In MathML 1.0, relational operators were bracketed using
<kw role = "element">reln</kw>. This usage, although still supported,
is now <intref ref="interf_deprec">deprecated</intref> in favor of
<kw>apply</kw>. The element for the relational operator is the first child element of the
<kw role = "element">apply</kw>. Thus, the example from the preceding paragraph is properly marked up as:
<eg role = "mathml"><![CDATA[
<apply>
<lt/>
<ci>a</ci>
<ci>b</ci>
</apply>
]]></eg>It is an error to enclose a relation in an element other than
<kw role = "element">apply</kw> or
<kw role = "element">reln</kw>.</p>
<p>The number of child elements in the
<kw role = "element">apply</kw> is defined by the element in the first (i.e. relation) position.</p>
<p>
<emph>Unary</emph> relations are followed by exactly one other child element within the
<kw role = "element">apply</kw>.</p>
<p>
<emph>Binary</emph> relations are followed by exactly two child elements.</p>
<p>
<emph>N-ary</emph> relations are followed by zero or more child elements.</p>
<p>The one exception to these rules is that
<kw role = "element">declare</kw> elements may be inserted in any position except the first.
<kw role = "element">declare</kw> elements are not counted when satisfying the child element count for an
<kw role = "element">apply</kw> containing a unary or binary relation element.</p></div3>
<div3 id = "contm_conditions">
<head>Conditions</head>
<table border = "1">
<tbody>
<tr>
<td>condition</td>
<td>
<kw role = "element">condition</kw></td></tr></tbody></table>
<p>The
<kw role = "element">condition</kw> element is used to define the
<quote>such that</quote> construct in mathematical expressions. Condition elements are used in a number of contexts in MathML. They are used to construct objects like sets and lists by rule instead of by enumeration. They can be used with the
<kw role = "element">forall</kw> and
<kw role = "element">exists</kw> operators to form logical expressions. And finally, they can be used in various ways in conjunction with certain operators. For example, they can be used with an
<kw role = "element">int</kw> element to specify domains of integration, or to specify argument lists for operators like
<kw role = "element">min</kw> and
<kw role = "element">max</kw>.</p>
<p>The
<kw role = "element">condition</kw> element is always used together with one or more
<kw role = "element">bvar</kw> elements.</p>
<p>The exact interpretation depends on the context, but generally speaking, the
<kw role = "element">condition</kw> element is used to restrict the permissible values of a bound variable appearing in another expression to those that satisfy the relations contained in the
<kw role = "element">condition</kw>. Similarly, when the
<kw role = "element">condition</kw> element contains a
<kw role = "element">set</kw>, the values of the bound variables are restricted to that set.</p>
<p>A condition element contains a single child that is either an
<kw role = "element">apply</kw>, or a
<kw role = "element">reln</kw> element (<intref
ref="interf_deprec">deprecated</intref>). Compound conditions are
indicated by applying relations such as
<kw role = "element">and</kw> inside the child of the condition.</p>
<p>A third example shows the use of quantifiers with
<kw role = "element">condition</kw>. The following markup encodes
<quote>there exists
<mi>x</mi> < 3 such that
<mi>x</mi><sup>2</sup> = 4</quote>.
<eg role = "mathml"><![CDATA[
<apply>
<exists/>
<bvar><ci> x </ci></bvar>
<condition>
<apply><lt/><ci>x</ci><cn>3</cn></apply>
</condition>
<apply>
<eq/>
<apply>
<power/><ci>x</ci><cn>2</cn>
</apply>
<cn>4</cn>
</apply>
</apply>
]]></eg></p></div4></div3>
<div3 id = "contm_synsem">
<head>Syntax and Semantics</head>
<table border = "1">
<tbody>
<tr>
<td>mappings</td>
<td>
<kw role = "element">semantics</kw>,
<kw role = "element">annotation</kw>,
<kw role = "element">annotation-xml</kw></td></tr></tbody></table>
<p>The use of content markup rather than presentation markup for mathematics is sometimes referred to as
<emph>semantic tagging</emph>
<bibref ref = "Buswell1996"/>. The parse-tree of a valid element structure using MathML content elements corresponds directly to the expression tree of the underlying mathematical expression. We therefore regard the content tagging itself as encoding the
<emph>syntax</emph> of the mathematical expression. This is, in general, sufficient to obtain some rendering and even some symbolic manipulation (e.g. polynomial factorization).</p>
<p>However, even in such apparently simple expressions as
<mi>X</mi> +
<mi>Y</mi>, some additional information may be required for applications such as computer algebra. Are
<mi>X</mi> and
<mi>Y</mi> integers, or functions, etc.?
<quote>Plus</quote> represents addition over which field? This additional information is referred to as
<emph>semantic mapping</emph>. In MathML, this mapping is provided by the
<kw role = "element">semantics</kw>,
<kw role = "element">annotation</kw> and
<kw role = "element">annotation-xml</kw> elements.</p>
<p>The
<kw role = "element">semantics</kw> element is the container element for the MathML expression together with its semantic mappings.
<kw role = "element">semantics</kw> expects a variable number of child elements. The first is the element (which may itself be a complex element structure) for which this additional semantic information is being defined. The second and subsequent children, if any, are instances of the elements
<kw role = "element">annotation</kw> and/or
<kw role = "element">annotation-xml</kw>.</p>
<p>The
<kw role = "element">semantics</kw> element also accepts the
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes for use by external processing applications. One use might be a URI for a semantic content dictionary, for example. Since the semantic mapping information might in some cases be provided entirely by the
<kw role = "attrib">definitionURL</kw> attribute, the
<kw role = "element">annotation</kw> or
<kw role = "element">annotation-xml</kw> elements are optional.</p>
<p>The
<kw role = "element">annotation</kw> element is a container for arbitrary data. This data may be in the form of text, computer algebra encodings, C programs, or whatever a processing application expects.
<kw role = "element">annotation</kw> has an attribute
<kw role = "attval">encoding</kw> defining the form in use. Note that the content model of
<kw role = "element">annotation</kw> is
<kw>PCDATA</kw>, so care must be taken that the particular encoding does not conflict with XML parsing rules.</p>
<p>The
<kw role = "element">annotation-xml</kw> element is a container for semantic information in well-formed XML. For example, an XML form of the OpenMath semantics could be given. Another possible use here is to embed, for example, the presentation tag form of a construct given in content tag form in the first child element of
<kw role = "element">semantics</kw> (or vice versa).
<kw role = "element">annotation-xml</kw> has an attribute
<kw role = "attval">encoding</kw> defining the form in use.</p>
<p>For example:
<eg role = "mathml"><![CDATA[
<semantics>
<apply>
<divide/>
<cn>123</cn>
<cn>456</cn>
</apply>
<annotation encoding="Mathematica">
N[123/456, 39]
</annotation>
<annotation encoding="TeX">
$0.269736842105263157894736842105263157894\ldots$
</annotation>
<annotation encoding="Maple">
evalf(123/456, 39);
</annotation>
<annotation-xml encoding="MathML-Presentation">
<mrow>
<mn> 0.269736842105263157894 </mn>
<mover accent='true'>
<mn> 736842105263157894 </mn>
<mo> ‾ </mo>
</mover>
</mrow>
</annotation-xml>
<annotation-xml encoding="OpenMath">
<OMA xmlns="http://www.openmath.org/OpenMath">
<OMS cd="arith1" name="divide"/>
<OMI>123</OMI>
<OMI>456</OMI>
</OMA>
</annotation-xml>
</semantics>
]]></eg>where
<kw role = "element">OMA</kw> is the element defining the additional semantic information.</p>
<p>Of course, providing an explicit semantic mapping at all is optional, and in general would only be provided where there is some requirement to process or manipulate the underlying mathematics.</p></div3>
<div3>
<head>Semantic Mappings</head>
<p>Although semantic mappings can easily be provided by various proprietary, or highly specialized encodings, there are no widely available, non-proprietary standard schemes for semantic mapping. In part to address this need, the goal of the OpenMath effort is to provide a platform-independent, vendor-neutral standard for the exchange of mathematical objects between applications. Such mathematical objects include semantic mapping information. The OpenMath group has defined an XML syntax for the encoding of this information
<bibref ref = "OpenMath2000"/>. This element set could provide the basis of one
<kw role = "element">annotation-xml</kw> element set.</p>
<p>An attractive side of this mechanism is that the OpenMath syntax is specified in XML, so that a MathML expression together with its semantic annotations can be validated using XML parsers.</p></div3>
<div3>
<head>Constants and Symbols</head>
<p>MathML provides a collection of predefined constants and symbols which represent frequently-encountered concepts in K-12 mathematics. These include symbols for well-known sets, such as
<kw role = "element">integers</kw> and
<kw role = "element">rationals</kw>, and also some widely known constant symbols such as
<kw role = "element">false</kw>,
<kw role = "element">true</kw>,
<kw role = "element">exponentiale</kw>.</p></div3>
<div3>
<head>MathML element types</head>
<p>MathML functions, operators and relations can all be thought of as mathematical functions if viewed in a sufficiently abstract way. For example, the standard addition operator can be regarded as a function mapping pairs of real numbers to real numbers. Similarly, a relation can be thought of as a function from some space of ordered pairs into the set of values {true, false}. To be mathematically meaningful, the domain and codomain of a function must be precisely specified. In practical terms, this means that functions only make sense when applied to certain kinds of operands. For example, thinking of the standard addition operator, it makes no sense to speak of
<quote>adding</quote> a set to a function. Since MathML content markup seeks to encode mathematical expressions in a way that can be unambiguously evaluated, it is no surprise that the types of operands is an issue.</p>
<p>MathML specifies the types of arguments in two ways. The first way is by providing precise instructions for processing applications about the kinds of arguments expected by the MathML content elements denoting functions, operators and relations. These operand types are defined in a dictionary of default semantic bindings for content elements, which is given in
<specref ref = "cedef"/>. For example, the MathML content dictionary specifies that for real scalar arguments the plus operator is the standard commutative addition operator over a field. The elements
<kw role = "element">cn</kw> has a
<kw role = "attrib">type</kw> attribute with a default value of
<kw role = "attval">real</kw>. Thus some processors will be able to use this information to verify the validity of the indicated operations.</p>
<p>Although MathML specifies the types of arguments for functions, operators and relations, and provides a mechanism for typing arguments, a MathML-compliant processor is not required to do any type checking. In other words, a MathML processor will not generate errors if argument types are incorrect. If the processor is a computer algebra system, it may be unable to evaluate an expression, but no MathML error is generated.</p></div3></div2>
<div2 id = "contm_attrib">
<head>Content Element Attributes</head>
<div3>
<head>Content Element Attribute Values</head>
<p>Content element attributes are all of the type
<kw>CDATA,</kw> that is, any character string will be accepted as valid. In addition, each attribute has a list of predefined values, which a content processor is expected to recognize and process. The reason that the attribute values are not formally restricted to the list of predefined values is to allow for extension. A processor encountering a value (not in the predefined list) which it does not recognize may validly process it as the default value for that attribute.</p></div3>
<p>Each attribute is followed by the elements to which it can be applied.</p>
<div4>
<head>
<kw role = "attrib">base</kw></head>
<glist>
<gitem>
<label>cn</label>
<def>
<p>indicates numerical base of the number. Predefined values: any numeric string.</p>
<p>The default value is
<kw role = "attval">10</kw></p></def></gitem></glist></div4>
<div4>
<head>
<kw role = "attrib">closure</kw></head>
<glist>
<gitem>
<label>interval</label>
<def>
<p>indicates closure of the interval. Predefined values:
<kw role = "attval">open</kw>,
<kw role = "attval">closed</kw>,
<kw role = "attval">open-closed</kw>,
<kw role = "attval">closed-open</kw>.</p>
<p>The default value is
<kw role = "attval">closed</kw></p></def></gitem></glist></div4>
<div4>
<head>
<kw role = "attrib">definitionURL</kw></head>
<glist>
<gitem>
<label>csymbol, declare, semantics, any operator element</label>
<def>
<p>points to an external definition of the semantics of the symbol or construct being declared. The value is a URL or URI that should point to some kind of definition. This definition overrides the MathML default semantics.</p>
<p>At present, MathML does not specify the format in which external semantic definitions should be given. In particular,
<emph>there is no requirement that the target of the URI be loadable and parsable.</emph>
An external definition could, for example, define the semantics in human-readable form.</p>
<p>Ideally, in most situations the definition pointed to by the
<kw role = "attrib">definitionURL</kw> attribute would be some standard, machine-readable format. However, there are reasons why MathML does not require such a format.</p>
<ulist>
<item>
<p>No such format currently exists. There are several projects underway
to develop and implement standard semantic encoding formats,
most notably the OpenMath effort.
By nature, the development of a comprehensive system of semantic encoding
is a very large enterprise, and while much work has been done, much
additional work remains. Even though the
<kw role = "attrib">definitionURL</kw> is designed and intended for use
with a formal semantic encoding language such as OpenMath, it is premature
to require any one particular format.</p>
</item>
<item>
<p>
There will always be situations where some non-standard format is preferable.
This is particularly true in situations where authors are describing new
ideas.
It is anticipated that in the near term, there will be a variety
of renderer-dependent implementations of the
<kw role = "attrib">definitionURL</kw> attribute.</p>
<ulist>
<item>
<p>A translation tool might simply prompt the user with the specified definition
in situations where the proper semantics have been overridden, and in this
case, human-readable definitions will be most useful.</p>
</item>
<item>
<p>Other software may utilize OpenMath encodings.</p>
</item>
<item>
<p>Still other software may use proprietary encodings, or look for definitions
in any of several formats.</p>
</item>
</ulist>
<p>As a consequence, authors need to be aware that there is no guarantee a generic renderer will be able to take advantage of information pointed to by the
<kw role = "attrib">definitionURL</kw> attribute. Of course, when widely-accepted standardized semantic encodings are available, the definitions pointed to can be replaced without modifying the original document. However, this is likely to be labor intensive.</p>
</item>
</ulist>
<p>There is no default value for the
<kw role = "attrib">definitionURL</kw> attribute, i.e. the semantics are defined
within the MathML fragment, and/or by the MathML default semantics.</p></def></gitem></glist></div4>
<div4>
<head>
<kw role = "attrib">encoding</kw></head>
<glist>
<gitem>
<label>annotation, annotation-xml, csymbol, semantics, all operator elements</label>
<def>
<p>indicates the encoding of the annotation, or in the case of
<kw>csymbol</kw> ,
<kw>semantics</kw> and operator elements, the syntax of the target referred to by
<kw>definitionURL</kw>. Predefined values are
<kw role = "attval">MathML-Presentation</kw>,
<kw role = "attval">MathML-Content</kw>. Other typical values:
<kw role = "attval">TeX</kw>,
<kw role = "attval">OpenMath</kw>.</p>
<p>The default value is "", i.e. unspecified.</p></def></gitem></glist></div4>
<div4>
<head>
<kw role = "attrib">nargs</kw></head>
<glist>
<gitem>
<label>declare</label>
<def>
<p>indicates number of arguments for function declarations. Pre-defined values:
<kw role = "attval">nary</kw>, or any numeric string.</p>
<p>The default value is
<kw role = "attval">1</kw>.</p></def></gitem></glist></div4>
<div4>
<head>
<kw role = "attrib">occurrence</kw></head>
<glist>
<gitem>
<label>declare</label>
<def>
<p>indicates occurrence for operator declarations. Pre-defined values:
<kw role = "attval">prefix</kw>,
<kw role = "attval">infix</kw>,
<kw role = "attval">function-model</kw>.</p>
<p>The default value is
<kw role = "attval">function-model</kw>.</p></def></gitem></glist></div4>
<div4>
<head>
<kw role = "attrib">order</kw></head>
<glist>
<gitem>
<label>list</label>
<def>
<p>indicates ordering on the list. Predefined values:
<kw role = "attval">lexicographic</kw>,
<kw role = "attval">numeric</kw>.</p>
<p>The default value is
<kw role = "attval">numeric</kw>.</p></def></gitem></glist></div4>
<div4 id = "contm_scope">
<head>
<kw role = "attrib">scope</kw></head>
<glist>
<gitem>
<label>declare</label>
<def>
<p>indicates scope of applicability of the declaration. Pre-defined values:
<kw role = "attval">local</kw>,
<kw role = "attval">global</kw> (<intref ref="interf_deprec">deprecated</intref>).
<ulist>
<item>
<p>
<kw role = "attval">local</kw> means the containing MathML element.</p></item>
<item>
<p>
<kw role = "attval">global</kw> means the containing <kw role="element">math</kw> element.</p></item>
</ulist>
</p>
<p>In MathML 2.0, a declare has been restricted to occur only at the beginning of a
<kw role="element">math</kw> element. Thus, there is no difference between
the two possible <kw role="attrib">scope</kw> values and the scope attribute may be
safely ignored.
The <kw role = "attval">global</kw> attribute value has been
<intref ref="interf_deprec">deprecated</intref> for this role
as <kw role = "attval">local</kw> better represents the concept.
Ideally, one would like to make document-wide declarations by setting the value of the
<kw role = "attrib">scope</kw> attribute to be
<kw role = "attval">global-document</kw>. However, the proper mechanism for document-wide declarations very much depends on details of the way in which XML will be embedded in HTML, future XML style sheet mechanisms, and the underlying Document Object Model.</p>
<p>Since these supporting technologies are still in flux at present, the MathML specification does not include
<kw role = "attval">global-document</kw> as a pre-defined value of the
<kw role = "attrib">scope</kw> attribute. It is anticipated, however, that this issue will be revisited in future revisions of MathML as supporting technologies stabilize. In the near term, MathML implementors that wish to simulate the effect of a document-wide declaration are encouraged to pre-process documents in order to distribute document-wide declarations to each individual
<kw role = "element">math</kw> element in the document.</p></def></gitem></glist></div4>
<div4 id = "contm_typeattrib">
<head>
<kw role = "attrib">type</kw></head>
<glist>
<gitem>
<label>cn</label>
<def>
<p>indicates type of the number. Predefined values:
<kw role = "attval">e-notation</kw>,
<kw role = "attval">integer</kw>,
<kw role = "attval">rational</kw>,
<kw role = "attval">real</kw>,
<kw role = "attval">float</kw>,
<kw role = "attval">complex-polar</kw>,
<kw role = "attval">complex-cartesian</kw>,
<kw role = "attval">constant</kw>.</p>
<p>The default value is
<kw role = "attval">real</kw>.</p>
<p>Notes. Each data type implies that the data adheres to certain formatting conventions, detailed below. If the data fails to conform to the expected format, an error is generated. Details of the individual formats are:</p>
<glist>
<gitem>
<label>real</label>
<def>
<p>A real number is presented in decimal notation. Decimal notation consists of an optional sign
(<quote>+</quote> or
<quote>-</quote>) followed by a string of digits possibly separated into an integer and a fractional part by a
<quote>decimal point</quote>. Some examples are 0.3, 1, and -31.56. If a different
<kw role = "attrib">base</kw> is specified, then the digits are interpreted as being digits computed to that base.</p>
</def></gitem>
<gitem>
<label>e-notation</label>
<def>
<p>A real number may also be presented in scientific notation. Such numbers have two parts (a mantissa and an exponent) separated by
<quote>e</quote> or <quote>E</quote>. The first part is a real number, while the second part is an integer exponent indicating a power of the base.
For example, 12.3e5 represents 12.3 times 10<sup>5</sup></p></def></gitem>
<gitem>
<label>integer</label>
<def>
<p>An integer is represented by an optional sign followed by a string of 1 or more
<quote>digits</quote>. What a
<quote>digit</quote> is depends on the
<kw role = "attrib">base</kw> attribute. If
<kw role = "attrib">base</kw> is present, it specifies the base for the digit encoding, and it specifies it base 10. Thus
<kw role = "attrib">base</kw>='16' specifies a hex encoding. When
<kw role = "attrib">base</kw> > 10, letters are added in alphabetical order as digits. The legitimate values for
<kw role = "attrib">base</kw> are therefore between 2 and 36.</p></def></gitem>
<gitem>
<label>rational</label>
<def>
<p>A rational number is two integers separated by
<kw role = "emptytag">sep</kw>. If
<kw role = "attrib">base</kw> is present, it specifies the base used for the digit encoding of both integers.</p></def></gitem>
<gitem>
<label>complex-cartesian</label>
<def>
<p>A complex number is of the form two real point numbers separated by
<kw role = "emptytag">sep</kw>.</p></def></gitem>
<gitem>
<label>complex-polar</label>
<def>
<p>A complex number is specified in the form of a magnitude and an angle (in radians). The raw data is in the form of two real numbers separated by
<kw role = "emptytag">sep</kw>.</p></def></gitem>
<gitem>
<label>constant</label>
<def>
<p>The
<kw role = "attval">constant</kw> type is used to denote named constants. For example, an instance of
<code><![CDATA[<cn type="constant">π</cn>]]></code>should be interpreted as having the semantics of the mathematical constant Pi. The data for a constant
<kw role = "element">cn</kw> tag may be one of the following common constants:
<table border = "1">
<tbody>
<tr>
<td>Symbol</td>
<td>Value</td></tr>
<tr>
<td>
<kw role = "entity">pi</kw></td>
<td>The usual
<kw role = "entity">pi</kw> of trigonometry: approximately 3.141592653...</td></tr>
<tr>
<td>
<kw role = "entity">ExponentialE</kw> (or
<kw role = "entity">ee</kw>)</td>
<td>The base for natural logarithms: approximately 2.718281828 ...</td></tr>
<tr>
<td>
<kw role = "entity">ImaginaryI</kw> (or
<kw role = "entity">ii</kw>)</td>
<td>Square root of -1</td></tr>
<tr>
<td>
<kw role = "entity">gamma</kw></td>
<td>Euler's constant: approximately 0.5772156649...</td></tr>
<tr>
<td>
<kw role = "entity">infin</kw> (or
<kw role = "entity">infty</kw>)</td>
<td>Infinity. Proper interpretation varies with context</td></tr>
<tr>
<td>
<kw role = "entity">true</kw></td>
<td>the logical constant
<kw>true</kw></td></tr>
<tr>
<td>
<kw role = "entity">false</kw></td>
<td>the logical constant
<kw>false</kw></td></tr>
<tr>
<td>
<kw role = "entity">NotANumber</kw> (or
<kw role = "entity">NaN</kw>)</td>
<td>represents the result of an ill-defined floating point division</td></tr></tbody></table></p></def></gitem></glist></def></gitem>
<gitem>
<label>ci</label>
<def>
<p>indicates type of the identifier. Predefined values:
<kw role = "attval">integer</kw>,
<kw role = "attval">rational</kw>,
<kw role = "attval">real</kw>,
<kw role = "attval">float</kw>,
<kw role = "attval">complex</kw>,
<kw role = "attval">complex-polar</kw>,
<kw role = "attval">complex-cartesian</kw>,
<kw role = "attval">constant</kw>, or the name of any content element. The meanings of the attribute values shared with
<kw role="element">cn</kw> are the same as those listed for the <kw role = "element">cn</kw> element.
The attribute value <kw role = "attval">complex</kw> is intended for use when an identifier
represents a complex number but the particular representation (such as polar or cartesian) is
either not known or is irrelevant.</p>
<p>The default value is "", i.e. unspecified.</p></def></gitem>
<gitem>
<label>declare</label>
<def>
<p>indicates type of the identifier being declared. Predefined values: any content element name.</p>
<p>The default value is
<kw role = "element">ci</kw> , i.e. a generic identifier</p></def></gitem>
<gitem>
<label>set</label>
<def>
<p>indicates type of the set. Predefined values:
<kw role = "attval">normal</kw>,
<kw role = "attval">multiset</kw>.
<kw role = "attval">multiset</kw> indicates that repetitions are allowed.</p>
<p>The default value is
<kw role = "attval">normal</kw>.</p></def></gitem>
<gitem>
<label>tendsto</label>
<def>
<p>is used to capture the notion of one quantity approaching another. It occurs as a
container so that it can more easily be used in the construction of a limit expression.
Predefined values:
<kw role = "attval">above</kw>,
<kw role = "attval">below</kw>,
<kw role = "attval">two-sided</kw>.</p>
<p>The default value is
<kw role = "attval">above</kw>.</p></def></gitem></glist></div4></div3>
<kw role = "attrib">type</kw> attribute, in addition to conveying semantic information, can be interpreted to provide rendering information. For example in
<eg role = "mathml"><![CDATA[
<ci type="vector">V</ci>
]]></eg>a renderer could display a bold
<mi>V</mi> for the vector.</p></div4>
<div4 id = "contm_genatt">
<head>General Attributes</head>
<p>All content elements support the following general attributes that can be used to modify the rendering of the markup.
<ulist>
<item>
<p>
<kw role = "attrib">class</kw></p></item>
<item>
<p>
<kw role = "attrib">style</kw></p></item>
<item>
<p>
<kw role = "attrib">id</kw></p></item>
<item>
<p>
<kw role = "attrib">other</kw></p></item></ulist></p>
<p>The
<kw role = "attval">class</kw>,
<kw role = "attval">style</kw> and
<kw role = "attval">id</kw> attributes are intended for compatibility with Cascading Style Sheets (CSS), as described in
<specref ref = "fund_globatt"/>.</p>
<p>Content or semantic tagging goes along with the (frequently implicit) premise that, if you know the semantics, you can always work out a presentation form. When an author's main goal is to mark up re-usable, evaluatable mathematical expressions, the exact rendering of the expression is probably not critical, provided that it is easily understandable. However, when an author's goal is more along the lines of providing enough additional semantic information to make a document more accessible by facilitating better visual rendering, voice rendering, or specialized processing, controlling the exact notation used becomes more of an issue.</p>
<p>MathML elements accept an attribute
<kw role = "attrib">other</kw> (see
<specref ref = "interf_unspecified"/>), which can be used to specify things not specifically documented in MathML. On content tags, this attribute can be used by an author to express a
<emph>preference</emph> between equivalent forms for a particular content element construct, where the selection of the presentation has nothing to do with the semantics. Examples might be
<ulist>
<item>
<p>inline or displayed equations</p></item>
<item>
<p>script-style fractions</p></item>
<item>
<p>use of
<mi>x</mi> with a dot for a derivative over d
<mi>x</mi>/d
<mi>t</mi></p></item></ulist></p>
<p>Thus, if a particular renderer recognized a display attribute to select between script-style and display-style fractions, an author might write
<eg role = "mathml"><![CDATA[
<apply other='display="scriptstyle"'>
<divide/>
<mn> 1 </mn>
<mi> x </mi>
</apply>
]]></eg>to indicate that the rendering 1/
<mi>x</mi> is preferred.</p>
<p>The information provided in the
<kw role = "attrib">other</kw> attribute is intended for use by specific renderers or processors, and therefore, the permitted values are determined by the renderer being used. It is legal for a renderer to ignore this information. This might be intentional, as in the case of a publisher imposing a house style, or simply because the renderer does not understand them, or is unable to carry them out.</p></div4></div3></div2>
<div2 id = "contm_elem">
<head>The Content Markup Elements</head>
<p>This section provides detailed descriptions of the MathML content tags. They are grouped in categories that broadly reflect the area of mathematics from which they come, and also the grouping in the MathML DTD. There is no linguistic difference in MathML between operators and functions. Their separation here and in the DTD is for reasons of historical usage.</p>
<p>When working with the content elements, it can be useful to keep in mind the following.
<ulist>
<item>
<p>The role of the content elements is analogous to data entry in a mathematical system. The information that is provided is there to facilitate the successful parsing of an expression as the intended mathematical object by a receiving application.</p></item>
<item>
<p>MathML content elements do not by themselves
<quote>perform</quote> any mathematical evaluations or operations. They do not
<quote>evaluate</quote> in a browser and any
<quote>action</quote> that is ultimately taken on those objects is determined entirely by the receiving mathematical application. For example, editing programs and applications geared to computation for the lower grades would typically leave 3 + 4 as is, whereas computational systems targeting a more advanced audience might evaluate this as 7. Similarly, some computational systems might evaluate sin(0) to 0, whereas others would leave it unevaluated. Yet other computational systems might be unable to deal with pure symbolic expressions like sin(<mi>x</mi>) and may even regard them as data entry errors. None of this has any bearing on the correctness of the original MathML representation. Where evaluation is mentioned at all in the descriptions below, it is merely to help clarify the meaning of the underlying operation.</p></item>
<item>
<p>Apart from the instances where there is an explicit interaction with presentation tagging, there is no required rendering (visual or aural) – only a suggested default. As such, the presentations that are included in this section are merely to help communicate to the reader the intended mathematical meaning by association with the same expression written in a more traditional notation.</p></item></ulist></p>
<p>The <kw role="element">cn</kw> element is used to specify actual
numerical constants. The content model must provide sufficient information
that a number may be entered as data into a computational system. By
default, it represents a signed real number in base 10. Thus, the content
normally consists of <kw>PCDATA</kw> restricted to a sign, a string of
decimal digits and possibly a decimal point, or alternatively one of the
predefined symbolic constants such as <kw role="entity">pi</kw>.</p>
<p>The <kw role="element">cn</kw> element uses the attribute <kw
role="attrib">type</kw> to represent other types of numbers such as, for
example, integer, rational, real or complex, and uses the attribute <kw
role="attrib">base</kw> to specify the numerical base.</p>
<p>In addition to simple <kw>PCDATA</kw>, <kw role="element">cn</kw>
accepts as content <kw>PCDATA</kw> separated by the (empty) element <kw
role="element">sep</kw>. This determines the different parts needed to
construct a rational or complex-cartesian number.</p>
<p>The <kw role="element">cn</kw> element may also contain arbitrary
presentation markup in its content (see <specref ref="presm"/>) so that its
presentation can be very elaborate.</p>
<p>Alternative input notations for numbers are possible, but must be
explicitly defined by using the <kw role="attrib">definitionURL</kw> and
<kw role="attrib">encoding</kw> attributes, to refer to a written
specification of how a sequence of real numbers separated by <kw
role="emptytag">sep</kw> should be interpreted.</p>
</div5>
<div5><head>Attributes</head>
<p>All attributes are <kw>CDATA</kw>:
<glist>
<gitem>
<label>type</label>
<def>
<p>Allowed values are
<kw role = "attval">real</kw>,
<kw role = "attval">integer</kw>,
<kw role = "attval">rational</kw>,
<kw role = "attval">complex-cartesian</kw>,
<kw role = "attval">complex-polar</kw>,
<kw role = "attval">constant</kw></p></def></gitem>
<gitem>
<label>base</label>
<def>
<p>Number (<kw>CDATA</kw> for XML DTD) between 2 and 36.</p></def></gitem>
<gitem>
<label>definitionURL</label>
<def>
<p>URL or URI pointing to an alternative definition.</p></def></gitem>
<gitem>
<label>encoding</label>
<def>
<p>Syntax of the alternative definition.</p></def></gitem></glist></p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<cn type="real"> 12345.7 </cn>
<cn type="integer"> 12345 </cn>
<cn type="integer" base="16"> AB3 </cn>
<cn type="rational"> 12342 <sep/> 2342342 </cn>
<cn type="complex-cartesian"> 12.3 <sep/> 5 </cn>
<cn type="complex-polar"> 2 <sep/> 3.1415 </cn>
<cn type="constant"> π </cn>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<p>By default, a contiguous block of
<kw>PCDATA</kw> contained in a
<kw role = "element">cn</kw> element should render as if it were wrapped in an
<kw role = "element">mn</kw> presentation element.
</p>
<p> If an application supports bidirectional text rendering, then the
rendering within a <kw role = "element">cn</kw> element follows the Unicode
bidirectional rendering rules just as if it were wrapped in an
<kw role = "element">mn</kw> presentation element.</p>
<p>Similarly, presentation markup contained in a
<kw role = "element">cn</kw> element should render as it normally would. A mixture of
<kw>PCDATA</kw> and presentation markup should render as if it were wrapped in an
<kw role = "element">mrow</kw> element, with contiguous blocks of
<kw>PCDATA</kw> wrapped in
<kw role = "element">mn</kw> elements.</p>
<p>However, not all mathematical systems that encounter content based tagging do visual or aural rendering. The receiving applications are free to make use of a number in the manner in which they normally handle numerical data. Some systems might simplify the rational number 12342/2342342 to 6171/1171171 while pure floating point based systems might approximate this as 0.5269085385e-2. All numbers might be re-expressed in base 10. The role of MathML is simply to record enough information about the mathematical object and its structure so that it may be properly parsed.</p>
<p>The following renderings of the above MathML expressions are included both to help clarify the meaning of the corresponding MathML encoding and as suggestions for authors of rendering applications. In each case, no mathematical evaluation is intended or implied.
<ulist>
<item>
<p>12345.7</p></item>
<item>
<p>12345</p></item>
<item>
<p>AB3<sub>16</sub></p></item>
<item>
<p>12342 / 2342342</p></item>
<item>
<p>12.3 + 5 i</p></item>
<item>
<p>Polar( 2 , 3.1415 )</p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4003.gif" alt = "\pi"/></p></item></ulist></p>
</div5></div4>
<div4 id = "contm_ci">
<head>Identifier (<kw role = "element">ci</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">ci</kw> element is used to name an identifier in a MathML expression (for example a variable). Such names are used to identify mathematical objects. By default they are assumed to represent complex scalars. The
<kw role = "element">ci</kw> element may contain arbitrary presentation markup in its content (see
<specref ref = "presm"/>) so that its presentation as a symbol can be very elaborate.</p>
<p>The
<kw role = "element">ci</kw> element uses the
<kw role = "attrib">type</kw> attribute to specify the type of object that it represents. Valid types include
<kw role = "attval">integer</kw>,
<kw role = "attval">rational</kw>,
<kw role = "attval">real</kw>,
<kw role = "attval">float</kw>,
<kw role = "attval">complex</kw>,
<kw role = "attval">complex-polar</kw>,
<kw role = "attval">complex-cartesian</kw>,
<kw role = "attval">constant</kw>, and more generally, any of the names of the MathML container elements (e.g.
<kw role = "element">vector</kw>) or their type values. The
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes can be used to extend the definition of
<kw role = "element">ci</kw> to include other types. For example, a more advanced use might require a
<kw role = "attval">vector(complex)</kw>.</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<ci> x </ci>
]]></eg>
<eg role = "mathml"><![CDATA[
<ci type="vector"> V </ci>
]]></eg>
<eg role = "mathml"><![CDATA[
<ci>
<msub>
<mi>x</mi>
<mi>a</mi>
</msub>
</ci>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<p>If the content of a
<kw role = "element">ci</kw> element is tagged using presentation tags, that presentation is used. If no such tagging is supplied then the
<kw>PCDATA</kw> content would typically be rendered as if it were the content of an
<kw role = "element">mi</kw> element.
</p>
<p> If an application supports bidirectional text rendering, then the
rendering within a <kw role = "element">ci</kw> element follows the Unicode
bidirectional rendering rules just as if it were wrapped in an
<kw role = "element">mi</kw> presentation element.</p>
<p>
A renderer may wish to make use of the value of the type attribute to improve on this. For example, a symbol of type
<kw role = "element">vector</kw> might be rendered using a bold face. Typical renderings of the above symbols are:
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4004.gif" alt = "x"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4005.gif" alt = "V"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4006.gif" alt = "x_i"/></p></item></ulist></p></div5></div4>
<div4 id = "contm_csymbol">
<head>Externally defined symbol (<kw role = "element">csymbol</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">csymbol</kw> element allows a writer to create an element in MathML whose semantics are externally defined (i.e. not in the core MathML content). The element can then be used in a MathML expression as for example an operator or constant. Attributes are used to give the syntax and location of the external definition of the symbol semantics.</p>
<p>Use of
<kw role = "element">csymbol</kw> for referencing external semantics can be contrasted with use of the
<kw role = "element">semantics</kw> to attach additional information in-line (ie. within the MathML fragment) to a MathML construct. See
<specref ref = "contm_synsem"/>.</p></div5>
<div5>
<head>Attributes</head>
<p>All attributes are
<kw>CDATA</kw>:
<glist>
<gitem>
<label>definitionURL</label>
<def>
<p>Pointer to external definition of the semantics of the symbol. MathML does not specify a particular syntax in which this definition should be written.</p></def></gitem>
<gitem>
<label>encoding</label>
<def>
<p>Gives the syntax of the definition pointed to by definitionURL. An application can then test the value of this attribute to determine whether it is able to process the target of the
<kw role = "attrib">definitionURL</kw>. This syntax might be text, or a formal syntax such as OpenMath.</p></def></gitem></glist></p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<!-- reference to OpenMath formal syntax definition of Bessel function -->
<kw role = "element">csymbol</kw> element should render as if it were wrapped in an
<kw role = "element">mo</kw> presentation element.</p>
<p> If an application supports bidirectional text rendering, then the
rendering within a <kw role = "element">csymbol</kw> element follows the Unicode
bidirectional rendering rules just as if it were wrapped in an
<kw role = "element">mo</kw> presentation element.</p>
<p>Similarly, presentation markup contained in a
<kw role = "element">csymbol</kw> element should render as it normally would. A mixture of
<kw>PCDATA</kw> and presentation markup should render as if it were contained wrapped in an
<kw role = "element">mrow</kw> element, with contiguous blocks of
<kw>PCDATA</kw> wrapped in
<kw role = "element">mo</kw> elements. The examples above would render by default as
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4007.gif" alt = "J_0(y)"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4008.gif" alt = "k"/></p></item></ulist></p>
<p>As
<kw role = "element">csymbol</kw> is used to support reference to externally defined semantics, it is a MathML error to have embedded content MathML elements within the
<kw role = "element">csymbol</kw> element.</p></div5></div4></div3>
<div3>
<head>Basic Content Elements</head>
<div4 id = "contm_apply">
<head>Apply (<kw role = "element">apply</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">apply</kw> element allows a function or operator to be applied to its arguments. Nearly all expression construction in MathML content markup is carried out by applying operators or functions to arguments. The first child of
<kw role = "element">apply</kw> is the operator to be applied, with the other child elements as arguments or qualifiers.</p>
<p>The
<kw role = "element">apply</kw> element is conceptually necessary in order to distinguish between a function or operator, and an instance of its use. The expression constructed by applying a function to 0 or more arguments is always an element from the codomain of the function.</p>
<p>Proper usage depends on the operator that is being applied. For example, the
<kw role = "element">plus</kw> operator may have zero or more arguments, while the
<kw role = "element">minus</kw> operator requires one or two arguments to be properly formed.</p>
<p>If the object being applied as a function is not already one of the elements known to be a function (such as
<kw role = "element">fn</kw>,
<kw role = "element">sin</kw> or
<kw role = "element">plus</kw>) then it is treated as if it were the content of an
<kw role = "element">fn</kw> element.</p>
<p>Some operators such as
<kw role = "element">diff</kw> and
<kw role = "element">int</kw> make use of
<quote>named</quote> arguments. These special arguments are elements that appear as children of the
<kw role = "element">apply</kw> element and identify
<quote>parameters</quote> such as the variable of differentiation or the domain of integration. These elements are discussed further in
<specref ref = "contm_opwithqual"/>.</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<apply>
<factorial/>
<cn>3</cn>
</apply>
]]></eg>
<eg role = "mathml"><![CDATA[
<apply>
<plus/>
<cn>3</cn>
<cn>4</cn>
</apply>
]]></eg>
<eg role = "mathml"><![CDATA[
<apply>
<sin/>
<ci>x</ci>
</apply>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<p>A mathematical system that has been passed an
<kw role = "element">apply</kw> element is free to do with it whatever it normally does with such mathematical data. It may be that no rendering is involved (e.g. a syntax validator), or that the
<quote>function application</quote> is evaluated and that only the result is rendered (e.g. sin(0)
<graphic role = "inline" source = "image/f4009.gif" alt = "\rightarrow"/> 0).</p>
<p>When an unevaluated
<quote>function application</quote> is rendered there are a wide variety of appropriate renderings. The choice often depends on the function or operator being applied. Applications of basic operations such as
<kw role = "element">plus</kw> are generally presented using an infix notation while applications of
<kw role = "element">sin</kw> would use a more traditional functional notation such as sin(<mi>x</mi>). Consult the default rendering for the operator being applied.</p>
<p>Applications of user-defined functions (see
<kw role = "element">csymbol</kw>,
<kw role = "element">fn</kw>) that are not evaluated by the receiving or rendering application would typically render using a traditional functional notation unless an alternative presentation is specified using the
<kw role = "element">semantics</kw> tag.</p></div5></div4>
<div4 id = "contm_reln">
<head>Relation (<kw role = "element">reln</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">reln</kw> element was used in MathML 1.0 to construct an equation or relation. Relations were constructed in a manner exactly analogous to the use of
<kw role = "element">apply</kw>. This usage is <intref ref="interf_deprec">deprecated</intref> in MathML 2.0 in favor of the more generally usable
<kw role = "element">apply</kw>.</p>
<p>The first child of
<kw role = "element">reln</kw> is the relational operator to be applied, with the other child elements acting as arguments. See
<specref ref = "contm_relation"/> for further details.</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<reln>
<eq/>
<ci> a </ci>
<ci> b </ci>
</reln>
]]></eg>
<eg role = "mathml"><![CDATA[
<reln>
<lt/>
<ci> a </ci>
<ci> b </ci>
</reln>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4010.gif" alt = "a = b"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4011.gif" alt = "a < b"/></p></item></ulist></div5></div4>
<div4 id = "contm_fn">
<head>Function (<kw role = "element">fn</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">fn</kw> element makes explicit the fact that a more general (possibly constructed) MathML object is being used in the same manner as if it were a pre-defined function such as
<kw role = "element">sin</kw> or
<kw role = "element">plus</kw>.</p>
<p>
<kw role = "element">fn</kw> has exactly one child element, used to give the name (or presentation form) of the function. When
<kw role = "element">fn</kw> is used as the first child of an apply, the number of following arguments is determined by the contents of the
<kw role = "element">fn</kw>. </p>
<p>In MathML 1.0,
<kw role = "element">fn</kw> was also the primary mechanism used to extend the collection of
<quote>known</quote> mathematical functions. This usage is now <intref
ref="interf_deprec">deprecated</intref> in favor of the more generally applicable
<kw role = "element">csymbol</kw> element. (New functions may also be introduced by using
<kw role = "element">declare</kw> in conjunction with a
<kw role = "element">lambda</kw> expression.)</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<fn><ci> L </ci> </fn>
]]></eg>
<eg role = "mathml"><![CDATA[
<apply>
<fn>
<apply>
<plus/>
<ci> f </ci>
<ci> g </ci>
</apply>
</fn>
<ci>z</ci>
</apply>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<p>An
<kw role = "element">fn</kw> object is rendered in the same way as its content. A rendering application may add additional adornments such as parentheses to clarify the meaning.
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4012.gif" alt = "L"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4013.gif" alt = "(f+g)z"/></p></item></ulist></p></div5></div4>
<div4 id = "contm_interval">
<head>Interval (<kw role = "element">interval</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">interval</kw> element is used to represent simple mathematical intervals of the real number line. It takes an attribute
<kw role = "attrib">closure</kw>, which can take on any of the values
<kw role = "attval">open</kw>,
<kw role = "attval">closed</kw>,
<kw role = "attval">open-closed</kw>, or
<kw role = "attval">closed-open</kw>, with a default value of
<kw role = "attval">closed</kw>.</p>
<p>More general domains are constructed by using the
<kw role = "element">condition</kw> and
<kw role = "element">bvar</kw> elements to bind free variables to constraints.</p>
<p>The
<kw role = "element">interval</kw> element expects
<emph>either</emph> two child elements that evaluate to real numbers
<emph>or</emph> one child element that is a
<kw role = "element">condition</kw> defining the
<kw role = "element">interval</kw>.</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<interval>
<ci> a </ci>
<ci> b </ci>
</interval>
]]></eg>
<eg role = "mathml"><![CDATA[
<interval closure="open-closed">
<ci> a </ci>
<ci> b </ci>
</interval>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4014.gif" alt = "[a, b]"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4015.gif" alt = "(a, b]"/></p></item></ulist></div5></div4>
<div4 id = "contm_inverse">
<head>Inverse (<kw role = "element">inverse</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">inverse</kw> element is applied to a function in order to construct a generic expression for the functional inverse of that function. (See also the discussion of
<kw role = "element">inverse</kw> in
<specref ref = "contm_inverseconstruct"/>). As with other MathML functions,
<kw role = "element">inverse</kw> may either be applied to arguments, or it may appear alone, in which case it represents an abstract inversion operator acting on other functions.</p>
<p>A typical use of the
<kw role = "element">inverse</kw> element is in an HTML document discussing a number of alternative definitions for a particular function so that there is a need to write and define
<mi>f</mi><sup>(-1)</sup>(x). To associate a particular definition with
<mi>f</mi><sup>(-1)</sup>, use the
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes.</p></div5>
<p>The <kw role="element">condition</kw> element is used to place a
condition on one or more free variables or identifiers. The conditions may
be specified in terms of relations that are to be satisfied by the
variables, including general relationships such as set membership.</p>
<p>It is used to define general sets and lists in situations where the
elements cannot be explicitly enumerated. Condition contains either a
single <kw role="element">apply</kw> or <kw
role="element">reln</kw> element; the <kw role="element">apply</kw> element
is used to construct compound conditions. For example, it is used below to
describe the set of all <mi>x</mi> such that <mi>x</mi> < 5. See the
discussion on sets in <specref ref="contm_sets"/>. See <specref
ref="contm_conditions"/> for further details.</p>
</div5>
<div5><head>Examples</head>
<eg role="mathml-fragment"><![CDATA[
<condition>
<apply><in/><ci> x </ci><ci type="set"> R </ci></apply>
</condition>
]]></eg>
<eg role = "mathml-fragment"><![CDATA[
<condition>
<apply>
<and/>
<apply><gt/><ci> x </ci><cn> 0 </cn></apply>
<apply><lt/><ci> x </ci><cn> 1 </cn></apply>
</apply>
</condition>
]]></eg>
<eg role = "mathml"><![CDATA[
<apply>
<max/>
<bvar><ci> x </ci></bvar>
<condition>
<apply> <and/>
<apply><gt/><ci> x </ci><cn> 0 </cn></apply>
<apply><lt/><ci> x </ci><cn> 1 </cn></apply>
</apply>
</condition>
<apply>
<minus/>
<ci> x </ci>
<apply>
<sin/>
<ci> x </ci>
</apply>
</apply>
</apply>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4016.gif" alt = "x \in \mathbb{R}"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4017.gif" alt = "x > 0 \land x < 1"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/f4018.gif" alt = "\max_{x}\{\,x-\sin x\mid 0<x<1\,\}"/></p></item></ulist></div5></div4>
<div4 id = "contm_declare">
<head>Declare (<kw role = "element">declare</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">declare</kw> construct has two primary roles. The first is to change or set the default attribute values for a specific mathematical object. The second is to establish an association between a
<quote>name</quote> and an object. Once a declaration is in effect, the
<quote>name</quote> object acquires the new attribute settings, and (if the second object is present) all the properties of the associated object.</p>
<p>The various attributes of the
<kw role = "element">declare</kw> element assign properties to the object being declared or determine where the declaration is in effect.</p>
<p>The scope of a declaration is <quote>local</quote> to the surrounding container element.
The <kw role = "attrib">scope</kw> attribute can only be assigned to
<kw role = "attval">local</kw>, but is intended to support future extensions.
As discussed in
<specref ref = "contm_scope"/>, MathML contains no provision for making document-wide declarations at present, though it is anticipated that this capability will be added in future revisions of MathML, when supporting technologies become available.</p>
<p><kw role = "element">declare</kw> takes one or two children. The first child, which
is mandatory, is the object affected by the declaration.
This is usually a <kw role = "element">ci</kw> element
providing the identifier that is being declared as in:
<eg role = "mathml"><![CDATA[
<declare type="vector"> <ci> V </ci> </declare>
]]></eg>The second child, which is optional, is a constructor initializing the variable:
<eg role = "mathml"><![CDATA[
<declare type="vector">
<ci> V </ci>
<vector>
<cn> 1 </cn><cn> 2 </cn><cn> 3 </cn>
</vector>
</declare>
]]></eg></p>
<p>The constructor type and the type of the element declared must agree. For example, if the type attribute of the declaration is
<kw role = "element">fn</kw>, the second child (constructor) must be an element equivalent to an
<kw role = "element">fn</kw> element. (This would include actual
<kw role = "element">fn</kw> elements,
<kw role = "element">lambda</kw> elements and any of the defined functions in the basic set of content tags.) If no type is specified in the declaration then the type attribute of the declared name is set to the type of the constructor (second child) of the declaration. The type attribute of the declaration can be especially useful in the special case of the second element being a semantic tag.</p></div5>
<div5>
<head>Attributes</head>
<p>All attributes are
<kw>CDATA</kw>:
<glist>
<gitem>
<label>
<kw role = "attrib">type</kw></label>
<def>
<p>defines the MathML element type of the identifier declared.</p></def></gitem>
<gitem>
<label>
<kw role = "attrib">scope</kw></label>
<def>
<p>defines the scope of application of the declaration.</p></def></gitem>
<gitem>
<label>
<kw role = "attrib">nargs</kw></label>
<def>
<p>number of arguments for function declarations.</p></def></gitem>
<gitem>
<label>
<kw role = "attrib">occurrence</kw></label>
<def>
<p>describes operator usage as
<kw role = "attval">prefix</kw>,
<kw role = "attval">infix</kw> or
<kw role = "attval">function-model</kw> indications.</p></def></gitem>
<gitem>
<label>
<kw role = "attrib">definitionURL</kw></label>
<def>
<p>URI pointing to detailed semantics of the function.</p></def></gitem>
<gitem>
<label>
<kw role = "attrib">encoding</kw></label>
<def>
<p>syntax of the detailed semantics of the function.</p></def></gitem></glist></p></div5>
<div5>
<head>Examples</head>
<p>The declaration
<eg role = "mathml"><![CDATA[
<declare type="fn" nargs="2">
<ci> f </ci>
<apply>
<plus/>
<ci> F </ci><ci> G </ci>
</apply>
</declare>
]]></eg>
declares <mi>f</mi> to be a two-variable function with the property that
<mi>J</mi> with a one-variable function defined so that
<mi>J</mi>(<mi>y</mi>) = ln
<mi>y</mi>. (Note that because of the type attribute of the
<kw role = "element">declare</kw> element, the second argument must be something of function type
, namely a known function like
<kw role = "element">sin</kw>, or a
<kw role = "element">lambda</kw> construct.)</p>
<p>The
<kw role = "attrib">type</kw> attribute on the declaration is only necessary if the type cannot be inferred from the type of the second argument.</p>
<p>Even when a declaration is in effect it is still possible to override attributes values selectively as in
<code><![CDATA[ <ci type="set"> S
</ci>]]></code>. This capability is needed in order to write statements of the form
<quote>Let
<mi>s</mi> be a member of
<mi>S</mi></quote>.</p></div5>
<div5>
<head>Default Rendering</head>
<p>Since the
<kw role = "element">declare</kw> construct is not directly rendered, most declarations are likely to be invisible to a reader. However, declarations can produce quite different effects in an application which evaluates or manipulates MathML content. While the declaration
<eg role = "mathml"><![CDATA[
<declare>
<ci> v </ci>
<vector>
<cn> 1 </cn>
<cn> 2 </cn>
<cn> 3 </cn>
</vector>
</declare>
]]></eg>
is active the symbol <mi>v</mi> acquires all the properties of the vector,
and even its dimension and components have meaningful values. This may
affect how <mi>v</mi> is rendered by some applications, as well as how it
<p>The <kw role="element">quotient</kw> element is the operator used for
division modulo a particular base. When the <kw
role="element">quotient</kw> operator is applied to integer arguments
<mi>a</mi> and <mi>b</mi>, the result is the <quote>quotient of
<mi>a</mi> divided by <mi>b</mi></quote>. That is, <kw
role="element">quotient</kw> returns the unique integer <mi>q</mi> such
that <mi>a</mi> = <mi>q</mi> <mi>b</mi> + <mi>r</mi>. (In common usage,
<mi>q</mi> is called the quotient and <mi>r</mi> is the remainder.)</p>
<p>The <kw role="element">quotient</kw> element takes the attribute <kw
role="attrib">definitionURL</kw> and <kw
role="attrib">encoding</kw> attributes, which can be used to override the
default semantics.</p>
<p>The <kw role="element">quotient</kw> element is a <emph>binary
arithmetic operator</emph> (see <specref ref="contm_funopqual"/>).</p>
</div5>
<div5><head>Example</head>
<eg role="mathml"><![CDATA[
<apply>
<quotient/>
<ci> a </ci>
<ci> b </ci>
</apply>
]]></eg>
<p>Various mathematical applications will use this data in different ways. Editing applications might choose an image such as shown below, while a computationally based application would evaluate it to 2 when
<mi>a</mi>=13 and
<mi>b</mi>=5.</p></div5>
<div5>
<head>Default Rendering</head>
<p>There is no commonly used notation for this concept. Some possible renderings are
<p>The <kw role="element">divide</kw> element is the division operator.</p>
<p>The <kw role="element">divide</kw> element takes the <kw
role="attrib">definitionURL</kw> and <kw
role="attrib">encoding</kw> attributes, which can be used to override the
default semantics.</p>
<p>The <kw role="element">divide</kw> element is a
<emph>binary arithmetic operator</emph> (see
<specref ref = "contm_funopqual"/>).</p></div5>
<div5>
<head>Example</head>
<eg role = "mathml"><![CDATA[
<apply>
<divide/>
<ci> a </ci>
<ci> b </ci>
</apply>
]]></eg>
<p>As a MathML expression, this does not evaluate. However, on receiving such an expression, some applications may attempt to evaluate and simplify the value. For example, when
<mi>a</mi>=5 and
<mi>b</mi>=2 some mathematical applications may evaluate this to 2.5 while others will treat is as a rational number.</p></div5>
<div5>
<head>Default Rendering</head>
<p>
<graphic role = "inline" source = "image/f4028.gif" alt = "a/b"/></p></div5></div4>
<div4 id = "contm_maxmin">
<head>Maximum and minimum (<kw role = "element">max</kw>,
<kw role = "element">min</kw>)</head>
<div5>
<head>Discussion</head>
<p>The elements
<kw role = "element">max</kw> and
<kw role = "element">min</kw> are used to compare the values of their arguments. They return the maximum and minimum of these values respectively.</p>
<p>The
<kw role = "element">max</kw> and
<kw role = "element">min</kw> elements take the
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes that can be used to override the default semantics.</p>
<p>The
<kw role = "element">max</kw> and
<kw role = "element">min</kw> elements are
<emph>n-ary arithmetic operators</emph> (see
<specref ref = "contm_funopqual"/>).</p></div5>
<div5>
<head>Examples</head>
<p>When the objects are to be compared explicitly they are listed as arguments to the function as in:
<eg role = "mathml"><![CDATA[
<apply>
<max/>
<ci> a </ci>
<ci> b </ci>
</apply>
]]></eg>The elements to be compared may also be described using bound variables with a
<kw role = "element">condition</kw> element and an expression to be maximized (or minimized), as in:
<eg role = "mathml"><![CDATA[
<apply>
<min/>
<bvar><ci>x</ci></bvar>
<condition>
<apply><notin/><ci> x </ci><ci type="set"> B </ci></apply>
</condition>
<apply>
<power/>
<ci> x </ci>
<cn> 2 </cn>
</apply>
</apply>
]]></eg>Note that the bound variable must be stated even if it might
be implicit in conventional notation. In MathML1.0, the bound variable
and expression to be evaluated (<mi>x</mi>) could be omitted in the
example below: this usage is <intref
ref="interf_deprec">deprecated</intref> in MathML2.0 in favor of
explicitly stating the bound variable and expression in all cases:
<p>The <kw role="element">implies</kw> element is the boolean relational operator
<quote>implies</quote>.</p>
<p>The
<kw role = "element">implies</kw> element takes the
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes, which can be used to override the default semantics.</p>
<p>The
<kw role = "element">implies</kw> element is a
<emph>binary logical operator</emph> (see
<specref ref = "contm_relation"/>).</p></div5>
<div5>
<head>Example</head>
<eg role = "mathml"><![CDATA[
<apply>
<implies/>
<ci> A </ci>
<ci> B </ci>
</apply>
]]></eg>
<p>Mathematical applications designed for the evaluation of such expressions would evaluate this to
<kw role = "attval">true</kw> when
<mi>a</mi> =
<kw role = "attval">false</kw> and
<mi>b</mi> =
<kw role = "attval">true</kw>.</p></div5>
<div5>
<head>Default Rendering</head>
<p>
<graphic role = "display" source = "image/f4043.gif" alt = "A \Rightarrow B"/></p></div5></div4>
<div4 id="contm_forall"><head>Universal quantifier (<kw role = "element">forall</kw>)</head>
<div5><head>Discussion</head>
<p>The
<kw role = "element">forall</kw> element represents the universal quantifier of logic. It must be used in conjunction with one or more bound variables, an optional
<kw role = "element">condition</kw> element, and an assertion, which should take the form of an
<kw role = "element">apply</kw> element. In MathML 1.0, the
<kw role = "element">reln</kw> element was also permitted here: this usage is now deprecated.</p>
<p>The
<kw role = "element">forall</kw> element takes the
<kw role = "attrib">definitionURL</kw> and
<kw role = "attrib">encoding</kw> attributes, which can be used to override the default semantics.</p>
<p>The
<kw role = "element">forall</kw> element is a
<emph>quantifier</emph> (see
<specref ref = "contm_opwithqual"/>).</p></div5>
<div5>
<head>Examples</head>
<p>The first example encodes a simple identity.
<eg role = "mathml"><![CDATA[
<apply>
<forall/>
<bvar><ci> x </ci></bvar>
<apply><eq/>
<apply>
<minus/><ci> x </ci><ci> x </ci>
</apply>
<cn>0</cn>
</apply>
</apply>
]]></eg></p>
<p>The next example is more involved, and makes use of an optional
<graphic role="inline" source="image/f4045.gif" alt="\forall p \in \mathbb{Q}, q \in \mathbb{Q}, p < q: p < q^2"/></p></item>
<item><p>
<graphic role="inline" source="image/f4046.gif" alt="\forall n>0, n \in \mathbb{Z}: \exists x \in \mathbb{Z}, y \in \mathbb{Z}, z \in \mathbb{Z}: x^n+y^n=z^n"/></p></item>
<kw role = "element">lowlimit</kw> element and its contents depends on the context. In the preceding example, it should be rendered as a subscript to the integral sign:
<graphic role = "display" source = "image/f4066.gif" alt = "\int_a^b f(x) \, \diffd x"/></p>
<p>Consult the descriptions of individual operators that make use of the
<kw role="element">lowlimit</kw> construct for default renderings.</p>
<p>The <kw role="element">laplacian</kw> element is the vector calculus
laplacian operator.</p>
<p>The <kw role="element">laplacian</kw> element takes the attributes <kw
role="attrib">encoding</kw> and <kw>definitionURL</kw> that can be used to override the
default semantics.</p>
<p>The <kw role="element">laplacian</kw> element is an <emph>unary calculus
operator</emph> (see <specref ref="contm_funopqual"/>).</p>
</div5>
<div5><head>Example</head>
<eg role="mathml"><![CDATA[
<apply>
<eq/>
<apply><laplacian/>
<ci> f </ci>
</apply>
<apply>
<divergence/>
<apply><grad/>
<ci> f </ci>
</apply>
</apply>
</apply>
]]></eg>
<p>Where for example
<mi>f</mi> is a scalar function of three real variables.</p></div5>
<div5>
<head>Default Rendering</head>
<graphic source = "image/f4073.gif" alt = "\nabla^2 f"/></div5></div4></div3>
<div3 id = "contm_sets">
<head>Theory of Sets</head>
<div4 id = "contm_set">
<head>Set (<kw role = "element">set</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">set</kw> element is the container element that constructs a set of elements. The elements of a set can be defined either by explicitly listing the elements, or by using the
<kw role = "element">bvar</kw> and
<kw role = "element">condition</kw> elements.</p>
<p>The
<kw role = "element">set</kw> element is a
<emph>constructor element</emph> (see
<specref ref = "contm_constructor"/>).</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<set>
<ci> b </ci>
<ci> a </ci>
<ci> c </ci>
</set>
]]></eg>
<p>This constructs the set {b, a, c}</p>
<eg role = "mathml"><![CDATA[
<set>
<bvar><ci> x </ci></bvar>
<condition>
<apply><and/>
<apply><lt/>
<ci> x </ci>
<cn> 5 </cn>
</apply>
<apply><in/>
<ci> x </ci>
<naturalnumbers/>
</apply>
</apply>
</condition>
<ci> x </ci>
</set>
]]></eg>
<p>This constructs the set of all natural numbers less than 5, ie. the set {0, 1, 2, 3, 4}</p>
</div5>
<div5>
<head>Default Rendering</head>
<ulist>
<item>
<p>
<graphic role = "inline" source = "image/f4074.gif" alt = "\{ a, b, c \}"/></p></item>
<item>
<p>
<graphic role = "inline" source = "image/new-setexample.gif" alt = "\{ x \mid x < 5 \land x \in \mathbb{N} \}"/></p></item></ulist></div5></div4>
<div4 id = "contm_list">
<head>List (<kw role = "element">list</kw>)</head>
<div5>
<head>Discussion</head>
<p>The
<kw role = "element">list</kw> element is the container element that constructs a list of elements. Elements can be defined either by explicitly listing the elements, or by using the
<kw role = "element">bvar</kw> and
<kw role = "element">condition</kw> elements.</p>
<p>Lists differ from sets in that there is an explicit order to the elements. Two orders are supported: lexicographic and numeric. The kind of ordering that should be used is specified by the
<kw role = "attrib">order</kw> attribute.</p>
<p>The
<kw role = "element">list</kw> element is a
<emph>constructor element</emph> (see
<specref ref = "contm_constructor"/>).</p></div5>
<div5>
<head>Examples</head>
<eg role = "mathml"><![CDATA[
<list>
<ci> a </ci>
<ci> b </ci>
<ci> c </ci>
</list>
]]></eg>
<eg role = "mathml"><![CDATA[
<list order="numeric">
<bvar><ci> x </ci></bvar>
<condition>
<apply><lt/>
<ci> x </ci>
<cn> 5 </cn>
</apply>
</condition>
<ci> x </ci>
</list>
]]></eg></div5>
<div5>
<head>Default Rendering</head>
<ulist>
<item><p>
<graphic role="inline" source="image/f4076.gif" alt="[ a, b, c ]"/></p></item>
<item><p>
<graphic role="inline" source="image/f4077.gif" alt="[ x \mid x < 5 ]"/></p></item>
<kw role = "attrib">encoding</kw> attributes, which can be used to override the default semantics.</p>
<p>
<kw role = "element">selector</kw> is classified as an n-ary linear algebra operator even though it can take only one, two, or three arguments.</p></div5>
<div5>
<head>Example</head>
<eg role = "mathml"><![CDATA[
<apply>
<selector/>
<ci type="matrix"> A </ci>
<cn> 3 </cn>
<cn> 2 </cn>
</apply>
]]></eg>
</div5>
<div5><head>Default Rendering</head>
<p>The <kw role="element">selector</kw> construct renders in a manner that indicates
which sub-element of the parent object is selected. For vectors and matrices this is
normally done by specifying the parent object together with subscripted indices.
