4 Content Markup

4.4.1.1.1 Discussion

The cn 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 PCDATA restricted to a sign, a string of decimal digits and possibly a decimal point, or alternatively one of the predefined symbolic constants such as π.

The cn element uses the attribute type to represent other types of numbers such as, for example, integer, rational, real or complex, and uses the attribute base to specify the numerical base.

In addition to simple PCDATA, cn accepts as content PCDATA separated by the (empty) element sep. This determines the different parts needed to construct a rational or complex-cartesian number.

The cn element may also contain arbitrary presentation markup in its content (see Chapter 3 Presentation Markup) so that its presentation can be very elaborate.

Alternative input notations for numbers are possible, but must be explicitly defined by using the definitionURL and encoding attributes, to refer to a written specification of how a sequence of real numbers separated by <sep/> should be interpreted.

4.4.1.1.2 Attributes

All attributes are CDATA:

type

Allowed values are "real", "integer", "rational", "complex-cartesian", "complex-polar", "constant"

base

Number (CDATA for XML DTD) between 2 and 36.

definitionURL

URL or URI pointing to an alternative definition.

encoding

Syntax of the alternative definition.

4.4.1.1.3 Examples

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

4.4.1.1.4 Default Rendering

By default, a contiguous block of PCDATA contained in a cn element should render as if it were wrapped in an mn presentation element.

If an application supports bidirectional text rendering, then the rendering within a cn element follows the Unicode bidirectional rendering rules just as if it were wrapped in an mn presentation element.

Similarly, presentation markup contained in a cn element should render as it normally would. A mixture of PCDATA and presentation markup should render as if it were wrapped in an mrow element, with contiguous blocks of PCDATA wrapped in mn elements.

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.

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.

• 12345.7

• 12345

• AB3₁₆

• 12342 / 2342342

• 12.3 + 5 i

• Polar( 2 , 3.1415 )

• 

4.4.1.2.1 Discussion

The ci 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 ci element may contain arbitrary presentation markup in its content (see Chapter 3 Presentation Markup) so that its presentation as a symbol can be very elaborate.

The ci element uses the type attribute to specify the basic type of object that it represents. While any CDATA string is a valid type, the predefined types include "integer", "rational", "real", , "complex", "complex-polar", "complex-cartesian", "constant", "function" and more generally, any of the names of the MathML container elements (e.g. vector) or their type values. For a more advanced treatment of types, the type attribute is inappropriate. Advanced types require significant structure of their own (for example, vector(complex)) and are probably best constructed as mathematical objects and then associated with a MathML expression through use of the semantics element. Additional information on this topic is planned. See the MathML Web site for more information.

The definitionURL attribute can be used to associate additional properties with a ci element. See the discussion of bound variables (Section 4.4.5.6 Bound variable (bvar)) for a discussion of an important instance of this. When used as an operator it may make use of qualifiers as described in Section 4.2.3.2 Operators taking Qualifiers.

4.4.1.2.2 Examples

<ci> x </ci>

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

<ci>
  <msub>
    <mi>x</mi>
    <mi>i</mi>
  </msub>
</ci>

4.4.1.2.3 Default Rendering

If the content of a ci element is tagged using presentation tags, that presentation is used. If no such tagging is supplied then the PCDATA content is rendered as if it were the content of an mi element.

If an application supports bidirectional text rendering, then the rendering within a ci element follows the Unicode bidirectional rendering rules just as if it were wrapped in an mi presentation element.

A renderer may wish to make use of the value of the type attribute to improve on this. For example, a symbol of type vector might be rendered using a bold face. Typical renderings of the above symbols are:

4.4.1.3.1 Discussion

The csymbol 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. When used as an operator it may make use of qualifiers as described in Section 4.2.3.2 Operators taking Qualifiers.

Use of csymbol for referencing external semantics can be contrasted with use of the semantics to attach additional information in-line (i.e. within the MathML fragment) to a MathML construct. See Section 4.2.6 Syntax and Semantics.

4.4.1.3.2 Attributes

All attributes are CDATA:

definitionURL

Pointer to external definition of the semantics of the symbol. MathML does not specify a particular syntax in which this definition should be written.

encoding

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 definitionURL. This syntax might be text, or a formal syntax such as OpenMath.

4.4.1.3.3 Examples

<!-- reference to OpenMath formal syntax definition of Bessel function -->
<apply>
  <csymbol encoding="OpenMath" 
    definitionURL="http://www.openmath.org/cd/hypergeo2#BesselJ">
    <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="http://www.example.org/universalconstants/Boltzmann.htm">
  k
</csymbol>

4.4.1.3.4 Default Rendering

By default, a contiguous block of PCDATA contained in a csymbol element should render as if it were wrapped in an mo presentation element.

If an application supports bidirectional text rendering, then the rendering within a csymbol element follows the Unicode bidirectional rendering rules just as if it were wrapped in an mo presentation element.

Similarly, presentation markup contained in a csymbol element should render as it normally would. A mixture of PCDATA and presentation markup should render as if it were contained wrapped in an mrow element, with contiguous blocks of PCDATA wrapped in mo elements. The examples above would render by default as

As csymbol is used to support reference to externally defined semantics, it is a MathML error to have embedded content MathML elements within the csymbol element.

4.4.2.1.1 Discussion

The apply 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 apply is the operator to be applied, with the other child elements as arguments or qualifiers.

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

Proper usage depends on the operator that is being applied. For example, the plus operator may have zero or more arguments, while the minus operator requires one or two arguments to be properly formed.

If the object being applied as a function is not already one of the elements known to be a function (such as fn (deprecated), sin or plus) then it is treated as if it were a function.

Some operators such as user defined functions defined using the declare or csymbol elements, diff and int make use of "named" arguments. These special arguments are elements that appear as children of the apply element and identify "parameters" such as the variable of differentiation or the domain of integration. These elements are discussed further in Section 4.2.3.2 Operators taking Qualifiers.

4.4.2.1.2 Examples

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

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

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

4.4.2.1.3 Default Rendering

A mathematical system that has been passed an apply 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 "function application" is evaluated and that only the result is rendered (e.g. sin(0) 0).

When an unevaluated "function application" 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 plus are generally presented using an infix notation while applications of sin would use a more traditional functional notation such as sin(x). Consult the default rendering for the operator being applied.

Applications of user-defined functions (see csymbol, fn) 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 semantics tag.

4.4.2.2.1 Discussion

The reln 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 apply. This usage is deprecated in MathML 2.0 in favor of the more generally usable apply.

The first child of reln is the relational operator to be applied, with the other child elements acting as arguments. See Section 4.2.4 Relations for further details.

4.4.2.2.2 Examples

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

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

4.4.2.2.3 Default Rendering

4.4.2.3.1 Discussion

The fn 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 sin or plus.

fn has exactly one child element, used to give the name (or presentation form) of the function. When fn is used as the first child of an apply, the number of following arguments is determined by the contents of the fn.

In MathML 1.0, fn was also the primary mechanism used to extend the collection of "known" mathematical functions. The fn element has been deprecated. To extend the collection of known mathematical functions without using the fn element, use the more generally applicable csymbol element or use a declare in conjunction with a lambda expression.

4.4.2.3.2 Examples

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

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

4.4.2.3.3 Default Rendering

An fn object is rendered in the same way as its content. A rendering application may add additional adornments such as parentheses to clarify the meaning.

4.4.2.4.1 Discussion

The interval element is used to represent simple mathematical intervals of the real number line. It takes an attribute closure, which can take on any of the values "open", "closed", "open-closed", or "closed-open", with a default value of "closed".

A single interval element occuring as the second child of an apply element and preceded by one of the pre-defined n-ary operators is interpreted as a shorthand notation for a domainofapplication. All other uses of an interval element as a child of an apply should be interpreted as ordinary function arguments unless otherwise dictated by the function definition.

More general domains should be constructed using a domainofapplication element or one of the other shortcut notations described in Section 4.2.3.2 Operators taking Qualifiers.

The interval element expects two child elements that evaluate to real numbers.

4.4.2.4.2 Examples

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

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

4.4.2.4.3 Default Rendering

4.4.2.5.1 Discussion

The inverse 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 inverse in Section 4.2.1.5 The inverse construct). As with other MathML functions, inverse may either be applied to arguments, or it may appear alone, in which case it represents an abstract inversion operator acting on other functions.

A typical use of the inverse 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 f^(-1)(x). To associate a particular definition with f^(-1), use the definitionURL and encoding attributes.

4.4.2.5.2 Examples

<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.5.3 Default Rendering

The default rendering for a functional inverse makes use of a parenthesized exponent as in f^(-1)(x).

4.4.2.6.1 Discussion

The sep element is used to separate PCDATA into separate tokens for parsing the contents of the various specialized forms of the cn elements. For example, sep is used when specifying the real and imaginary parts of a complex number (see Section 4.4.1 Token Elements). If it occurs between MathML elements, it is a MathML error.

4.4.2.6.2 Examples

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

4.4.2.6.3 Default Rendering

The sep element is not directly rendered (see Section 4.4.1 Token Elements).

4.4.2.7.1 Discussion

The condition element is used to assert that a Boolean valued expression should be true. The conditions may be specified in terms of relations that are to be satisfied , including general relationships such as set membership. When used in conjunction with the bound variables of an apply element, it serves as a shorthand notation for the domainofapplication defined by having n-tuples of values of the bound variables of the surrounding apply element included in the domain when the conditions placed on them in this way are satisfied and excluded otherwise.

It is used to define general sets and lists in situations where the elements cannot be explicitly enumerated. Condition contains either a single apply or reln element (deprecated); the apply element is used to construct compound conditions. For example, it is used below to describe the set of all x such that x < 5. See the discussion on sets in Section 4.4.6 Theory of Sets. See Section 4.2.5 Conditions for further details.

4.4.2.7.2 Examples

<condition>
  <apply><in/><ci> x </ci><ci type="set"> A </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.7.3 Default Rendering

4.4.2.8.1 Discussion

The declare 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 "name" and an object. Once a declaration is in effect, the "name" object acquires the new attribute settings, and (if the second object is present) all the properties of the associated object.

The various attributes of the declare element assign properties to the object being declared or determine where the declaration is in effect. The list of allowed attributes varies depending on the object involved as it always includes the attributes associated with that object.

All declare elements must occur at the beginning of a math element. The scope of a declaration is "local" to the surrounding math element. The scope attribute can only be assigned to "local", but is intended to support future extensions. As discussed in Section 4.3.2.8 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.

declare takes one or two children. The first child, which is mandatory, is the object affected by the declaration. This is usually a ci element providing the identifier that is being declared as in:

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

The second child, which is optional, is a constructor initializing the variable:

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

The constructor type and the type of the element declared must agree. For example, if the type attribute of the declaration is function, the second child (constructor) must be an element that can serve as a function. (This would typically be something like a csymbol element, a ci element, a lambda element, or 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.

An important case is when the first child is an identifier, and the second child is a semantics tag enclosing that identifier. In this case all uses of the identifier acquire the associations implied by the use of the semantics element. without having to write out the full semantics element for every use.

The actual instances of a declared ci element are normally recognized by comparing their content with that of the declared element. Equality of two elements is determined by comparing the XML information set of the two expressions after XML space normalization (see [XPath]).

When the content is more complex, semantics elements are involved, or the author simply wants to use multiple presentations for emphasis without losing track of the relationship to the declared instance the author may choose to make the correspondence explicit by placing an id attribute on a declared instance and referring back to it using a definitionURL attribute on the matching instances of the ci element as in the following example.

  <declare>
    <ci id="var-A"> A </ci>
    <vector>
      <ci> a </ci>
      <ci> b </ci>
      <ci> c </ci>
    </vector>
  </declare>
  <apply>
    <eq/>
    <ci> V </ci>
    <apply>
      <plus/>
      <ci definitionURL="#var-A"> A </ci>
      <ci> B </ci>
    </apply>
  </apply>

4.4.2.8.2 Attributes

All attributes are CDATA. Of special interest are:

type

defines the MathML element type of the identifier declared.

scope

defines the scope of application of the declaration.

nargs

number of arguments for function declarations.

occurrence

describes operator usage as "prefix", "infix" or "function-model" indications.

definitionURL

URI pointing to detailed semantics of the function.

encoding

syntax of the detailed semantics of the function.

4.4.2.8.3 Examples

The declaration

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

declares f to be a two-variable function with the property that f(x, y) = (F+ G)(x, y).

The declaration

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

associates the name J with a one-variable function defined so that J(y) = ln y. (Note that because of the type attribute of the declare element, the second argument must be something of function type , namely a known function like sin, or a lambda construct.)

The type attribute on the declaration is only necessary if the type cannot be inferred from the type of the second argument.

Even when a declaration is in effect it is still possible to override attributes values selectively as in <ci type="set"> S </ci>. This capability is needed in order to write statements of the form "Let s be a member of S".

4.4.2.8.4 Default Rendering

Since the declare 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

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

is active the symbol v acquires all the properties of the vector, and even its dimension and components have meaningful values. This may affect how v is rendered by some applications, as well as how it is treated mathematically.

4.4.2.9.1 Discussion

The lambda element is used to construct a user-defined function from an expression, bound variables, and qualifiers. In a lambda construct with n (possibly 0) bound variables, the first n children are bvar elements that identify the variables that are used as placeholders in the last child for actual parameter values. The bound variables can be restricted by an optional domainofapplication qualifier or one of its shorthand notations. The meaning of the lambda construct is an n-ary function that returns the expression in the last child where the bound variables are replaced with the respective arguments. See Section 4.2.2.2 Constructors for further details.

4.4.2.9.2 Examples

The first example presents a simple lambda construct.

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

The next example constructs a one-argument function in which the argument b specifies the upper bound of a specific definite integral.

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

Such constructs are often used in conjunction with declare to construct new functions.

The domainofapplication child restricts the possible values of the arguments of the constructed function. For instance, the following two lambda constructs are representations of a function on the integers.

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

If a lambda construct does not contain bound variables, then the arity of the constructed function is unchanged, and the lambda construct is redundant, unless it also contains a domainofapplication construct that restricts existing functional arguments, as in this example, which is a variant representation for the function above.

<lambda>
  <domainofapplication><integers/></domainofapplication>
  <sin/>
</lambda>

In particular, if the last child of a lambda construct is not a function, say a number, then the lambda construct will not be a function, but the same number. Of course, in this case a domainofapplication does not make sense

4.4.2.9.3 Default Rendering

4.4.2.10.1 Discussion

The compose element represents the function composition operator. Note that MathML makes no assumption about the domain and codomain of the constituent functions in a composition; the domain of the resulting composition may be empty.

To override the default semantics for the compose element, or to associate a more specific definition for function composition, use the definitionURL and encoding attributes.

The compose element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.2.10.2 Examples

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

<apply>
  <compose/>
  <ci type="function"> f </ci>
  <ci type="function"> g </ci>
  <ci type="function"> 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.10.3 Default Rendering

4.4.2.11.1 Discussion

The ident element represents the identity function. MathML makes no assumption about the function space in which the identity function resides. That is, proper interpretation of the domain (and hence codomain) of the identity function depends on the context in which it is used.

To override the default semantics for the ident element, or to associate a more specific definition, use the definitionURL and encoding attributes (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.2.11.2 Examples

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

4.4.2.11.3 Default Rendering

4.4.2.12.1 Discussion

The domain element denotes the domain of a given function, which is the set of values over which it is defined.

To override the default semantics for the domain element, or to associate a more specific definition, use the definitionURL and encoding attributes (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.2.12.2 Examples

If f is a function from the reals to the rationals, then:

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

4.4.2.12.3 Default Rendering

4.4.2.13.1 Discussion

The codomain element denotes the codomain of a given function, which is a set containing all values taken by the function. It is not necessarily the case that every point in the codomain is generated by the function applied to some point of the domain. (For example I may know that a function is integer-valued, so its codomain is the integers, without knowing (or stating) which subset of the integers is mapped to by the function.)

Codomain is sometimes also called Range.

To override the default semantics for the codomain element, or to associate a more specific definition, use the definitionURL and encoding attributes (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.2.13.2 Examples

If f is a function from the reals to the rationals, then:

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

4.4.2.13.3 Default Rendering

4.4.2.14.1 Discussion

The image element denotes the image of a given function, which is the set of values taken by the function. Every point in the image is generated by the function applied to some point of the domain.

To override the default semantics for the image element, or to associate a more specific definition, use the definitionURL and encoding attributes (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.2.14.2 Examples

The real sin function is a function from the reals to the reals, taking values between -1 and 1.

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

4.4.2.14.3 Default Rendering

4.4.2.15.1 Discussion

The domainofapplication element is a qualifier which denotes the domain over which a given function is being applied. It is intended to be a more general alternative to specification of this domain using such qualifier elements as bvar, lowlimit or condition.

To override the default semantics for the domainofapplication element, or to associate a more specific definition, use the definitionURL and encoding attributes (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.2.15.2 Examples

The integral of a function f over an arbitrary domain C .

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

4.4.2.15.3 Default Rendering

The default rendering depends on the particular function being applied.

4.4.2.16.1 Discussion

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

The declaration is constructed using the piecewise element. This contains zero or more piece elements, and optionally one otherwise element. Each piece element contains exactly two children. The first child defines the value taken by the piecewise expression when the condition specified in the associated second child of the piece is true. The degenerate case of no piece elements and no otherwise element is treated as undefined for all values of the domain.

otherwise allows the specification of a value to be taken by the piecewise function when none of the conditions (second child elements of the piece elements) is true, i.e. a default value.

It should be noted that no "order of execution" is implied by the ordering of the piece child elements within piecewise. It is the responsibility of the author to ensure that the subsets of the function domain defined by the second children of the piece elements are disjoint, or that, where they overlap, the values of the corresponding first children of the piece elements coincide. If this is not the case, the meaning of the expression is undefined.

The piecewise elements are constructors (see Section 4.2.2.2 Constructors).

4.4.2.16.2 Examples

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

The following might be a definition of abs (x)

<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.2.16.3 Default Rendering

4.4.3.1.1 Discussion

The quotient element is the operator used for division modulo a particular base. When the quotient operator is applied to integer arguments a and b, the result is the "quotient of a divided by b". That is, quotient returns the unique integer q such that a = q b + r. (In common usage, q is called the quotient and r is the remainder.)

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

The quotient element is a binary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.1.2 Example

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

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 a=13 and b=5.

4.4.3.1.3 Default Rendering

There is no commonly used notation for this concept. Some possible renderings are

• quotient of a divided by b

• integer part of a / b

• 

4.4.3.2.1 Discussion

The factorial element is used to construct factorials.

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

The factorial element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.2.2 Example

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

If this were evaluated at n = 5 it would evaluate to 120.

4.4.3.2.3 Default Rendering

4.4.3.3.1 Discussion

The divide element is the division operator.

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

The divide element is a binary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.3.2 Example

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

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 a=5 and b=2 some mathematical applications may evaluate this to 2.5 while others will treat is as a rational number.

4.4.3.3.3 Default Rendering

4.4.3.4.1 Discussion

The elements max and min are used to compare the values of their arguments. They return the maximum and minimum of these values respectively.

The max and min elements take the definitionURL and encoding attributes that can be used to override the default semantics.

The max and min elements are n-ary arithmetic operators (see Section 4.2.3 Functions, Operators and Qualifiers). As n-ary operators, their operands may be listed explicitly or constructed using a domain of application as described in [n-ary operators].

4.4.3.4.2 Examples

When the objects are to be compared explicitly they are listed as arguments to the function as in:

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

The elements to be compared may also be described using bound variables with a condition element and an expression to be maximized (or minimized), as in:

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

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 (x) could be omitted in the example below: this usage is deprecated in MathML2.0 in favor of explicitly stating the bound variable and expression in all cases:

<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.4.3 Default Rendering

4.4.3.5.1 Discussion

The minus element is the subtraction operator.

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

The minus element can be used as a unary arithmetic operator (e.g. to represent - x), or as a binary arithmetic operator (e.g. to represent x- y).

4.4.3.5.2 Example

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

If this were evaluated at x=5 and y=2 it would yield 3.

4.4.3.5.3 Default Rendering

4.4.3.6.1 Discussion

The plus element is the addition operator.

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

The plus element is an n-ary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers). The operands are usually listed explicitly. As an n-ary operator, the operands may in principle also be provided using a domain of application as described in [n-ary operators]. However, such expressions can already be represented explicitly using Section 4.4.7.1 Sum (sum) so the plus does not normally take qualifiers.

4.4.3.6.2 Example

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

If this were evaluated at x = 5, y = 2 and z = 1 it would yield 8.

4.4.3.6.3 Default Rendering

4.4.3.7.1 Discussion

The power element is a generic exponentiation operator. That is, when applied to arguments a and b, it returns the value of "a to the power of b".

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

The power element is a binary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.7.2 Example

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

If this were evaluated at x= 5 it would yield 125.

4.4.3.7.3 Default Rendering

4.4.3.8.1 Discussion

The rem element is the operator that returns the "remainder" of a division modulo a particular base. When the rem operator is applied to integer arguments a and b, the result is the "remainder of a divided by b". That is, rem returns the unique integer, r such that a = q b+ r, where r < q. (In common usage, q is called the quotient and r is the remainder.)

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

The rem element is a binary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.8.2 Example

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

If this were evaluated at a = 15 and b = 8 it would yield 7.

4.4.3.8.3 Default Rendering

4.4.3.9.1 Discussion

The times element is the n-ary multiplication operator. The operands are usually listed explicitly. As an n-ary operator, the operands may in principle also be provided using a domain of application as described in [n-ary operators]. However, such expressions can already be represented explicitly by using Section 4.4.7.2 Product (product) so the times does not normally take qualifiers.

times takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.3.9.2 Example

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

If this were evaluated at a = 5.5 and b = 3 it would yield 16.5.

4.4.3.9.3 Default Rendering

4.4.3.10.1 Discussion

The root element is used to construct roots. The kind of root to be taken is specified by a degree element, which should be given as the second child of the apply element enclosing the root element. Thus, square roots correspond to the case where degree contains the value 2, cube roots correspond to 3, and so on. If no degree is present, a default value of 2 is used.

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

The root element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.3.10.2 Example

The nth root of a is is given by

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

4.4.3.10.3 Default Rendering

4.4.3.11.1 Discussion

The gcd element is used to denote the greatest common divisor of its arguments.

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

The gcd element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.3.11.2 Example

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

If this were evaluated at a = 15, b = 21, c = 48, it would yield 3.

4.4.3.11.3 Default Rendering

This default rendering is English-language locale specific: other locales may have different default renderings.

4.4.3.12.1 Discussion

The and element is the Boolean "and" operator.

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

The and element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.3.12.2 Example

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

If this were evaluated and both a and b had truth values of "true", then the result would be "true".

4.4.3.12.3 Default Rendering

4.4.3.13.1 Discussion

The or element is the Boolean "or" operator.

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

The or element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.3.13.2 Example

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

4.4.3.13.3 Default Rendering

4.4.3.14.1 Discussion

The xor element is the Boolean "exclusive or" operator.

xor takes the definitionURL and encoding attributes, which can be used to override the default semantics.

The xor element is an n-ary relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.3.14.2 Example

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

4.4.3.14.3 Default Rendering

4.4.3.15.1 Example

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

4.4.3.15.2 Default Rendering

4.4.3.16.1 Discussion

The implies element is the Boolean relational operator "implies".

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

The implies element is a binary logical operator (see Section 4.2.4 Relations).

4.4.3.16.2 Example

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

Mathematical applications designed for the evaluation of such expressions would evaluate this to "true" when a = "false" and b = "true".

4.4.3.16.3 Default Rendering

4.4.3.17.1 Discussion

The forall element represents the universal quantifier of logic. It is usually used in conjunction with one or more bound variables, an optional condition element, and an assertion. It may also be used with a domain of application and function as described in Section 4.2.3.2 Operators taking Qualifiers in which case the assertion corresponds to applying the function to an element of the specified domain. In MathML 1.0, the reln element was also permitted here: this usage is now deprecated.

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

The forall element is a quantifier (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.3.17.2 Examples

The first example encodes a simple identity.

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

The next example is more involved, and makes use of an optional condition element.

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

The final example uses both the forall and exists quantifiers.

<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.17.3 Default Rendering

4.4.3.18.1 Discussion

The exists element represents the existential quantifier of logic. Typically, it is used in conjunction with one or more bound variables, an optional condition element, and an assertion, which may take the form of either an apply or reln element. The exists element may also be used with a general domain of application and function as described in Section 4.2.3.2 Operators taking Qualifiers. For such uses the assertion is obtained by applying the function to an element of the specified domain.

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

The exists element is a quantifier (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.3.18.2 Example

The following example encodes the sense of the expression "there exists an x such that f(x) = 0".

<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.18.3 Default Rendering

4.4.3.19.1 Discussion

The abs element represents the absolute value of a real quantity or the modulus of a complex quantity.

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

The abs element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.19.2 Example

The following example encodes the absolute value of x.

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

4.4.3.19.3 Default Rendering

4.4.3.20.1 Discussion

The conjugate element represents the complex conjugate of a complex quantity.

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

The conjugate element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.20.2 Example

The following example encodes the conjugate of x + i y.

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

4.4.3.20.3 Default Rendering

4.4.3.21.1 Discussion

The arg operator (introduced in MathML 2.0) gives the "argument" of a complex number, which is the angle (in radians) it makes with the positive real axis. Real negative numbers have argument equal to + .

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

The arg element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.21.2 Example

The following example encodes the argument operation on x + i y.

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

4.4.3.21.3 Default Rendering

4.4.3.22.1 Discussion

The real operator (introduced in MathML 2.0) gives the real part of a complex number, that is the x component in x + i y

The real element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The real element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.22.2 Example

The following example encodes the real operation on x + i y.

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

A MathML-aware evaluation system would return the x component, suitably encoded.

4.4.3.22.3 Default Rendering

4.4.3.23.1 Discussion

The imaginary operator (introduced in MathML 2.0) gives the imaginary part of a complex number, that is, the y component in x + i y.

The imaginary element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The imaginary element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.3.23.2 Example

The following example encodes the imaginary operation on x + i y.

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

A MathML-aware evaluation system would return the y component, suitably encoded.

4.4.3.23.3 Default Rendering

4.4.3.24.1 Discussion

The lcm element (introduced in MathML 2.0) is used to denote the lowest common multiple of its arguments.

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

The lcm element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.3.24.2 Example

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

If this were evaluated at a = 2, b = 4, c = 6 it would yield 12.

4.4.3.24.3 Default Rendering

This default rendering is English-language locale specific: other locales may have different default renderings.

4.4.3.25.1 Discussion

The floor element (introduced in MathML 2.0) is used to denote the round-down (towards -infinity) operator.

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

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

4.4.3.25.2 Example

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

If this were evaluated at a = 15.015, it would yield 15.

<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.25.3 Default Rendering

4.4.3.26.1 Discussion

The ceiling element (introduced in MathML 2.0) is used to denote the round-up (towards +infinity) operator.

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

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

4.4.3.26.2 Example

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

If this were evaluated at a = 15.015, it would yield 16.

<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.3.26.3 Default Rendering

4.4.4.1.1 Discussion

The eq element is the relational operator "equals".

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

The eq element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.4.1.2 Example

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

If this were tested at a = 5.5 and b = 6 it would yield the truth value false.

4.4.4.1.3 Default Rendering

4.4.4.2.1 Discussion

The neq element is the "not equal to" relational operator.

neq takes the definitionURL and encoding attributes, which can be used to override the default semantics.

The neq element is a binary relation (see Section 4.2.4 Relations).

4.4.4.2.2 Example

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

If this were tested at a = 5.5 and b = 6 it would yield the truth value true.

4.4.4.2.3 Default Rendering

4.4.4.3.1 Discussion

The gt element is the "greater than" relational operator.

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

The gt element is an n-ary relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.4.3.2 Example

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

If this were tested at a = 5.5 and b = 6 it would yield the truth value false.

4.4.4.3.3 Default Rendering

4.4.4.4.1 Discussion

The lt element is the "less than" relational operator.

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

The lt element is an n-ary relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.4.4.2 Example

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

If this were tested at a = 5.5 and b = 6 it would yield the truth value "true".

4.4.4.4.3 Default Rendering

4.4.4.5.1 Discussion

The geq element is the relational operator "greater than or equal".

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

The geq element is an n-ary relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.4.5.2 Example

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

If this were tested for a = 5.5 and b = 5.5 it would yield the truth value true.

4.4.4.5.3 Default Rendering

4.4.4.6.1 Discussion

The leq element is the relational operator "less than or equal".

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

The leq element is an n-ary relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.4.6.2 Example

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

If a = 5.4 and b = 5.5 this will yield the truth value true.

4.4.4.6.3 Default Rendering

4.4.4.7.1 Discussion

The equivalent element is the "equivalence" relational operator.

The equivalent element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The equivalent element is an n-ary relation (see Section 4.2.4 Relations). As special form of n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers), its operands may be generated by allowing a function or expression to vary over a domain of application. Therefore it may take qualifiers.

4.4.4.7.2 Example

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

This yields the truth value true for all values of a.

4.4.4.7.3 Default Rendering

4.4.4.8.1 Discussion

The approx element is the relational operator "approximately equal". This is a generic relational operator and no specific arithmetic precision is implied

The approx element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The approx element is a binary relation (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.4.8.2 Example

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

4.4.4.8.3 Default Rendering

4.4.4.9.1 Discussion

The factorof element is the relational operator element on two integers a and b specifying whether one is an integer factor of the other.

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

The factorof element is an binary relational operator (see Section 4.2.4 Relations).

4.4.4.9.2 Example

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

4.4.4.9.3 Default Rendering

4.4.5.1.1 Discussion

The int element is the operator element for an integral. Optional bound variables serve as the integration variables and definite integrals are indicated by providing a domain of integration. This may be provided by an optional domainofapplication element or one of the shortcut representations of the domain of application (see Section 4.2.3.2 Operators taking Qualifiers). For example, the integration variable and domain of application can be given by the child elements lowlimit, uplimit and bvar in the enclosing apply element. The integrand is also specified as a child element of the enclosing apply element.

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

The int element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.5.1.2 Examples

An indefinite integral can be represented with or without the explicit use of a bound variable. To represent it without the use of a bound variable apply the int operator directly to a function as in

<apply>
  <eq/>
  <apply><int/><sin/></apply>
  <cos/>
</apply>

The next example specifies the integrand using an expression involving a bound variable and makes it a definite integral by using the qualifiers lowlimit, uplimit to place restrictions on the bound variable.

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

This example specifies an interval of the real line as the domain of integration with an interval element. In this form the integrand is provided as a function and no mention is made of a bound variable..

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

The final example specifies the domain of integration with a bound variable and a condition element.

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

4.4.5.1.3 Default Rendering

4.4.5.2.1 Discussion

The diff element is the differentiation operator element for functions of a single variable. It may be applied directly to an actual function such as sine or cosine, thereby denoting a function which is the derivative of the original function, or it can be applied to an expression involving a single variable such as sin(x), or cos(x). or a polynomial in x. For the expression case the actual variable is designated by a bvar element that is a child of the containing apply element. The bvar element may also contain a degree element, which specifies the order of the derivative to be taken.

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

The diff element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.5.2.2 Examples

The derivative of a function f (often displayed as f') can be written as:

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

The derivative with respect to x of an expression in x such as f (x) can be written as:

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

4.4.5.2.3 Default Rendering

4.4.5.3.1 Discussion

The partialdiff element is the partial differentiation operator element for functions or algebraic expressions in several variables.

In the case of algebraic expressions, the bound variables are given by bvar elements, which are children of the containing apply element. The bvar elements may also contain degree element, which specify the order of the partial derivative to be taken in that variable.

For the expression case the actual variable is designated by a bvar element that is a child of the containing apply element. The bvar elements may also contain a degree element, which specifies the order of the derivative to be taken.

Where a total degree of differentiation must be specified, this is indicated by use of a degree element at the top level, i.e. without any associated bvar, as a child of the containing apply element.

For the case of partial differentiation of a function, the containing apply takes two child elements: firstly a list of indices indicating by position which coordinates are involved in constructing the partial derivatives, and secondly the actual function to be partially differentiated. The coordinates may be repeated.

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

The partialdiff element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.5.3.2 Examples

<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="function"> 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="function"> 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="function">f</ci>
</apply>

4.4.5.3.3 Default Rendering

4.4.5.4.1 Discussion

The lowlimit element is the container element used to indicate the "lower limit" of an operator using qualifiers. For example, in an integral, it can be used to specify the lower limit of integration. Similarly, it can be used to specify the lower limit of an index for a sum or product.

The meaning of the lowlimit element depends on the context it is being used in. For further details about how qualifiers are used in conjunction with operators taking qualifiers, consult Section 4.2.3.2 Operators taking Qualifiers.

4.4.5.4.2 Example

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

4.4.5.4.3 Default Rendering

The default rendering of the lowlimit element and its contents depends on the context. In the preceding example, it should be rendered as a subscript to the integral sign:

Consult the descriptions of individual operators that make use of the lowlimit construct for default renderings.

4.4.5.5.1 Discussion

The uplimit element is the container element used to indicate the "upper limit" of an operator using qualifiers. For example, in an integral, it can be used to specify the upper limit of integration. Similarly, it can be used to specify the upper limit of an index for a sum or product.

The meaning of the uplimit element depends on the context it is being used in. For further details about how qualifiers are used in conjunction with operators taking qualifiers, consult Section 4.2.3.2 Operators taking Qualifiers.

4.4.5.5.2 Example

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

4.4.5.5.3 Default Rendering

The default rendering of the uplimit element and its contents depends on the context. In the preceding example, it should be rendered as a superscript to the integral sign:

Consult the descriptions of individual operators that make use of the uplimit construct for default renderings.

4.4.5.6.1 Discussion

The bvar element is the container element for the "bound variable" of an operation. For example, in an integral it specifies the variable of integration. In a derivative, it indicates the variable with respect to which a function is being differentiated. When the bvar element is used to qualify a derivative, it may contain a child degree element that specifies the order of the derivative with respect to that variable. The bvar element is also used for the internal variable in a number of operators taking qualifiers, including user defined operators, sums and products and for the bound variable used with the universal and existential quantifiers forall and exists. When a bvar element has more than one child element, the elements may appear in any order.

Instances of the bound variables are normally recognized by comparing the XML information sets of the relevant ci elements after first carrying out XML space normalization. Such identification can be made explicit by placing an id on the ci element in the bvar element and referring to it using the definitionURL attribute on all other instances. An example of this approach is

<set>
  <bvar><ci id="var-x"> x </ci></bvar>
  <condition>
    <apply>
      <lt/>
      <ci definitionURL="#var-x"> x </ci>
      <cn> 1 </cn>
    </apply>
  </condition>
</set>

This id based approach is especially helpful when constructions involving bound variables are nested.

It can be necessary to associate additional information with a bound variable one or more instances of it. The information might be something like a detailed mathematical type, an alternative presentation or encoding or a domain of application. Such associations are accomplished in the standard way by replacing a ci element (even inside the bvar element) by a semantics element containing both it and the additional information. Recognition of and instance of the bound variable is still based on the actual ci elements and not the semantics elements or anything else they may contain. The id based approach outlined above may still be used.

The meaning of the bvar element depends on the context it is being used in. For further details about how qualifiers are used in conjunction with operators taking qualifiers, consult Section 4.2.3.2 Operators taking Qualifiers.

4.4.5.6.2 Examples

<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="function"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.5.6.3 Default Rendering

The default rendering of the bvar element and its contents depends on the context. In the preceding examples, it should be rendered as the x in the dx of the integral, and as the x in the denominator of the derivative symbol, respectively:

Note that in the case of the derivative, the default rendering of the degree child of the bvar element is as an exponent.

Consult the descriptions of individual operators that make use of the bvar construct for default renderings.

4.4.5.7.1 Discussion

The degree element is the container element for the "degree" or "order" of an operation. There are a number of basic mathematical constructs that come in families, such as derivatives and moments. Rather than introduce special elements for each of these families, MathML uses a single general construct, the degree element for this concept of "order".

The meaning of the degree element depends on the context it is being used in. For further details about how qualifiers are used in conjunction with operators taking qualifiers, consult Section 4.2.3.2 Operators taking Qualifiers.

4.4.5.7.2 Example

<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.7.3 Default Rendering

The default rendering of the degree element and its contents depends on the context. In the preceding example, the degree elements would be rendered as the exponents in the differentiation symbols:

Consult the descriptions of individual operators that make use of the degree construct for default renderings.

4.4.5.8.1 Discussion

The divergence element is the vector calculus divergence operator, often called div.

The divergence element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The divergence element is a unary calculus operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.5.8.2 Example

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

4.4.5.8.3 Default Rendering

or

4.4.5.9.1 Discussion

The grad element is the vector calculus gradient operator, often called grad.

The grad element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The grad element is a unary calculus operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.5.9.2 Example

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

Where for example f is a scalar function of three real variables.

4.4.5.9.3 Default Rendering

or

4.4.5.10.1 Discussion

The curl element is the vector calculus curl operator.

The curl element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The curl element is a unary calculus operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.5.10.2 Example

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

Where for example a is a vector field.

4.4.5.10.3 Default Rendering

or

4.4.5.11.1 Discussion

The laplacian element is the vector calculus laplacian operator.

The laplacian element takes the attributes encoding and definitionURL that can be used to override the default semantics.

The laplacian element is an unary calculus operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.5.11.2 Example

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

Where for example f is a scalar function of three real variables.

4.4.5.11.3 Default Rendering

4.4.6.1.1 Discussion

The set 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 evaluating a function over a domain of application as described in Section 4.2.3.2 Operators taking Qualifiers.

The set element is a constructor element (see Section 4.2.2.2 Constructors).

4.4.6.1.2 Examples

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

This constructs the set {b, a, c}

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

This constructs the set of all natural numbers less than 5, i.e. the set {0, 1, 2, 3, 4}. In general a set can be constructed by providing a function and a domain of application. The elements of the set correspond to the values obtained by evaluating the function at the points of the domain. The qualifications defined by a domainofapplication element can also be abbreviated in several ways including just a condition element placing constraints directly on the bound variables as in this example

4.4.6.1.3 Default Rendering

4.4.6.2.1 Discussion

The list element is the container element that constructs a list of elements. Elements can be defined either by explicitly listing the elements, or by evaluating a function over a domain of application as described in Section 4.2.3.2 Operators taking Qualifiers.

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

The list element is a constructor element (see Section 4.2.2.2 Constructors).

4.4.6.2.2 Examples

<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.2.3 Default Rendering

4.4.6.3.1 Discussion

The union element is the operator for a set-theoretic union or join of sets. The operands are usually listed explicitly.

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

The union element is an n-ary set operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.6.3.2 Example

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

<apply>
  <union/>
  <bvar><ci type="set"> S </ci></bvar>
  <domainofapplication><ci type="list">L</ci></domainofapplication>
  <ci type="set"> S </ci>
</apply>

4.4.6.3.3 Default Rendering

4.4.6.4.1 Discussion

The intersect element is the operator for the set-theoretic intersection or meet of sets. The operands are usually listed explicitly.

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

The intersect element is an n-ary set operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.6.4.2 Example

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

<apply>
  <intersect/>
  <bvar><ci type="set"> S </ci></bvar>
  <domainofapplication><ci type="list">L</ci></domainofapplication>
  <ci type="set"> S </ci>
</apply>

4.4.6.4.3 Default Rendering

4.4.6.5.1 Discussion

The in element is the relational operator used for a set-theoretic inclusion ("is in" or "is a member of").

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

The in element is a binary set relation (see Section 4.2.4 Relations).

4.4.6.5.2 Example

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

4.4.6.5.3 Default Rendering

4.4.6.6.1 Discussion

The notin element is the relational operator element used for set-theoretic exclusion ("is not in" or "is not a member of").

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

The notin element is a binary set relation (see Section 4.2.4 Relations).

4.4.6.6.2 Example

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

4.4.6.6.3 Default Rendering

4.4.6.7.1 Discussion

The subset element is the relational operator element for a set-theoretic containment ("is a subset of").

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

The subset element is an n-ary set relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.6.7.2 Example

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

<apply>
  <subset/>
  <bvar><ci type="set">S</ci></bvar>
  <condition>
    <apply><in/>
      <ci>S</ci>
      <ci type="list">T</ci>
    </apply>
  </condition>
  <ci>S</ci>
</apply>

4.4.6.7.3 Default Rendering

4.4.6.8.1 Discussion

The prsubset element is the relational operator element for set-theoretic proper containment ("is a proper subset of").

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

The prsubset element is an n-ary set relation (see Section 4.2.4 Relations). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.6.8.2 Example

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

<apply>
  <prsubset/>
  <bvar><ci type="integer">i</ci></bvar>
  <lowlimit><cn>0</cn></lowlimit>
  <uplimit><cn>10</cn></uplimit>
  <apply><selector/>
    <ci type="vector_of_sets">S</ci>
    <ci>i</ci>
  </apply>
</apply>

4.4.6.8.3 Default Rendering

4.4.6.9.1 Discussion

The notsubset element is the relational operator element for the set-theoretic relation "is not a subset of".

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

The notsubset element is a binary set relation (see Section 4.2.4 Relations).

4.4.6.9.2 Example

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

4.4.6.9.3 Default Rendering

4.4.6.10.1 Discussion

The notprsubset element is the operator element for the set-theoretic relation "is not a proper subset of".

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

The notprsubset element is a binary set relation (see Section 4.2.4 Relations).

4.4.6.10.2 Example

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

4.4.6.10.3 Default Rendering

4.4.6.11.1 Discussion

The setdiff element is the operator element for a set-theoretic difference of two sets.

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

The setdiff element is a binary set operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.6.11.2 Example

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

4.4.6.11.3 Default Rendering

4.4.6.12.1 Discussion

The card element is the operator element for the size or cardinality of a set.

The card element takes the attributes definitionURL and encoding that can be used to override the default semantics.

The card element is a unary set operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.6.12.2 Example

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

where A is a set with 5 elements.

4.4.6.12.3 Default Rendering

4.4.6.13.1 Discussion

The cartesianproduct element is the operator element for the Cartesian product of two or more sets. If A and B are two sets, then the Cartesian product of A and B is the set of all pairs (a,b) with a in A and b in B.

The cartesianproduct element takes the attributes definitionURL and encoding that can be used to override the default semantics.

The cartesianproduct element is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers). As an n-ary operator, its operands may also be generated as described in [n-ary operators] Therefore it may take qualifiers.

4.4.6.13.2 Example

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

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

4.4.6.13.3 Default Rendering

4.4.7.1.1 Discussion

The sum element denotes the summation operator. The most general form of a sum specifies the terms of the sum by using a domainofapplication element to specify a domain. If no bound variables are specified then terms of the sum correspond to those produced by evaluating the function that is provided at the points of the domain, while if bound variables are present they are the index of summation and they take on the values of points in the domain. In this case the terms of the sum correspond to the values of the expression that is provided, evaluated at those points. Depending on the structure of the domain, the domain of summation can be abbreviated by using uplimit and lowlimit to specify upper and lower limits for the sum.

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

The sum element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.7.1.2 Examples

<apply>
  <sum/>
  <bvar><ci> x </ci></bvar>
  <lowlimit>
    <ci> a </ci>
  </lowlimit>
  <uplimit>
    <ci> b </ci>
  </uplimit>
  <apply><ci type="function"> 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="function"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

<apply>
  <sum/>
  <domainofapplication>
    <ci type="set"> B </ci>
  </domainofapplication>
  <ci type="function"> f </ci>
</apply>

4.4.7.1.3 Default Rendering

4.4.7.2.1 Discussion

The product element denotes the product operator. The most general form of a product specifies the terms of the product by using a domainofapplication element to specify the domain. If no bound variables are specified then terms of the product correspond to those produced by evaluating the function that is provided at the points of the domain, while if bound variables are present they are the index of product and they take on the values of points in the domain. In this case the terms of the product correspond to the values of the expression that is provided, evaluated at those points. Depending on the structure of the domain, the domain of product can be abbreviated by using uplimit and lowlimit to specify upper and lower limits for the product.

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

The product element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.7.2.2 Examples

<apply>
  <product/>
  <bvar><ci> x </ci></bvar>
  <lowlimit><ci> a </ci></lowlimit>
  <uplimit><ci> b </ci></uplimit>
  <apply>
    <ci type="function"> 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="function"> f </ci>
    <ci> x </ci>
  </apply>
</apply>

4.4.7.2.3 Default Rendering

4.4.7.3.1 Discussion

The limit element represents the operation of taking a limit of a sequence. The limit point is expressed by specifying a lowlimit and a bvar, or by specifying a condition on one or more bound variables.

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

The limit element is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.7.3.2 Examples

<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.3.3 Default Rendering

4.4.7.4.1 Discussion

The tendsto element is used to express the relation that a quantity is tending to a specified value. While this is used primarily as part of the statement of a mathematical limit, it exists as a construct on its own to allow one to capture mathematical statements such as "As x tends to y," and to provide a building block to construct more general kinds of limits that are not explicitly covered by the recommendation.

The tendsto element takes the attributes type to set the direction from which the limiting value is approached.

The tendsto element is a binary relational operator (see Section 4.2.4 Relations).

4.4.7.4.2 Examples

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

To express (x, y) (f(x, y), g(x, y)), one might use vectors, as in:

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

4.4.7.4.3 Default Rendering

4.4.8.1.1 Discussion

These operator elements denote the standard trigonometric functions.

These elements all take the definitionURL and encoding attributes, which can be used to override the default semantics.

They are all unary trigonometric operators. (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.8.1.2 Examples

<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.1.3 Default Rendering

4.4.8.2.1 Discussion

The exp element represents the exponential function associated with the inverse of the ln function. In particular, exp(1) is approximately 2.718281828.

The exp element takes the definitionURL and encoding attributes, which may be used to override the default semantics.

The exp element is a unary arithmetic operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.8.2.2 Example

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

4.4.8.2.3 Default Rendering

4.4.8.3.1 Discussion

The ln element represents the natural logarithm function.

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

The ln element is a unary calculus operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.8.3.2 Example

<apply>
  <ln/>
  <ci> a </ci>
</apply>

If a = e, (where e is the base of the natural logarithms) this will yield the value 1.

4.4.8.3.3 Default Rendering

4.4.8.4.1 Discussion

The log element is the operator that returns a logarithm to a given base. The base may be specified using a logbase element, which should be the first element following log, i.e. the second child of the containing apply element. If the logbase element is not present, a default base of 10 is assumed.

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

The log element can be used as either an operator taking qualifiers or a unary calculus operator (see Section 4.2.3.2 Operators taking Qualifiers).

4.4.8.4.2 Example

<apply>
  <log/>
  <logbase>
    <cn> 3 </cn>
  </logbase>
  <ci> x </ci>
</apply>

This markup represents "the base 3 logarithm of x". For natural logarithms base e, the ln element should be used instead.

4.4.8.4.3 Default Rendering

4.4.9.1.1 Discussion

mean is the operator element representing a mean or average.

mean takes the definitionURL and encoding attributes, which can be used to override the default semantics.

The mean element is a n-ary operator and takes certain qualifiers (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.9.1.2 Example

<apply>
  <mean/>
  <ci> X </ci>
</apply>

4.4.9.1.3 Default Rendering

or

4.4.9.2.1 Discussion

sdev is the operator element representing the statistical standard deviation operator.

sdev takes the definitionURL and encoding attributes, which can be used to override the default semantics.

The sdev element is a n-ary operator and takes certain qualifiers (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.9.2.2 Example

sdev is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers).

<apply>
  <sdev/>
  <ci> X </ci>
</apply>

4.4.9.2.3 Default Rendering

4.4.9.3.1 Discussion

variance is the operator element representing the statistical variance operator.

variance takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.9.3.2 Example

variance is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers).

<apply>
  <variance/>
  <ci> X </ci>
</apply>

4.4.9.3.3 Default Rendering

4.4.9.4.1 Discussion

median is the operator element representing the statistical median operator.

median takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.9.4.2 Example

median is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers).

<apply>
  <median/>
  <ci> X </ci>
</apply>

4.4.9.4.3 Default Rendering

4.4.9.5.1 Discussion

mode is the operator element representing the statistical mode operator.

mode takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.9.5.2 Example

mode is an n-ary operator (see Section 4.2.3 Functions, Operators and Qualifiers).

<apply>
  <mode/>
  <ci> X </ci>
</apply>

4.4.9.5.3 Default Rendering

4.4.9.6.1 Discussion

The moment element represents the statistical moment operator. Use the qualifier degree for the n in " n-th moment". Use the qualifier momentabout for the p in "moment about p".

moment takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.9.6.2 Example

moment is an operator taking qualifiers (see Section 4.2.3.2 Operators taking Qualifiers). The third moment of the distribution X about the point p is written:

<apply>
  <moment/>
  <degree><cn> 3 </cn></degree>
  <momentabout>
    <ci> p </ci>
  </momentabout>
  <ci> X </ci>
</apply>

4.4.9.6.3 Default Rendering

4.4.9.7.1 Discussion

The momentabout element is a qualifier element used with the moment element to represent statistical moments. Use the qualifier momentabout for the p in "moment about p".

momentabout takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.9.7.2 Example

The third moment of the distribution X about the point p is written:

<apply>
  <moment/>
  <degree><cn> 3 </cn></degree>
  <momentabout><ci> p </ci></momentabout>
  <ci> X </ci>
</apply>

4.4.9.7.3 Default Rendering

4.4.10.1.1 Discussion

vector is the container element for a vector. The child elements form the components of the vector.

For purposes of interaction with matrices and matrix multiplication, vectors are regarded as equivalent to a matrix consisting of a single column, and the transpose of a vector behaves the same as a matrix consisting of a single row. Note that vectors may be rendered either as a single column or row.

In general a vector can be constructed by providing a function and a 1-dimensional domain of application. The entries of the vector correspond to the values obtained by evaluating the function at the points of the domain. The qualifications defined by a domainofapplication element can also be abbreviated in several ways including a condition placed on a bound variable and an expression involving that variable.

4.4.10.1.2 Example

vector is a constructor element (see Section 4.2.2.2 Constructors).

<vector>
  <cn> 1 </cn>
  <cn> 2 </cn>
  <cn> 3 </cn>
  <ci> x </ci>
</vector>

4.4.10.1.3 Default Rendering

(1, 2, 3, x)

4.4.10.2.1 Discussion

The matrix element is the container element for matrix rows, which are represented by matrixrow. The matrixrows contain the elements of a matrix.

In general a matrix can be constructed by providing a function and a 2-dimensional domain of application. The entries of the matrix correspond to the values obtained by evaluating the function at the points of the domain. The qualifications defined by a domainofapplication element can also be abbreviated in several ways including a condition element placing constraints directly on bound variables and an expression in those variables.

4.4.10.2.2 Example

matrix is a constructor element (see Section 4.2.2.2 Constructors).

<matrix>
  <matrixrow>
    <cn> 0 </cn> <cn> 1 </cn> <cn> 0 </cn>
  </matrixrow>
  <matrixrow>
    <cn> 0 </cn> <cn> 0 </cn> <cn> 1 </cn>
  </matrixrow>
  <matrixrow>
    <cn> 1 </cn> <cn> 0 </cn> <cn> 0 </cn>
  </matrixrow>
</matrix>

4.4.10.2.3 Default Rendering

4.4.10.3.1 Discussion

The matrixrow element is the container element for the rows of a matrix.

4.4.10.3.2 Example

matrixrow is a constructor element (see Section 4.2.2.2 Constructors).

<matrixrow>
  <cn> 1 </cn>
  <cn> 2 </cn>
</matrixrow>
<matrixrow>
  <cn> 3 </cn>
  <ci> x </ci>
</matrixrow>

4.4.10.3.3 Default Rendering

Matrix rows are not directly rendered by themselves outside of the context of a matrix.

4.4.10.4.1 Discussion

The determinant element is the operator for constructing the determinant of a matrix.

determinant takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.10.4.2 Example

determinant is a unary operator (see Section 4.2.3 Functions, Operators and Qualifiers).

<apply>
  <determinant/>
  <ci type="matrix"> A </ci>
</apply>

4.4.10.4.3 Default Rendering

4.4.10.5.1 Discussion

The transpose element is the operator for constructing the transpose of a matrix.

transpose takes the definitionURL and encoding attributes, which can be used to override the default semantics.

4.4.10.5.2 Example

transpose is a unary operator (see Section 4.2.3 Functions, Operators and Qualifiers).

<apply>
  <transpose/>
  <ci type="matrix"> A </ci>
</apply>

4.4.10.5.3 Default Rendering

4.4.10.6.1 Discussion

The selector element is the operator for indexing into vectors matrices and lists. It accepts one or more arguments. The first argument identifies the vector, matrix or list from which the selection is taking place, and the second and subsequent arguments, if any, indicate the kind of selection taking place.

When selector is used with a single argument, it should be interpreted as giving the sequence of all elements in the list, vector or matrix given. The ordering of elements in the sequence for a matrix is understood to be first by column, then by row. That is, for a matrix ( a_i,j), where the indices denote row and column, the ordering would be a _1,1, a _1,2, ... a _2,1, a_2,2 ... etc.

When three arguments are given, the last one is ignored for a list or vector, and in the case of a matrix, the second and third arguments specify the row and column of the selected element.

When two arguments are given, and the first is a vector or list, the second argument specifies an element in the list or vector. When a matrix and only one index i is specified as in

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

it refers to the i-th matrixrow. Thus, the preceding example selects the following row:

<matrixrow> <cn> 1 </cn> <cn> 2 </cn> </matrixrow>

selector takes the definitionURL and encoding attributes, which can be used to override the default semantics.

selector is classified as an n-ary linear algebra operator even though it can take only one, two, or three arguments.

4.4.10.6.2 Example

<apply>
  <selector/>
  <ci type="matrix"> A </ci>
  <cn> 3 </cn>
  <cn> 2 </cn>
</apply>

4.4.10.6.3 Default Rendering

The selector 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. For example, the selection

<apply>
  <selector/>
  <ci type="vector">V</ci>
  <cn> 1 </cn>
</apply>

would have a default rendering of

Selecting the (1,2) element of a 2 by 2 matrix would have a default rendering as

4.4.10.7.1 Discussion

The vectorproduct is the operator element for deriving the vector product of two vectors.

The vectorproduct element takes the attributes definitionURL and encoding that can be used to override the default semantics.

The vectorproduct element is a binary vector operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.10.7.2 Example

<apply>
  <eq/>
  <apply><vectorproduct/>
    <ci type="vector"> A </ci>
    <ci type="vector"> B </ci>
  </apply>
  <apply><times/>
    <ci> a </ci>
    <ci> b </ci>
    <apply><sin/>
      <ci> &theta; </ci>
    </apply>
    <ci type="vector"> N </ci>
  </apply>
</apply>

where A and B are vectors, N is a unit vector orthogonal to A and B, a, b are the magnitudes of A, B and is the angle between A and B.

4.4.10.7.3 Default Rendering

4.4.10.8.1 Discussion

The scalarproduct is the operator element for deriving the scalar product of two vectors.

The scalarproduct element takes the attributes definitionURL and encoding that can be used to override the default semantics.

The scalarproduct element is a binary vector operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.10.8.2 Example

<apply>
  <eq/>
  <apply><scalarproduct/>
    <ci type="vector"> A </ci>
    <ci type="vector">B </ci>
  </apply>
  <apply><times/>
    <ci> a </ci>
    <ci> b </ci>
    <apply><cos/>
      <ci> &theta; </ci>
    </apply>
  </apply>
</apply>

where A and B are vectors, a, b are the magnitudes of A, B and is the angle between A and B.

4.4.10.8.3 Default Rendering

4.4.10.9.1 Discussion

The outerproduct is the operator element for deriving the outer product of two vectors.

The outerproduct element takes the attributes definitionURL and encoding that can be used to override the default semantics.

The outerproduct element is a binary vector operator (see Section 4.2.3 Functions, Operators and Qualifiers).

4.4.10.9.2 Example

<apply>
  <outerproduct/>
  <ci type="vector">A</ci>
  <ci type="vector">B</ci>
</apply>

where A and B are vectors.

4.4.10.9.3 Default Rendering

or

4.4.11.1.1 Discussion

The annotation element is the container element for a semantic annotation in a non-XML format.

The annotation element takes the attributes definitionURL and encoding that can be used to override the default semantics. Only the encoding attribute is required whenever the semantics remains unchanged.

4.4.11.1.2 Example

The annotation element is a semantic mapping element. It is always used with semantics.

<semantics>
  <apply>
    <plus/>
    <apply><sin/>
      <ci> x </ci>
    </apply>
    <cn> 5 </cn>
  </apply>
  <annotation encoding="TeX">
    \sin x + 5
  </annotation>
</semantics>

4.4.11.1.3 Default Rendering

None. The information contained in annotations may optionally be used by a renderer able to process the kind of annotation given.

4.4.11.2.1 Discussion

The semantics element is the container element that associates additional representations with a given MathML construct. The semantics element has as its first child the expression being annotated, and the subsequent children are the annotations. There is no restriction on the kind of annotation that can be attached using the semantics element. For example, one might give a T_EX encoding, computer algebra input, or even detailed mathematical type information in an annotation. A definitionURL attribute is used on the annotation to indicate when the semantics of an annotation differs significantly from that of the original expression.

The representations that are XML based are enclosed in an annotation-xml element while those representations that are to be parsed as PCDATA are enclosed in an annotation element.

The semantics element takes the definitionURL and encoding attributes, which can be used to reference an external source for some or all of the semantic information.

An important purpose of the semantics construct is to associate specific semantics with a particular presentation, or additional presentation information with a content construct. The default rendering of a semantics element is the default rendering of its first child. When a MathML-presentation annotation is provided, a MathML renderer may optionally use this information to render the MathML construct. This would typically be the case when the first child is a MathML content construct and the annotation is provided to give a preferred rendering differing from the default for the content elements.

Use of semantics to attach additional information in-line to a MathML construct can be contrasted with use of the csymbol for referencing external semantics. See Section 4.4.1.3 Externally defined symbol (csymbol)

4.4.11.2.2 Examples

The semantics element is a semantic mapping element.

<semantics>
  <apply>
    <plus/>
    <apply>
      <sin/>
      <ci> x </ci>
    </apply>
    <cn> 5 </cn>
  </apply>
  <annotation encoding="Maple">
    sin(x) + 5
  </annotation>
  <annotation-xml encoding="MathML-Presentation">
    ...
    ...
  </annotation-xml>
  <annotation encoding="Mathematica">
    Sin[x] + 5
  </annotation>
  <annotation encoding="TeX">
    \sin x + 5
  </annotation>
  <annotation-xml encoding="OpenMath">
    <OMA xmlns="http://www.openmath.org/OpenMath">
    <OMS cd="transc1" name="sin"/>
    <OMI>5</OMI>
    </OMA>
  </annotation-xml>
</semantics>

4.4.11.2.3 Default Rendering

The default rendering of a semantics element is the default rendering of its first child.

4.4.11.3.1 Discussion

The annotation-xml container element is used to contain representations that are XML based. It is always used together with the semantics element.

The annotation-xml element takes the attributes definitionURL and encoding that can be used to override the default semantics. Only the encoding attribute is required whenever the semantics remains unchanged.

annotation-xml is a semantic mapping element.

4.4.11.3.2 Example

<semantics>
  <apply>
    <plus/>
    <apply><sin/>
      <ci> x </ci>
    </apply>
    <cn> 5 </cn>
  </apply>
  <annotation-xml encoding="OpenMath">
    <OMA xmlns="http://www.openmath.org/OpenMath">
      <OMS name="plus" cd="arith1"/>
      <OMA><OMS name="sin" cd="transc1"/>
        <OMV name="x"/>
      </OMA>
      <OMI>5</OMI>
    </OMA>
  </annotation-xml>
</semantics>

See also the discussion of semantics above.

4.4.11.3.3 Default Rendering

None. The information may optionally be used by a renderer able to process the kind of annotation given.

4.4.12.1.1 Discussion

integers represents the set of all integers.

4.4.12.1.2 Example

<apply>
  <in/>
  <cn type="integer"> 42 </cn>
  <integers/>
</apply>

4.4.12.1.3 Default Rendering

4.4.12.2.1 Discussion

reals represents the set of all real numbers.

4.4.12.2.2 Example

<apply>
  <in/>
  <cn type="real"> 44.997 </cn>
  <reals/>
</apply>

4.4.12.2.3 Default Rendering

4.4.12.3.1 Discussion

rationals represents the set of all rational numbers.

4.4.12.3.2 Example

<apply>
  <in/>
  <cn type="rational"> 22 <sep/>7</cn>
  <rationals/>
</apply>

4.4.12.3.3 Default Rendering

4.4.12.4.1 Discussion

naturalnumbers represents the set of all natural numbers, i.e. non-negative integers.

4.4.12.4.2 Example

<apply>
  <in/>
  <cn type="integer">1729</cn>
  <naturalnumbers/>
</apply>

4.4.12.4.3 Default Rendering

4.4.12.5.1 Discussion

complexes represents the set of all complex numbers, i.e. numbers which may have a real and an imaginary part.

4.4.12.5.2 Example

<apply>
  <in/>
  <cn type="complex-cartesian">17<sep/>29</cn>
  <complexes/>
</apply>

4.4.12.5.3 Default Rendering

4.4.12.6.1 Discussion

primes represents the set of all natural prime numbers, i.e. integers greater than 1 which have no positive integer factor other than themselves and 1.

4.4.12.6.2 Example

<apply>
  <in/>
  <cn type="integer">17</cn>
  <primes/>
</apply>

4.4.12.6.3 Default Rendering

4.4.12.7.1 Discussion

exponentiale represents the mathematical constant which is the exponential base of the natural logarithms, commonly written e. It is approximately 2.718281828..

4.4.12.7.2 Example

<apply> <eq/>
  <apply>
    <ln/>
    <exponentiale/>
  </apply>
  <cn>1</cn>
</apply>

4.4.12.7.3 Default Rendering

4.4.12.8.1 Discussion

imaginaryi represents the mathematical constant which is the square root of -1, commonly written i.

4.4.12.8.2 Example

<apply> <eq/>
  <apply>
    <power/>
    <imaginaryi/>
    <cn>2</cn>
  </apply>
  <cn>-1</cn>
</apply>

4.4.12.8.3 Default Rendering

4.4.12.9.1 Discussion

notanumber represents the result of an ill-defined floating point operation, sometimes also called NaN.

4.4.12.9.2 Example

<apply> <eq/>
  <apply>
    <divide/>
    <cn>0</cn>
    <cn>0</cn>
  </apply>
  <notanumber/>
</apply>

4.4.12.9.3 Default Rendering

4.4.12.10.1 Discussion

true represents the logical constant for truth.

4.4.12.10.2 Example

<apply> <eq/>
  <apply>
    <or/>
    <true/>
    <ci type = "logical">P</ci>
  </apply>
  <true/>
</apply>

4.4.12.10.3 Default Rendering

4.4.12.11.1 Discussion

false represents the logical constant for falsehood.

4.4.12.11.2 Example

<apply> <eq/>
  <apply>
    <and/>
    <false/>
    <ci type = "logical">P</ci>
  </apply>
  <false/>
</apply>

4.4.12.11.3 Default Rendering

4.4.12.12.1 Discussion

emptyset represents the empty set.

4.4.12.12.2 Example

  <apply>
    <neq/>
    <integers/>
    <emptyset/>
  </apply>
  

4.4.12.12.3 Default Rendering

4.4.12.13.1 Discussion

pi represents the mathematical constant which is the ratio of a circle's circumference to its diameter, approximately 3.141592653.

4.4.12.13.2 Example

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

4.4.12.13.3 Default Rendering

4.4.12.14.1 Discussion

eulergamma represents Euler's constant, approximately 0.5772156649

4.4.12.14.2 Example

  <eulergamma/>

4.4.12.14.3 Default Rendering

4.4.12.15.1 Discussion

infinity represents the concept of infinity. Proper interpretation depends on context.

4.4.12.15.2 Example

  <infinity/>

4.4.12.15.3 Default Rendering