4 Content Markup

4.2.1.1 Constructing Mathematical Objects

Content expression trees are built up from basic mathematical objects. At the lowest level, leaf nodes are encapsulated in non-empty elements that define their type. Numbers and symbols are marked by the token elements cn and ci . 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 container 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.

The containers such as <cn>12345</cn> , <ci>x</ci> and <csymbol definitionURL="mySymbol.htm" encoding="text">S</csymbol> represent mathematical numbers , identifiers and externally defined symbols. Below, we will look at operator elements such as plus or sin , which provide access to the basic mathematical operations and functions applicable to those objects. Additional containers such as set for sets, and matrix for matrices are provided for representing a variety of common compound objects.

For example, the number 12345 is encoded as

<cn>12345</cn>

The attributes and PCDATA 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 base attribute to 8 as in

<cn base="8">12345</cn>

while the complex number 3 + 4i can be encoded as

<cn type="complex-cartesian">3<sep/>4</cn>

Such information makes it possible for another application to easily parse this into the correct number.

As another example, the scalar symbol v is encoded as

<ci>v</ci>

By default, ci elements represent elements from a commutative field (see C Content Element Definitions ). If a vector is intended then this fact can be encoded as

<ci type="vector">v</ci>

This invokes default semantics associated with the vector element, namely an arbitrary element of a finite-dimensional vector space.

By using the ci and csymbol 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 ci or csymbol element were actually the presentation element mi (see 3.2.3 Identifier (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 3 Presentation Markup ) in the body of the ci or csymbol element.

The default rendering of a simple cn -tagged object is the same as for the presentation element mn with some provision for overriding the presentation of the PCDATA by providing explicit mn tags. This is described in detail in 4.4 The Content Markup Elements .

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.

4.2.1.2 Constructing General Expressions

The notion of constructing a general expression tree is essentially that of applying an operator to sub-objects. For example, the sum a + b can be thought of as an application of the addition operator to two arguments a and b. 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 plus element, setting the definitionURL and encoding attributes as in

<plus definitionURL="www.example.com/VectorCalculus.htm"
      encoding="text"/>

can communicate that the intended operation is vector-based.

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 apply construct corresponding to function application. We will consider the apply construct in the next section.

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 csymbol element, which is discussed below.

4.2.1.3 The apply construct

The most fundamental way of building up a mathematical expression in MathML content markup is the apply construct. An apply 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 "logical brackets" without changing its meaning.

For example, (x + y) might be encoded as

<apply>
  <plus/>
  <ci> x </ci>
  <ci> y </ci>
</apply>

The opening and closing tags of apply specify exactly the scope of any operator or function. The most typical way of using apply is simple and recursive. Symbolically, the content model can be described as:

<apply> 
op
 

                     a
 

                     b
 </apply>

where the operands a and b are containers or other content-based elements themselves, and op is an operator or function. Note that since apply is a container, this allows apply constructs to be nested to arbitrary depth.

An apply may in principle have any number of operands:

<apply> op a b [c...] <apply>

For example, (x + y + z) can be encoded as

<apply>
  <plus/>
  <ci> x </ci>
  <ci> y </ci>
  <ci> z </ci>
</apply>

Mathematical expressions involving a mixture of operations result in nested occurrences of apply . For example, a x + b would be encoded as

<apply>
  <plus/>
  <apply>
    <times/>
    <ci> a </ci>
    <ci> x </ci>
  </apply>
  <ci> b </ci>
</apply>

There is no need to introduce parentheses or to resort to operator precedence in order to parse the expression correctly. The apply tags provide the proper grouping for the re-use of the expressions within other constructs. Any expression enclosed by an apply element is viewed as a single coherent object.

An expression such as (F + G)(x) might be a product, as in

<apply>
  <times/>
  <apply>
    <plus/>
    <ci> F </ci>
    <ci> G </ci>
  </apply>
  <ci> x </ci>
</apply>

or it might indicate the application of the function F + G to the argument x. This is indicated by constructing the sum

<apply>
  <plus/>
  <ci> F </ci>
  <ci> G </ci>
</apply>

and applying it to the argument x as in

<apply>
  <apply>
    <plus/>
    <ci> F </ci>
    <ci> G </ci>
    </apply>
  <ci> x </ci>
</apply>

Both the function and the arguments may be simple identifiers or more complicated expressions.

In MathML 1.0 , another construction closely related to the use of the apply element with operators and arguments was the reln element. The reln 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 x < y was given in MathML 1.0 by:

<reln>
  <lt/>
  <ci> x </ci>
  <ci> y </ci>
</reln>

In MathML 2.0, the apply construct is used with all operators, including logical operators. The expression above becomes

<apply>
  <lt/>
  <ci> x </ci>
  <ci> y </ci>
</apply>

in MathML 2.0. The use of reln with relational operators is supported for reasons of backwards compatibility, but deprecated. Authors creating new content are encouraged to use apply in all cases.

4.2.1.4 Explicitly defined functions and operators

The most common operations and functions such as plus and sin have been predefined explicitly as empty elements (see 4.4 The Content Markup Elements ). They have type and definitionURL 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.

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.

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 csymbol element is used as a container to construct a new symbol in much the same way that ci is used to construct an identifier. (Note that "symbol" 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 csymbol should refer to some mathematically defined concept with an external definition referenced via the definitionURL attribute, whereas ci is used for identifiers that are essentially "local" to the MathML expression and do not use any external definition mechanism. The target of the definitionURL attribute on the csymbol element may encode the definition in any format; the particular encoding in use is given by the encoding attribute.

To use csymbol to describe a completely new function, we write for example

<csymbol definitionURL="www.example.com/VectorCalculus.htm"
         encoding="text">
  Christoffel
</csymbol>

The definitionURL attribute specifies a URI that provides a written definition for the Christoffel symbol. Suggested default definitions for the content elements of MathML appear in C Content Element Definitions in a format based on OpenMath, although there is no requirement that a particular format be used. The role of the definitionURL 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.

MathML 1.0 supported the use of the fn to encode the fact that a construct is explicitly being used as a function or operator. To record the fact that F+ G is being used semantically as if it were a function, it was encoded as:

<fn>
  <apply>
    <plus/>
    <ci>F</ci>
    <ci>G</ci>
  </apply>
</fn>

This usage, although allowed in MathML 2.0 for reasons of backwards compatibility, is now deprecated. 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 apply . If it is required to add additional information to the construct, it should be wrapped in a semantics element, for example:

<semantics definitionURL="www.example.com/vectorfuncs/plus.htm"
           encoding="Mathematica">
  <apply>
    <plus/>
    <ci>F</ci>
    <ci>G</ci>
  </apply>
</semantics>

MathML 1.0 supported the use of definitionURL with fn to refer to external definitions for user-defined functions. This usage, although allowed for reasons of backwards compatibility, is deprecated in MathML 2.0 in favor of using csymbol to define the function, and then apply to link the function to its arguments. For example:

  <apply>
    <csymbol definitionURL="http://www.example.org/function_spaces.html#my_def"
             encoding="text">
      BigK
    </csymbol>
    <ci>x</ci>
    <ci>y</ci>
  </apply>

4.2.1.5 The inverse construct

Given functions, it is natural to have functional inverses. This is handled by the inverse element.

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 F. Even at the K-through-12 level the concept of an inverse F ^-1 of many common functions F 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.

MathML adopts the view: if F is a function from a domain D to D', then the inverse G of F is a function over D' such that G(F(x)) = x for x in D. This definition does not assert that such an inverse exists for all or indeed any x in D, or that it is single-valued anywhere. Also, depending on the functions involved, additional properties such as F(G(y)) = y for y in D' may hold.

The inverse element is applied to a function whenever an inverse is required. For example, application of the inverse sine function to x, i.e. sin^-1 (x), is encoded as:

<apply>
  <apply> <inverse/> <sin/> </apply>
  <ci> x </ci>
</apply>

While arcsin is one of the predefined MathML functions, an explicit reference to sin^-1(x) might occur in a document discussing possible definitions of arcsin .

4.2.1.6 The declare construct

Consider a document discussing the vectors A = (a, b, c) and B = (d, e, f), and later including the expression V = A + B. It is important to be able to communicate the fact that wherever A and B are used they represent a particular vector. The properties of that vector may determine aspects of operators such as plus .

The simple fact that A is a vector can be communicated by using the markup

<ci type="vector">A</ci>

but this still does not communicate, for example, which vector is involved or its dimensions.

The declare 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.

Declarations must occur at the beginning of a math element. The scope of a declaration is the entire math element in which the declaration is made. The scope attribute of a declare may be included but has no effect since the two possible values of "local" or "global" now have the same meaning. The "global" attribute value is still allowed for backwards compatibility with MathML 1.0., but is deprecated in MathML 2.0.

The uses of the declare 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 declare ) play the same semantic role as would the paired object.

For example, the declaration

<declare>
  <ci> A </ci>
  <vector>
    <ci> a </ci>
    <ci> b </ci>
    <ci> c </ci>
  </vector>
</declare>

specifies that A stands for the particular vector (a, b, c) so that subsequent uses of A as in V = A + B can take this into account. When declare is used in this way, the actual encoding

<apply>
  <eq/>
  <ci> V </ci>
  <apply>
    <plus/>
    <ci> A </ci>
    <ci> B </ci>
  </apply>
</apply>

remains unchanged but the expression can be interpreted properly as vector addition.

There is no requirement to declare an expression to stand for a specific object. For example, the declaration

<declare type="vector">
  <ci> A </ci>
</declare>

specifies that A is a vector without indicating the number of components or the values of specific components. The possible values for the type attribute include all the predefined container element names such as vector , matrix or set (see 4.3.2.9 type ).

4.2.1.7 The lambda construct

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:

Let f be the function taking x to x ² + 2

There are various notations for this concept in mathematical literature, such as (x, F(x)) = F or (x, [F]) =F, where x is a free variable in F.

This concept is implemented in MathML with the lambda element. A lambda construct with n internal variables is encoded by a lambda element with n+1 children. All but the last child must be bvar elements containing the identifiers of the internal variables. The last child is an expression defining the function. This is typically an apply , but can also be any container element.

The following constructs (x, sin(x+1)):

<lambda>
  <bvar><ci> x </ci></bvar>
  <apply>
    <sin/>
    <apply>
      <plus/>
      <ci> x </ci>
      <cn> 1 </cn>
    </apply>
  </apply>
</lambda>

To use declare and lambda to construct the function f for which f( x) = x ² + x + 3 use:

<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>

The following markup declares and constructs the function J such that J(x, y) is the integral from x to y of t ⁴ with respect to t.

<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>

The function J can then in turn be applied to an argument pair.

4.2.1.8 The use of qualifier elements and the condition construct

The last example of the preceding section illustrates the use of qualifier elements lowlimit , uplimit , and bvar used in conjunction with the int 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.

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 apply 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 4.2.3.2 Operators taking Qualifiers .

The qualifier element bvar is also used in another important MathML construction. The condition 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 { x | x < 1}:

<set>
  <bvar><ci> x </ci></bvar>
  <condition>
    <apply>
      <lt/>
      <ci> x </ci>
      <cn> 1 </cn>
    </apply>
  </condition>
</set>

4.2.1.9 Rendering of Content elements

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 4.4 The Content Markup Elements , and several mechanisms (including 4.3.3.2 General Attributes ) are provided for associating a particular rendering with an object.

4.2.2.1 Tokens

Token elements are typically the leaves of the MathML expression tree. Token elements are used to indicate mathematical identifiers, numbers and symbols.

It is also possible for the canonically empty operator elements such as exp , sin and cos to be leaves in an expression tree. The usage of operator elements is described in 4.2.3 Functions, Operators and Qualifiers .

cn

The cn element is the MathML token element used to represent numbers. The supported types of numbers include: "real", "integer", "rational", "complex-cartesian", and "complex-polar", with "real" being the default type. An attribute base (with default value "10") is used to help specify how the content is to be parsed. The content itself is essentially PCDATA , separated by sep when two parts are needed in order to fully describe a number. For example, the real number 3 is constructed by <cn type="real"> 3 </cn> , while the rational number 3/4 is constructed as <cn type="rational"> 3<sep/>4 </cn> . The detailed structure and specifications are provided in 4.4.1.1 Number (cn) .

ci

The ci element, or "content identifier" is used to construct a variable, or an identifier. A type attribute indicates the type of object the symbol represents. Typically, ci represents a real scalar, but no default is specified. The content is either PCDATA or a general presentation construct (see 3.1.6 Summary of Presentation Elements ). For example,

<ci> <msub> <mi>c</mi> <mn>1</mn> </msub> </ci>

$c_1$

encodes an atomic symbol that displays visually as c ₁ which, for purposes of content, is treated as a single symbol representing a real number. The detailed structure and specifications are provided in 4.4.1.2 Identifier (ci) .

csymbol

The csymbol element, or "content symbol" is used to construct a symbol whose semantics are not part of the core content elements provided by MathML, but defined externally. csymbol 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 definitionURL attribute to point to a particular meaning, and the encoding attribute to give the syntax of this definition. The content of a csymbol is either PCDATA or a general presentation construct (see 3.1.6 Summary of Presentation Elements ). For example,

<csymbol definitionURL="www.example.com/ContDiffFuncs.htm" encoding="text"> <msup> <mi>C</mi> <mn>2</mn> </msup> </csymbol>

$C^2$

encodes an atomic symbol that displays visually as C ² 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 4.4.1.3 Externally defined symbol (csymbol) .

4.2.2.2 Constructors

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.

interval

The interval element is described in detail in 4.4.2.4 Interval (interval) . It denotes an interval on the real line with the values represented by its children as end points. The closure attribute is used to qualify the type of interval being represented. For example,

<interval closure="open-closed"> <ci> a </ci> <ci> b </ci> </interval>

$\left(a , b\right]$

represents the open-closed interval often written (a, b].

set and list

The set and list elements are described in detail in 4.4.6.1 Set (set) and 4.4.6.2 List (list) . Typically, the child elements of a possibly empty list element are the actual components of an ordered list . For example, an ordered list of the three symbols a, b, and c is encoded as

<list> <ci> a </ci> <ci> b </ci> <ci> c </ci> </list>

$\left[a, b, c\right]$

Alternatively, bvar and condition elements can be used to define lists where membership depends on satisfying certain conditions.

An order 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.

Sets are structured much the same as lists except that there is no implied ordering and the type of set may be "normal" or "multiset" with "multiset" indicating that repetitions are allowed.

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.

matrix and matrixrow

The matrix element is used to represent mathematical matrices. It is described in detail in 4.4.10.2 Matrix (matrix) . It has zero or more child elements, all of which are matrixrow 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

<matrix> <matrixrow> <cn> 1 </cn> <cn> 2 </cn> </matrixrow> <matrixrow> <cn> 3 </cn> <cn> 4 </cn> </matrixrow> </matrix>

$\begin{pmatrix}1 & 2\\ 3 & 4\end{pmatrix}$

The matrixrow elements must always be contained inside of a matrix, and all rows in a given matrix must have the same number of elements.

Note that the behavior of the matrix and matrixrow elements is substantially different from the mtable and mtr presentation elements.

vector

The vector element is described in detail in 4.4.10.1 Vector (vector) . It constructs vectors from an n-dimensional vector space so that its n child elements typically represent real or complex valued scalars as in the three-element vector

<vector> <apply> <plus/> <ci> x </ci> <ci> y </ci> </apply> <cn> 3 </cn> <cn> 7 </cn> </vector>

$\left(\begin{array}{c}x+y\\ 3\\ 7\end{array}\right)$

apply

The apply element is described in detail in 4.4.2.1 Apply (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 a + b as in

<apply> <plus/> <ci> a </ci> <ci> b </ci> </apply>

$a+b$

through to using the sine function to construct sin(a) as in

<apply> <sin/> <ci> a </ci> </apply>

$\sin a$

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 4.2.3 Functions, Operators and Qualifiers .

reln

The reln element is described in detail in 4.4.2.2 Relation (reln) . It was used in MathML 1.0 to construct an expression such as a = b, as in

<reln><eq/> <ci> a </ci> <ci> b </ci> </reln>

$a=b$

indicating an intended comparison between two mathematical values.

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 apply . The use of reln with logical operators is supported for reasons of backwards compatibility, but deprecated in favor of apply .

fn

The fn 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 deprecated, as the use of an expression as a function or operator is clear from its position as the first child of an apply . fn is discussed in detail in 4.4.2.3 Function (fn) .

lambda

The lambda element is used to construct a user-defined function from an expression and one or more free variables. The lambda construct with n internal variables takes n+1 children. The first (second, up to n) is a bvar containing the identifiers of the internal variables. The last is an expression defining the function. This is typically an apply , but can also be any container element. The following constructs (x, sin x)

<lambda> <bvar><ci> x </ci></bvar> <apply> <sin/> <ci> x </ci> </apply> </lambda>

$x\mapsto \sin x$

The following constructs the constant function (x, 3)

<lambda> <bvar><ci> x </ci></bvar> <cn> 3 </cn> </lambda>

$x\mapsto 3$

piecewise, piece, otherwise

The piecewise , piece , otherwise elements are used to support "piecewise" declarations of the form " H(x) = 0 if x less than 0, H(x) = 1 otherwise".

<piecewise> <piece> <cn> 0 </cn> <apply><lt/><ci> x </ci> <cn> 0 </cn></apply> </piece> <otherwise> <ci> x </ci> </otherwise> </piecewise>

$\begin{cases}0 & \text{if $x< 0$}\\ x & \text{otherwise}\end{cases}$

The piecewise elements are discussed in detail in 4.4.2.16 Piecewise declaration (piecewise, piece, otherwise) .

4.2.2.3 Special Constructs

The declare construct is described in detail in 4.4.2.8 Declare (declare) . It is special in that its entire purpose is to modify the semantics of other objects. It is not rendered visually or aurally.

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 V 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.

The declaration

<declare type="vector"><ci>V</ci></declare>

resets the default type attribute of <ci>V</ci> to "vector" for all affected occurrences of <ci>V</ci> . This avoids having to write <ci type="vector">V</ci> every time you use the symbol.

More generally, declare can be used to associate expressions with specific content. For example, the declaration

<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>

associates the symbol F with a new function defined by the lambda construct. Within the scope where the declaration is in effect, the expression

<apply>
  <ci>F</ci>
  <ci> U </ci>
</apply>

stands for the integral of U from 0 to a.

The declare element can also be used to change the definition of a function or operator. For example, if the URL http://.../MathML:noncommutplus described a non-commutative plus operation encoded in Maple syntax, then the declaration

<declare definitionURL="http://.../MathML:noncommutplus"
         encoding="Maple">
  <plus/>
</declare>

would indicate that all affected uses of plus are to be interpreted as having that definition of plus .

4.2.3.1 Predefined functions and operators

MathML functions can be used in two ways. They can be used as the operator within an apply element, in which case they refer to a function evaluated at a specific value. For example,

<apply>
  <sin/>
  <cn>5</cn>
</apply>

denotes a real number, namely sin(5).

MathML functions can also be used as arguments to other operators, for example

<apply>
  <plus/><sin/><cos/>
</apply>

denotes a function, namely the result of adding the sine and cosine functions in some function space. (The default semantic definition of plus is such that it infers what kind of operation is intended from the type of its arguments.)

The number of child elements in the apply is defined by the element in the first (i.e. operator) position.

Unary operators are followed by exactly one other child element within the apply .

Binary operators are followed by exactly two child elements.

N-ary operators are followed by two or more child elements.

The one exception to these rules is that declare elements may be inserted in any position except the first. declare elements are not counted when satisfying the child element count for an apply containing a unary or binary operator element.

Integral, sum, product and differential operators are discussed below in 4.2.3.2 Operators taking Qualifiers .

4.2.3.2 Operators taking Qualifiers

The table below contains the qualifiers and the operators defined as taking qualifiers in MathML.

Operators taking qualifiers are canonically empty functions that differ from ordinary empty functions only in that they support the use of special qualifier 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 apply . 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 bvar , lowlimit , uplimit , interval , condition , domainofapplication , degree , momentabout , logbase . A typical example is:

<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>

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:

<fn>
  <apply>
    <int/>
    <bvar><ci>x</ci></bvar>
    <lowlimit><cn>0</cn></lowlimit>
    <uplimit><cn>1</cn></uplimit>
  </apply>
</fn>

In addition to the defined usage in MathML, qualifier schema may be used with any user-defined symbol (e.g. using csymbol ) or construct. The meaning of such a usage is not defined by MathML; it would normally be user-defined using the definitionURL attribute.

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.

int

The int function accepts the lowlimit , uplimit , bvar , interval , condition and domainofapplication schemata. If both lowlimit and uplimit schemata are present, they denote the limits of a definite integral. The domain of integration may alternatively be specified using interval , condition or domainofapplication . The bvar schema signifies the variable of integration. When used with int , each qualifier schema is expected to contain a single child schema; otherwise an error is generated.

diff

The diff function accepts the bvar schema. The bvar schema specifies with respect to which variable the derivative is being taken. The bvar may itself contain a degree 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 f with respect to x is:

<apply> <diff/> <bvar> <ci> x </ci> <degree> <cn> 2 </cn> </degree> </bvar> <apply><fn><ci>f</ci></fn> <ci> x </ci> </apply> </apply>

$\frac{d^{2}f(x)}{dx^2}$

partialdiff

The partialdiff operator accepts zero or more bvar schemata, and an optional degree qualifier schema. The bvar schema specify, in order, the variables with respect to which the derivative is being taken. Each bvar element may contain a degree schema which is used to specify the order of the derivative being taken with respect to that variable. The optional degree schema qualifier associated with the partialdiff element itself (that is, appearing as a child of the enclosing apply element rather than of one of the bvar qualifiers) is used to represent the total degree of the differentiation. Each degree schema used with partialdiff is expected to contain a single child schema. For example,

<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>

$\frac{\partial^{4}f}{\partial x^2\partial y\partial x}$

denotes the mixed partial derivative ( d⁴ / d² x dy dx ) f.

sum, product

The sum and product functions accept the bvar , lowlimit , uplimit , interval , condition and domainofapplication schemata. If both lowlimit and uplimit schemata are present, they denote the limits of the sum or product. The limits may alternatively be specified using the interval , condition or domainofapplication schema. The bvar schema signifies the internal variable in the sum or product. A typical example might be:

<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>

$\sum_{i=0}^{100} x^i$

When used with sum or product , each qualifier schema is expected to contain a single child schema; otherwise an error is generated.

limit

The limit function accepts zero or more bvar schemata, and optional condition and lowlimit schemata. A condition may be used to place constraints on the bvar . The bvar schema denotes the variable with respect to which the limit is being taken. The lowlimit schema denotes the limit point. When used with limit , the bvar and lowlimit schemata are expected to contain a single child schema; otherwise an error is generated.

log

The log function accepts only the logbase schema. If present, the logbase 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 log , the logbase schema is expected to contain a single child schema; otherwise an error is generated.

moment

The moment function accepts the degree and momentabout schema. If present, the degree schema denotes the order of the moment. Otherwise, the moment is assumed to be the first order moment. When used with moment , the degree schema is expected to contain a single child schema; otherwise an error is generated. If present, the momentabout schema denotes the point about which the moment is taken. Otherwise, the moment is assumed to be the moment about zero.

min, max

The min and max functions accept a bvar schema in cases where the maximum or minimum is being taken over a set of values specified by a condition schema together with an expression to be evaluated on that set. In MathML1.0, the bvar element was optional when using a condition ; if a condition element containing a single variable was given by itself following a min or max 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 deprecated in MathML 2.0 in favor of explicitly stating the bound variable(s) and the expression to be maximized or minimized in all cases.

The min and max 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 4.4.3.4 Maximum and minimum (max, min) .

forall, exists

The universal and existential quantifier operators forall and exists are used in conjunction with one or more bvar 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 "there exists x< 9" would be represented as:

<apply> <exists/> <bvar><ci> x </ci></bvar> <apply><lt/> <ci> x </ci><cn> 9 </cn> </apply> </apply>

$\exists x\colon x< 9$

The second usage is for representing implications. Hypotheses are given by a condition element following the bound variables. For example the statement "for all x < 9, x < 10" would be represented as:

<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>

$\forall x, x< 9\colon x< 10$

Note that in both usages one or more bvar qualifiers are mandatory.

4.2.5.1 Examples

The following encodes "there exists x such that x ⁵ < 3".

<apply>
  <exists/>
  <bvar><ci> x </ci></bvar>
  <condition>
    <apply><lt/>
      <apply>
        <power/>
        <ci>x</ci>
        <cn>5</cn>
      </apply>
      <cn>3</cn>
    </apply>
  </condition>
</apply>

The next example encodes "for all x in N there exist prime numbers p, q such that p+q = 2x".

<apply>
  <forall/>
  <bvar><ci>x</ci></bvar>
  <condition>
    <apply><in/>
          <ci>x</ci>
          <csymbol encoding="OpenMath" 
            definitionURL="http://www.openmath.org/cd/setname1.ocd">
            N
          </csymbol>
        </apply>
  </condition>

  <apply><exists/>
     <bvar><ci>p</ci></bvar>
     <bvar><ci>q</ci></bvar>
     <condition>
       <apply><and/>
          <apply><in/><ci>p</ci>
            <csymbol encoding="OpenMath" 
              definitionURL="http://www.openmath.org/cd/setname1.ocd">
             P
            </csymbol>
          </apply>
          <apply><in/><ci>q</ci>
            <csymbol encoding="OpenMath" 
              definitionURL="http://www.openmath.org/cd/setname1.ocd">
              P
            </csymbol>
          </apply>
          <apply><eq/>
              <apply><plus/><ci>p</ci><ci>q</ci></apply>
              <apply><times/><cn>2</cn><ci>x</ci></apply>
          </apply>
        </apply>
      </condition>
  </apply>
</apply>

A third example shows the use of quantifiers with condition . The following markup encodes "there exists x < 3 such that x ² = 4".

<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>

4.3.2.1 base

cn

indicates numerical base of the number. Predefined values: any numeric string.

The default value is "10"

4.3.2.2 closure

interval

indicates closure of the interval. Predefined values: "open", "closed", "open-closed", "closed-open".

The default value is "closed"

4.3.2.3 definitionURL

csymbol, declare, semantics, any operator element

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.

At present, MathML does not specify the format in which external semantic definitions should be given. In particular, there is no requirement that the target of the URI be loadable and parsable. An external definition could, for example, define the semantics in human-readable form.

Ideally, in most situations the definition pointed to by the definitionURL attribute would be some standard, machine-readable format. However, there are reasons why MathML does not require such a format.

• 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 definitionURL is designed and intended for use with a formal semantic encoding language such as OpenMath, it is premature to require any one particular format.

• 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 definitionURL attribute.

  • 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.

  • Other software may utilize OpenMath encodings.

  • Still other software may use proprietary encodings, or look for definitions in any of several formats.

  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 definitionURL 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.

There is no default value for the definitionURL attribute, i.e. the semantics are defined within the MathML fragment, and/or by the MathML default semantics.

4.3.2.4 encoding

annotation, annotation-xml, csymbol, semantics, all operator elements

indicates the encoding of the annotation, or in the case of csymbol , semantics and operator elements, the syntax of the target referred to by definitionURL . Predefined values are "MathML-Presentation", "MathML-Content". Other typical values: "TeX", "OpenMath".

The default value is "", i.e. unspecified.

4.3.2.5 nargs

declare

indicates number of arguments for function declarations. Pre-defined values: "nary", or any numeric string.

The default value is "1".

4.3.2.6 occurrence

declare

indicates occurrence for operator declarations. Pre-defined values: "prefix", "infix", "function-model".

The default value is "function-model".

4.3.2.7 order

list

indicates ordering on the list. Predefined values: "lexicographic", "numeric".

The default value is "numeric".

4.3.2.8 scope

declare

indicates scope of applicability of the declaration. Pre-defined values: "local", "global" (deprecated).

• "local" means the containing MathML element.

• "global" means the containing math element.

In MathML 2.0, a declare has been restricted to occur only at the beginning of a math element. Thus, there is no difference between the two possible scope values and the scope attribute may be safely ignored. The "global" attribute value has been deprecated for this role as "local" better represents the concept. Ideally, one would like to make document-wide declarations by setting the value of the scope attribute to be "global-document". 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.

Since these supporting technologies are still in flux at present, the MathML specification does not include "global-document" as a pre-defined value of the scope 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 math element in the document.

4.3.2.9 type

cn

indicates type of the number. Predefined values: "e-notation", "integer", "rational", "real", , "complex-polar", "complex-cartesian", "constant".

The default value is "real".

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:

real

A real number is presented in decimal notation. Decimal notation consists of an optional sign ("+" or "-") followed by a string of digits possibly separated into an integer and a fractional part by a "decimal point". Some examples are 0.3, 1, and -31.56. If a different base is specified, then the digits are interpreted as being digits computed to that base.

e-notation

A real number may also be presented in scientific notation. Such numbers have two parts (a mantissa and an exponent) separated by sep . The first part is a real number, while the second part is an integer exponent indicating a power of the base. For example, 12.3sep 5 represents 12.3 times 10⁵. The default presentation of this example is 12.3e5.

integer

An integer is represented by an optional sign followed by a string of 1 or more "digits". What a "digit" is depends on the base attribute. If base is present, it specifies the base for the digit encoding, and it specifies it base 10. Thus base ='16' specifies a hex encoding. When base > 10, letters are added in alphabetical order as digits. The legitimate values for base are therefore between 2 and 36.

rational

A rational number is two integers separated by sep . If base is present, it specifies the base used for the digit encoding of both integers.

complex-cartesian

A complex number is of the form two real point numbers separated by sep .

complex-polar

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 sep .

constant

The "constant" type is used to denote named constants. For example, an instance of <cn type="constant">&pi;</cn> should be interpreted as having the semantics of the mathematical constant Pi. The data for a constant cn tag may be one of the following common constants:

Symbol	Value
π	The usual π of trigonometry: approximately 3.141592653...
ⅇ (or ⅇ)	The base for natural logarithms: approximately 2.718281828 ...
ⅈ (or ⅈ)	Square root of -1
γ	Euler's constant: approximately 0.5772156649...
∞ (or &infty;)	Infinity. Proper interpretation varies with context
&true;	the logical constant true
&false;	the logical constant false
&NotANumber; (or &NaN;)	represents the result of an ill-defined floating point division

ci

indicates type of the identifier. Predefined values: "integer", "rational", "real", , "complex", "complex-polar", "complex-cartesian", "constant", or the name of any content element. The meanings of the attribute values shared with cn are the same as those listed for the cn element. The attribute value "complex" 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.

The default value is "", i.e. unspecified.

declare

indicates type of the identifier being declared. Predefined values: any content element name.

The default value is ci , i.e. a generic identifier

set

indicates type of the set. Predefined values: "normal", "multiset". "multiset" indicates that repetitions are allowed.

The default value is "normal".

tendsto

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: "above", "below", "two-sided".

The default value is "above".

4.3.3.1 type

The type attribute, in addition to conveying semantic information, can be interpreted to provide rendering information. For example in

<ci type="vector">V</ci>

a renderer could display a bold V for the vector.

4.3.3.2 General Attributes

All content elements support the following general attributes that can be used to modify the rendering of the markup.

• class

• style

• id

• other

The "class", "style" and "id" attributes are intended for compatibility with Cascading Style Sheets (CSS), as described in 2.4.5 Attributes Shared by all MathML Elements .

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.

MathML elements accept an attribute other (see 7.2.3 Attributes for unspecified data ), 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 preference 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

• inline or displayed equations

• script-style fractions

• use of x with a dot for a derivative over d x/d t

Thus, if a particular renderer recognized a display attribute to select between script-style and display-style fractions, an author might write

<apply other='display="scriptstyle"'>
  <divide/>
  <cn> 1 </cn>
  <ci> x </ci>
</apply>

to indicate that the rendering 1/ x is preferred.

The information provided in the other 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.

4.4.1.1 Number (cn )

<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">  &pi; </cn>

4.4.1.2 Identifier (ci )

<ci> x </ci>

<ci type="vector"> V </ci>

<ci>
  <msub>
    <mi>x</mi>
    <mi>a</mi>
  </msub>
</ci>

4.4.1.3 Externally defined symbol (csymbol )

<!-- reference to OpenMath formal syntax definition of Bessel function -->
<apply>
  <csymbol encoding="OpenMath" 
           definitionURL="http://www.openmath.org/cd/BesselFunctions.ocd">
    <msub><mi>J</mi><mn>0</mn></msub>
  </csymbol>
  <ci>y</ci>
</apply>

<!-- reference to human readable text description of Boltzmann's constant -->
<csymbol encoding="text" 
         definitionURL="www.example.org/universalconstants/Boltzmann.htm">
  k
</csymbol>

4.4.2.1 Apply (apply )

<apply>
  <factorial/>
  <cn>3</cn>
</apply>

<apply>
  <plus/>
  <cn>3</cn>
  <cn>4</cn>
</apply>

<apply>
  <sin/>
  <ci>x</ci>
</apply>

4.4.2.2 Relation (reln )

<reln>
  <eq/>
  <ci> a </ci>
  <ci> b </ci>
</reln>

<reln>
  <lt/>
  <ci> a </ci>
  <ci> b </ci>
</reln>

4.4.2.3 Function (fn )

<fn><ci> L </ci> </fn>

<apply>
  <fn>
  <apply>
    <plus/>
    <ci> f </ci>
    <ci> g </ci>
  </apply>
  </fn>
  <ci>z</ci>
</apply>

4.4.2.4 Interval (interval )

<interval>
  <ci> a </ci>
  <ci> b </ci>
</interval>

<interval closure="open-closed">
  <ci> a </ci>
  <ci> b </ci>
</interval>

4.4.2.5 Inverse (inverse )

<apply>
  <inverse/>
  <ci> f </ci>
</apply>

<apply>
  <inverse definitionURL="../MyDefinition.htm" encoding="text"/>
  <ci> f </ci>
</apply>

<apply>
  <apply><inverse/>
    <ci type="matrix"> a </ci>
  </apply>
  <ci> A </ci>
</apply>

4.4.2.6 Separator (sep )

<cn type="complex-cartesian"> 3 <sep/> 4 </cn>

4.4.2.7 Condition (condition )

<condition>
  <apply><in/><ci> x </ci><ci type="set"> R </ci></apply>
</condition>

<condition>
  <apply>
    <and/>
    <apply><gt/><ci> x </ci><cn> 0 </cn></apply>
    <apply><lt/><ci> x </ci><cn> 1 </cn></apply>
  </apply>
</condition>

<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>

4.4.2.8 Declare (declare )

<declare type="vector"> <ci> V </ci> </declare>

<declare type="vector">
  <ci> V </ci>
  <vector>
    <cn> 1 </cn><cn> 2 </cn><cn> 3 </cn>
  </vector>
</declare>

<declare type="fn" nargs="2">
  <ci> f </ci>
  <apply>
    <plus/>
    <ci> F </ci><ci> G </ci>
  </apply>
</declare>

<declare type="fn">
  <ci> J </ci>
  <lambda>
    <bvar><ci> x </ci></bvar>
    <apply><ln/>
      <ci> x </ci>
    </apply>
  </lambda>
</declare>

<declare>
  <ci> v </ci>
  <vector>
    <cn> 1 </cn>
    <cn> 2 </cn>
    <cn> 3 </cn>
  </vector>
</declare>

4.4.2.9 Lambda (lambda )

<lambda>
  <bvar><ci> x </ci></bvar>
  <apply><sin/>
    <apply>
      <plus/>
      <ci> x </ci>
      <cn> 1 </cn>
    </apply>
  </apply>
</lambda>

<lambda>
  <bvar><ci> b </ci></bvar>
  <apply>
    <int/>
    <bvar>
       <ci> x </ci>
    </bvar>
    <lowlimit>
       <ci> a </ci>
    </lowlimit>
    <uplimit>
       <ci> b </ci>
    </uplimit>
    <apply><fn><ci> f </ci></fn>
       <ci> x </ci>
    </apply>
  </apply>
</lambda>

4.4.2.10 Function composition (compose )

<apply>
  <compose/>
  <fn><ci> f </ci></fn>
  <fn><ci> g </ci></fn>
</apply>

<apply>
  <compose/>
  <ci type="fn"> f </ci>
  <ci type="fn"> g </ci>
  <ci type="fn"> h </ci>
</apply>

<apply>
  <apply><compose/>
    <fn><ci> f </ci></fn>
    <fn><ci> g </ci></fn>
  </apply>
  <ci> x </ci>
</apply>

<apply>
  <fn><ci> f </ci></fn>
  <apply>
    <fn><ci> g </ci></fn>
    <ci> x </ci>
  </apply>
</apply>

4.4.2.11 Identity function (ident )

<apply>
  <eq/>
  <apply><compose/>
    <fn><ci> f </ci></fn>
    <apply><inverse/>
      <fn><ci> f </ci></fn>
    </apply>
  </apply>
  <ident/>
</apply>

4.4.2.12 Domain (domain )

<apply>
  <eq/>
  <apply><domain/>
    <fn><ci> f </ci></fn>
  </apply>
  <reals/>
</apply>

4.4.2.13 codomain (codomain )

<apply>
  <eq/>
  <apply><codomain/>
    <fn><ci> f </ci></fn>
  </apply>
  <rationals/>
</apply>

4.4.2.14 Image (image )

<apply>
  <eq/>
  <apply><image/>
    <sin/>
  </apply>
  <interval>
    <cn>-1</cn>
	<cn> 1</cn>
  </interval>
</apply>

4.4.2.15 Domain of Application (domainofapplication )

<apply>
  <int/>
  <domainofapplication>
    <ci> C </ci>
  </domainofapplication>
  <ci> f </ci>
</apply>

4.4.2.16 Piecewise declaration (piecewise , piece , otherwise )

<piecewise>
  <piece>
      <cn> 0 </cn>
      <apply><lt/><ci> x </ci> <cn> 0 </cn></apply>
  </piece>
  <otherwise>
      <ci> x </ci>
  </otherwise>
</piecewise>

<apply>
<eq/>
<apply>
  <abs/>
  <ci> x </ci>
</apply>
<piecewise>
  <piece>
      <apply><minus/><ci> x </ci></apply>
      <apply><lt/><ci> x </ci> <cn> 0 </cn></apply>
  </piece>
  <piece>
      <cn> 0 </cn>
      <apply><eq/><ci> x </ci> <cn> 0 </cn></apply>
  </piece>
  <piece>
      <ci> x </ci>
      <apply><gt/><ci> x </ci> <cn> 0 </cn></apply>
  </piece>
</piecewise>
</apply>

4.4.3.1 Quotient (quotient )

<apply>
  <quotient/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.2 Factorial (factorial )

<apply>
  <factorial/>
  <ci> n </ci>
</apply>

4.4.3.3 Division (divide )

<apply>
  <divide/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.4 Maximum and minimum (max , min )

<apply>
  <max/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

<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>

<apply>
  <max/>
  <bvar><ci>x</ci></bvar>
  <condition>
    <apply><and/>
      <apply><in/><ci>x</ci><ci type="set">B</ci></apply>
      <apply><notin/><ci>x</ci><ci type="set">C</ci></apply>
    </apply>
  </condition>
  <ci>x</ci>
</apply>

4.4.3.5 Subtraction (minus )

<apply> <minus/>
  <ci> x </ci>
  <ci> y </ci>
</apply>

4.4.3.6 Addition (plus )

<apply>
  <plus/>
  <ci> x </ci>
  <ci> y </ci>
  <ci> z </ci>
</apply>

4.4.3.7 Exponentiation (power )

<apply>
  <power/>
  <ci> x </ci>
  <cn> 3 </cn>
</apply>

4.4.3.8 Remainder (rem )

<apply>
  <rem/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.9 Multiplication (times )

<apply>
  <times/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.10 Root (root )

<apply>
  <root/>
  <degree><ci type='integer'> n </ci></degree>
  <ci> a </ci>
</apply>

4.4.3.11 Greatest common divisor (gcd )

<apply> <gcd/>
  <ci> a </ci>
  <ci> b </ci>
  <ci> c </ci>
</apply>

4.4.3.12 And (and )

<apply>
  <and/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.13 Or (or )

<apply>
  <or/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.14 Exclusive Or (xor )

<apply>
  <xor/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.3.15 Not (not )

The not operator is the boolean "not" operator.

The not element takes the attribute definitionURL and encoding attributes, which can be used to override the default semantics.

The not element is a unary logical operator (see 4.2.3 Functions, Operators and Qualifiers ).

<apply>
  <not/>
  <ci> a </ci>
</apply>

4.4.3.16 Implies (implies )

<apply>
  <implies/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.3.17 Universal quantifier (forall )

<apply>
  <forall/>
  <bvar><ci> x </ci></bvar>
  <apply><eq/>
    <apply>
      <minus/><ci> x </ci><ci> x </ci>
    </apply>
    <cn>0</cn>
  </apply>
</apply>

<apply>
  <forall/>
  <bvar><ci> p </ci></bvar>
  <bvar><ci> q </ci></bvar>
  <condition>
    <apply><and/>
      <apply><in/><ci> p </ci><rationals/></apply>
      <apply><in/><ci> q </ci><rationals/></apply>
      <apply><lt/><ci> p </ci><ci> q </ci></apply>
    </apply>
  </condition>
  <apply><lt/>
      <ci> p </ci>
      <apply>
          <power/>
        <ci> q </ci>
        <cn> 2 </cn>
      </apply>
  </apply>
</apply>

<apply>
  <forall/>
  <bvar><ci> n </ci></bvar>
  <condition>
    <apply><and/>
      <apply><gt/><ci> n </ci><cn> 0 </cn></apply>
      <apply><in/><ci> n </ci><integers/></apply>
    </apply>
  </condition>
  <apply>
    <exists/>
    <bvar><ci> x </ci></bvar>
    <bvar><ci> y </ci></bvar>
    <bvar><ci> z </ci></bvar>
    <condition>
      <apply><and/>
        <apply><in/><ci> x </ci><integers/></apply>
        <apply><in/><ci> y </ci><integers/></apply>
        <apply><in/><ci> z </ci><integers/></apply>
      </apply>
    </condition>
    <apply>
      <eq/>
      <apply>
        <plus/>
        <apply><power/><ci> x </ci><ci> n </ci></apply>
        <apply><power/><ci> y </ci><ci> n </ci></apply>
      </apply>
      <apply><power/><ci> z </ci><ci> n </ci></apply>
    </apply>
  </apply>
</apply>

4.4.3.18 Existential quantifier (exists )

<apply>
  <exists/>
  <bvar><ci> x </ci></bvar>
  <apply><eq/>
    <apply>
      <fn><ci> f </ci></fn>
      <ci> x </ci>
    </apply>
    <cn>0</cn>
  </apply>
</apply>

4.4.3.19 Absolute Value (abs )

<apply>
  <abs/>
  <ci> x </ci>
</apply>

4.4.3.20 Complex conjugate (conjugate )

<apply>
  <conjugate/>
  <apply>
    <plus/>
    <ci> x </ci>
    <apply><times/>
      <cn> &ImaginaryI; </cn>
      <ci> y </ci>
    </apply>
  </apply>
</apply>

4.4.3.21 Argument (arg )

<apply>
  <arg/>
  <apply><plus/>
    <ci> x </ci>
    <apply><times/>
      <cn> &ImaginaryI; </cn>
      <ci> y </ci>
    </apply>
  </apply>
</apply>

4.4.3.22 Real part (real )

<apply>
  <real/>
  <apply><plus/>
    <ci> x </ci>
    <apply><times/>
      <cn> &ImaginaryI; </cn>
      <ci> y </ci>
    </apply>
  </apply>
</apply>

4.4.3.23 Imaginary part (imaginary )

<apply>
  <imaginary/>
  <apply><plus/>
    <ci> x </ci>
    <apply><times/>
      <cn> &ImaginaryI; </cn>
      <ci> y </ci>
    </apply>
  </apply>
</apply>

4.4.3.24 Lowest common multiple (lcm )

<apply> <lcm/>
  <ci> a </ci>
  <ci> b </ci>
  <ci> c </ci>
</apply>

4.4.3.25 Floor (floor )

<apply> <floor/>
  <ci> a </ci>
</apply>

<apply> <forall/>
  <bvar><ci> a </ci></bvar>
  <apply><and/>
    <apply><leq/>
	  <apply><floor/>
		<ci>a</ci>
	  </apply>
	  <ci>a</ci>
	</apply>    
    <apply><lt/>
      <ci>a</ci>
	  <apply><plus/>
	    <apply><floor/>
		  <ci>a</ci>
		</apply>
		<cn>1</cn>
	  </apply>
	</apply>
  </apply>
</apply>

4.4.3.26 Ceiling (ceiling )

<apply> <ceiling/>
  <ci> a </ci>
</apply>

<apply> <forall/>
  <bvar><ci> a </ci></bvar>
  <apply><and/>
    <apply><lt/>
	  <apply><minus/>
	    <apply><ceiling/>
		  <ci>a</ci>
		</apply>
		<cn>1</cn>
	  </apply>
      <ci>a</ci>
	</apply>
    <apply><leq/>
	  <ci>a</ci>
	  <apply><ceiling/>
		<ci>a</ci>
	  </apply>
	</apply>    
  </apply>
</apply>

4.4.4.1 Equals (eq )

<apply>
  <eq/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.4.2 Not Equals (neq )

<apply>
  <neq/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.4.3 Greater than (gt )

<apply>
  <gt/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.4.4 Less Than (lt )

<apply>
  <lt/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.4.5 Greater Than or Equal (geq )

<apply>
  <geq/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.4.6 Less Than or Equal (leq )

<apply>
  <leq/>
  <ci> a </ci>
  <ci> b </ci>
</apply>

4.4.4.7 Equivalent (equivalent )

<apply>
  <equivalent/>
  <ci> a </ci>
  <apply>
    <not/>
    <apply> <not/> <ci> a </ci> </apply>
  </apply>
</apply>

4.4.4.8 Approximately (approx )

<apply>
  <approx/>
  <cn type="rational"> 22 <sep/> 7 </cn>
  <cn type="constant"> &pi; </cn>
</apply>

4.4.4.9 Factor Of (factorof )

<apply>
  <factorof/>
    <ci> a </ci>
    <ci> b </ci>
</apply>

4.4.5.1 Integral (int )

<apply>
  <int/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <lowlimit>
    <cn> 0 </cn>
  </lowlimit>
  <uplimit>
    <ci> a </ci>
  </uplimit>
  <apply>
    <ci> f </ci>
    <ci> x </ci>
  </apply>
</apply>

<apply>
  <int/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <interval>
    <ci> a </ci>
    <ci> b </ci>
  </interval>
  <apply><cos/>
    <ci> x </ci>
  </apply>
</apply>

<apply>
  <int/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <condition>
    <apply><in/>
      <ci> x </ci>
      <ci type="set"> D </ci>
    </apply>
  </condition>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.5.2 Differentiation (diff )

<apply>
  <diff/>
  <ci> f </ci>
</apply>

<apply>
  <diff/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.5.3 Partial Differentiation (partialdiff )

<apply><partialdiff/>
 <bvar><ci> x </ci><degree><ci> m </ci></degree></bvar>
 <bvar><ci> y </ci><degree><ci> n </ci></degree></bvar>
 <degree><ci> k </ci></degree>
 <apply><ci type="fn"> f </ci>
  <ci> x </ci>
  <ci> y </ci>
 </apply>
</apply>

<apply><partialdiff/>
 <bvar><ci> x </ci></bvar>
 <bvar><ci> y </ci></bvar>
 <apply><ci type="fn"> f </ci>
  <ci> x </ci>
  <ci> y </ci>
 </apply>
</apply>

<apply><partialdiff/>
<list><cn>1</cn><cn>1</cn><cn>3</cn></list>
<ci type="fn">f</ci>
</apply>

4.4.5.4 Lower limit (lowlimit )

<apply>
  <int/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <lowlimit>
    <ci> a </ci>
  </lowlimit>
  <uplimit>
    <ci> b </ci>
  </uplimit>
  <apply><ci type="fn"> f </ci>
     <ci> x </ci>
  </apply>
</apply>

4.4.5.5 Upper limit (uplimit )

<apply>
  <int/>
  <bvar>
     <ci> x </ci>
  </bvar>
  <lowlimit>
     <ci> a </ci>
  </lowlimit>
  <uplimit>
     <ci> b </ci>
  </uplimit>
  <apply><ci type="fn"> f </ci>
     <ci> x </ci>
  </apply>
</apply>

4.4.5.6 Bound variable (bvar )

<apply>
  <diff/>
  <bvar>
    <ci> x </ci>
    <degree>
      <cn> 2 </cn>
    </degree>
  </bvar>
  <apply>
    <power/>
    <ci> x </ci>
    <cn> 4 </cn>
  </apply>
</apply>

<apply>
  <int/>
  <bvar><ci> x </ci></bvar>
  <condition>
    <apply><in/><ci> x </ci><ci> D </ci></apply>
  </condition>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.5.7 Degree (degree )

<apply>
  <partialdiff/>
  <bvar>
    <ci> x </ci>
    <degree>
      <ci> n </ci>
    </degree>
  </bvar>
  <bvar>
    <ci> y </ci>
    <degree>
      <ci> m </ci>
    </degree>
  </bvar>
  <apply><sin/>
    <apply> <times/>
      <ci> x </ci>
      <ci> y </ci>
    </apply>
  </apply>
</apply>

4.4.5.8 Divergence (divergence )

<apply>
  <divergence/>
  <ci> a </ci>
</apply>

4.4.5.9 Gradient (grad )

<apply>
  <grad/>
  <ci> f</ci>
</apply>

4.4.5.10 Curl (curl )

<apply>
  <curl/>
  <ci> a </ci>
</apply>

4.4.5.11 Laplacian (laplacian )

<apply>
  <eq/>
  <apply><laplacian/>
    <ci> f </ci>
  </apply>
  <apply>
    <divergence/>
    <apply><grad/>
      <ci> f </ci>
    </apply>
  </apply>
</apply>

4.4.6.1 Set (set )

<set>
  <ci> b </ci>
  <ci> a </ci>
  <ci> c </ci>
</set>

<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>

4.4.6.2 List (list )

<list>
  <ci> a </ci>
  <ci> b </ci>
  <ci> c </ci>
</list>

<list order="numeric">
  <bvar><ci> x </ci></bvar>
  <condition>
    <apply><lt/>
      <ci> x </ci>
      <cn> 5 </cn>
    </apply>
  </condition>
  <ci> x </ci>
</list>

4.4.6.3 Union (union )

<apply>
  <union/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.6.4 Intersect (intersect )

<apply>
  <intersect/>
  <ci type="set"> A </ci>
  <ci type="set"> B </ci>
</apply>

4.4.6.5 Set inclusion (in )

<apply>
  <in/>
  <ci> a </ci>
  <ci type="set"> A </ci>
</apply>

4.4.6.6 Set exclusion (notin )

<apply>
  <notin/>
  <ci> a </ci>
  <ci> A </ci>
</apply>

4.4.6.7 Subset (subset )

<apply>
  <subset/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.6.8 Proper Subset (prsubset )

<apply>
  <prsubset/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.6.9 Not Subset (notsubset )

<apply>
  <notsubset/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.6.10 Not Proper Subset (notprsubset )

<apply>
  <notprsubset/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.6.11 Set Difference (setdiff )

<apply>
  <setdiff/>
  <ci> A </ci>
  <ci> B </ci>
</apply>

4.4.6.12 Cardinality (card )

<apply>
  <eq/>
  <apply><card/>
    <ci> A </ci>
  </apply>
  <ci> 5 </ci>
</apply>

4.4.6.13 Cartesian product (cartesianproduct )

  <apply><cartesianproduct/>
    <ci> A </ci>
    <ci> B </ci>
  </apply>

  <apply><cartesianproduct/>
    <reals/>
    <reals/>
    <reals/>
  </apply>

4.4.7.1 Sum (sum )

<apply>
  <sum/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <lowlimit>
    <ci> a </ci>
  </lowlimit>
  <uplimit>
    <ci> b </ci>
  </uplimit>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

<apply>
  <sum/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <condition>
    <apply> <in/>
      <ci> x </ci>
      <ci type="set"> B </ci>
    </apply>
  </condition>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.7.2 Product (product )

<apply>
  <product/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <lowlimit>
    <ci> a </ci>
  </lowlimit>
  <uplimit>
    <ci> b </ci>
  </uplimit>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

<apply>
  <product/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <condition>
    <apply> <in/>
      <ci> x </ci>
      <ci type="set"> B </ci>
    </apply>
  </condition>
  <apply><ci type="fn"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.7.3 Limit (limit )

<apply>
  <limit/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <lowlimit>
    <cn> 0 </cn>
  </lowlimit>
  <apply><sin/>
    <ci> x </ci>
  </apply>
</apply>

<apply>
  <limit/>
  <bvar>
    <ci> x </ci>
  </bvar>
  <condition>
    <apply>
      <tendsto type="above"/>
      <ci> x </ci>
      <ci> a </ci>
    </apply>
  </condition>
  <apply><sin/>
     <ci> x </ci>
  </apply>
</apply>

4.4.7.4 Tends To (tendsto )

<apply>
  <tendsto type="above"/>
  <apply>
    <power/>
    <ci> x </ci>
    <cn> 2 </cn>
  </apply>
  <apply>
    <power/>
    <ci> a </ci>
    <cn> 2 </cn>
  </apply>
</apply>

<apply>
  <tendsto/>
  <vector>
     <ci> x </ci>
     <ci> y </ci>
  </vector>
  <vector>
    <apply><ci type="fn"> f </ci>
      <ci> x </ci>
      <ci> y </ci>
    </apply>
    <apply><ci type="fn"> g </ci>
      <ci> x </ci>
      <ci> y </ci>
    </apply>
  </vector>
</apply>

4.4.8.1 common trigonometric functions

The names of the common trigonometric functions supported by MathML are listed below. Since their standard interpretations are widely known, they are discussed as a group.

<apply>
  <sin/>
  <ci> x </ci>
</apply>

<apply>
  <sin/>
  <apply>
    <plus/>
    <apply><cos/>
      <ci> x </ci>
    </apply>
    <apply>
      <power/>
      <ci> x </ci>
      <cn> 3 </cn>
    </apply>
  </apply>
</apply>

4.4.8.2 Exponential (exp )

<apply>
  <exp/>
  <ci> x </ci>
</apply>

4.4.8.3 Natural Logarithm (ln )