The purpose of Content Markup is to provide an explicit encoding of
the underlying mathematical meaning of an expression, rather
than any particular notation for the expression. Mathematical notation
is at times ambiguous, context-dependent, and varies from community to
community. In many cases, it is preferable to work directly with the
underlying, formal, mathematical objects. Content Markup provides a
rigorous, extensible semantic framework and a markup language for this
purpose.
By encoding the underlying mathematical structure explicitly,
without regard to how it is presented, it is possible to interchange
information more precisely between systems that semantically process
mathematical objects. Important application areas include computer
algebra systems, automatic reasoning systems, industrial and scientific
applications, multi-lingual translation systems, mathematical search,
automated scoring of online assessments, and interactive textbooks.
This chapter presents an overview of basic
concepts used to define Content Markup, describes a
core collection of elements that comprise Strict Content Markup, and
defines a full collection of elements
to support common mathematical idioms. Strict Content Markup encodes general
expression trees in a semantically rigorous way, while the full set of
Content MathML elements provides backward-compatibility with previous
versions of Content Markup. The correspondence between full Content Markup
and Strict Content Markup is defined in F. The Strict Content MathML Transformation, which
details an algorithm to translate arbitrary Content Markup into Strict
Content Markup.
Content MathML represents mathematical objects as expression
trees. In general, an expression tree is constructed by applying
an operator to a sequence of sub-expressions. For example, the sum
x+y
can be constructed
as the application of the addition operator to two arguments
x and y, and the expression
cos(π)
as the application of the cosine function to the
number π.
The terminal nodes in an expression tree represent basic mathematical
objects such as numbers, variables, arithmetic operations, and so on.
The internal nodes in the tree represent function application or other
mathematical constructions that build up compound objects.
MathML defines a relatively small number of commonplace mathematical
constructs, chosen to be sufficient in a wide range of applications.
In addition, it provides a mechanism to refer to concepts outside of
the collection it defines, allowing them to be represented as well.
The defined set of content elements is designed to be adequate for
simple coding of formulas typically used from kindergarten through the
first two years of college in the United States, that is, up to A-Level
or Baccalaureate level in Europe.
The primary role of the MathML content element set is to encode the
mathematical structure of an expression independent of the notation used
to present it. However, rendering issues cannot be ignored. There are
many different approaches to render Content MathML formulae, ranging
from native implementations of the MathML elements, to declarative notation
definitions, to XSLT style sheets. Because rendering requirements for
Content MathML vary widely, MathML does not provide a normative rendering
specification. Instead, typical renderings are suggested by way of
examples given using presentation markup.
The basic building blocks of Content MathML expressions are
numbers, identifiers, and symbols.
These building blocks are combined using function application
and binding operators.
In the expression
,
the numeral
represents a number with a fixed value. Content MathML uses the
cn
element to represent numerical quantities. The identifier
is a mathematical variable, that is, an identifier
that represents a quantity with no predetermined value. Content MathML
uses the
ci
element to represent variable identifiers.
The plus sign is an identifier that represents a fixed, externally
defined object, namely, the addition function. Such an identifier is
called a symbol, to distinguish it from a variable. Common
elementary functions and operators are all symbols in this sense.
Content MathML uses the
csymbol
element to represent symbols.
The fundamental way to combine numbers, variables, and symbols
is function application. Content MathML distinguishes between the
function itself (which may be a symbol such as the sine function,
a variable such as f, or some other expression)
and the result of applying the function to its arguments. The
apply
element groups the function with its arguments syntactically, and
represents the expression that results from applying the function
to its arguments.
In an expression, variables may be described as bound or
free variables. Bound variables have a special role within
the scope of a binding expression, and may be renamed consistently
within that scope without changing the meaning of the expression.
Free variables are those that are not bound within an expression.
Content MathML differentiates between the application of a function
to a free variable (e.g. f(x))
and an operation that binds a variable within a binding scope. The
bind
element is used to delineate the binding scope of a bound variable
and to group the binding operator with its bound variables, which
are supplied using the
bvar
element.
In Strict Content markup, the only way to perform variable binding
is to use the bind element. In non-Strict
Content markup, other markup elements are provided that more closely
resemble well-known idiomatic notations, such as limit
-style
notations for sums and integrals. These constructs may implicitly
bind variables, such as the variable of integration, or the index variable
in a sum. MathML uses the term qualifier element to refer to
those elements used to represent the auxiliary data required by these
constructs.
Expressions involving qualifiers follow one of a small number of
idiomatic patterns, each of which applies to a class of similar binding
operators. For example, sums and products are in the same class
because they use index variables following the same pattern. The
Content MathML operator classes are described in detail in
4.3.4 Operator Classes.
Beginning in MathML 3, Strict Content MathML is defined as a
minimal subset of Content MathML that is sufficient to represent the meaning
of mathematical expressions using a uniform structure. The full Content
MathML element set retains backward compatibility with MathML 2, and strikes
a pragmatic balance between verbosity and formality.
Content MathML provides a considerable number of predefined functions
encoded as empty elements (e.g. sin,
log, etc.) and a variety of constructs for
forming compound objects (e.g. set,
interval, etc.). In contrast, Strict
Content MathML represents all known functions using a single element
(csymbol) with an attribute that points
to its definition in an extensible content dictionary, and uses only
apply and bind
elements to build up compound expressions. Token elements such as
cn and ci are
considered part of Strict Content MathML, but with a more restricted set
of attributes and with content restricted to text.
The formal semantics of Content MathML expressions are given by
specifying equivalent Strict Content MathML expressions, which all
have formal semantics defined in terms of content dictionaries.
The exact correspondence between each non-Strict Content MathML
structure and its Strict Content MathML equivalent is described
in terms of rewrite rules that are used as part of the transformation
algorithm given in F. The Strict Content MathML Transformation.
The algorithm described in F. The Strict Content MathML Transformation is complete in the
sense that it gives every Content MathML expression a specific meaning in
terms of a Strict Content MathML expression. In some cases, it gives a
specific strict interpretation to an expression whose meaning was not
sufficiently specified in MathML 2. The goal of this algorithm is to
be faithful to natural mathematical intuitions, however, some edge cases
may remain where the specific interpretation given by the algorithm may
be inconsistent with earlier expectations.
A conformant MathML processor need not implement this algorithm. The
existence of these transformation rules does not imply that a system must
treat equivalent expressions identically. In particular, systems may give
different presentation renderings for expressions that the transformation
rules imply are mathematically equivalent. In general, Content MathML
does not define any expectations for the computational behavior of the
expressions it encodes, including, but not limited to, the equivalence
of any specific expressions.
Strict Content MathML is designed to be compatible with OpenMath,
a standard for representing formal mathematical objects and semantics.
Strict Content MathML is an XML encoding of OpenMath Objects in the
sense of [OpenMath]. The following table gives the correspondence
between Strict Content MathML elements and their OpenMath equivalents.
Any method to formalize the meaning of mathematical expressions
must be extensible, that is, it must provide the ability to define
new functions and symbols to expand the domain of discourse. Content
MathML uses the
csymbol
element to represent new symbols, and uses Content Dictionaries
to describe their mathematical semantics. The association between a symbol
and its semantic description is accomplished using the attributes of the
csymbol element to point to the definition
of the symbol in a Content Dictionary.
The correspondence between operator elements in Content MathML and
symbol definitions in Content Dictionaries is given in
E.3 The Content MathML Operators. These definitions for predefined
MathML operator symbols refer to Content Dictionaries developed by the
OpenMath Society [OpenMath] in conjunction with the W3C Math Working
Group. It is important to note that this information is informative, not
normative. In general, the precise mathematical semantics of predefined
symbols are not fully specified by the MathML Recommendation, and the only
normative statements about symbol semantics are those present in the text
of this chapter. The semantic definitions provided by the OpenMath Content
Dictionaries are intended to be sufficient for most applications, and are
generally compatible with the semantics specified for analogous constructs
in this Recommendation. However, in contexts where highly precise semantics
are required (e.g. communication between computer algebra systems, within
formal systems such as theorem provers, etc.) it is the responsibility of
the relevant community of practice to verify, extend or replace definitions
provided by OpenMath Content Dictionaries as appropriate.
In this section we will present the elements for encoding the structure of content
MathML expressions. These elements are the only ones used for the Strict Content MathML
encoding. Concretely, we have
Full Content MathML allows further elements presented in
4.3 Content MathML for Specific Structures and 4.3 Content MathML for Specific Structures, and allows a richer
content model presented in this section. Differences in Strict and non-Strict
usage of are highlighted in the sections discussing each of the Strict element below.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Cn |
Cn |
| Attributes |
CommonAtt, type |
CommonAtt, DefEncAtt, type?, base? |
type Attribute Values |
integer |
real |
double |
hexdouble
|
|
integer |
real |
double |
hexdouble |
e-notation |
rational |
complex-cartesian |
complex-polar |
constant | text
|
default is real |
base Attribute Values |
|
integer
|
default is 10 |
| Content |
text |
(text | mglyph | sep | PresentationExpression)* |
The cn element is the Content MathML element used to
represent numbers. Strict Content MathML supports integers, real numbers,
and double precision floating point numbers. In these types of numbers,
the content of cn is text. Additionally, cn
supports rational numbers and complex numbers in which the different
parts are separated by use of the sep element. Constructs
using sep may be rewritten in Strict Content MathML as
constructs using apply as described below.
The type attribute specifies which kind of number is
represented in the cn element. The default value is
real. Each type implies that the content be of
a certain form, as detailed below.
The default rendering of the text content of cn is the same as that of the Presentation element mn, with suggested variants in the
case of attributes or sep being used, as listed below.
In Strict Content MathML, the type attribute is mandatory, and may only take the values
integer, real, hexdouble or
double:
- integer
-
An integer is represented by an optional sign followed by a string of
one or more decimal digits
.
- real
-
A real number is presented in radix notation. Radix notation consists of an
optional sign (+
or -
) followed by a string of
digits possibly separated into an integer and a fractional part by a
decimal point. Some examples are 0.3, 1, and -31.56.
- double
-
This type is used to mark up those double-precision
floating point numbers that can be represented in the IEEE 754
standard format [IEEE754]. This includes a subset of the (mathematical) real
numbers, negative zero, positive and negative real infinity
and a set of not a number
values. The lexical rules for
interpreting the text content of a cn as an IEEE
double are specified by Section
3.1.2.5 of XML Schema Part 2: Datatypes Second Edition
[XMLSchemaDatatypes]. For example, -1E4, 1267.43233E12, 12.78e-2,
12, -0, 0 and INF are all valid doubles in this format.
- hexdouble
-
This type is used to directly represent the 64 bits of an
IEEE 754 double-precision floating point number as a 16 digit
hexadecimal number. Thus the number represents mantissa, exponent, and sign
from lowest to highest bits using a least significant byte ordering.
This consists of a string of 16 digits 0-9, A-F.
The following example
represents a NaN value. Note that certain IEEE doubles, such as the
NaN in the example, cannot be represented in the lexical format for
the double type.
<cn type="hexdouble">7F800000</cn>
Sample Presentation
The base attribute is used to specify how the content is
to be parsed. The attribute value is a base 10 positive integer
giving the value of base in which the text content of the cn
is to be interpreted. The base attribute should only be
used on elements with type integer or
real. Its use on cn elements of other type
is deprecated. The default value for base is
10.
Additional values for the type attribute element for supporting
e-notations for real numbers, rational numbers, complex numbers and selected important
constants. As with the integer, real,
double and hexdouble types, each of these types
implies that the content be of a certain form. If the type attribute is
omitted, it defaults to real.
- integer
-
Integers can be represented with respect to a base different from
10: If base is present, it specifies (in base 10) the base for the digit encoding.
Thus base='16' specifies a hexadecimal
encoding. When base > 10, Latin letters (A-Z, a-z) are used in
alphabetical order as digits. The case of letters used as digits is not
significant. The following example encodes the base 10 number 32736.
Sample Presentation
<msub><mn>7FE0</mn><mn>16</mn></msub>
When base > 36, some integers cannot be represented using
numbers and letters alone. For example, while
arguably represents the number written in base 10 as 1,000,015, the number
written in base 10 as 1,000,037 cannot be represented using letters and
numbers alone when base is 1000. Consequently, support
for additional characters (if any) that may be used for digits when base > 36 is application specific.
- real
-
Real numbers can be represented with respect to a base
different than 10. If a base attribute is present, then the digits are
interpreted as being digits computed relative to that base (in the same way as
described for type integer).
- e-notation
-
A real number may be presented in scientific notation using this type. Such
numbers have two parts (a significand and an exponent)
separated by a <sep/> element. The
first part is a real number, while the
second part is an integer exponent indicating a power of the base.
For example, <cn type="e-notation">12.3<sep/>5</cn>
represents . The default presentation of this example is
12.3e5. Note that this type is primarily useful for backwards compatibility with
MathML 2, and in most cases, it is preferable to use the double
type, if the number to be represented is in the range of IEEE doubles:
- rational
-
A rational number is given as two integers to be used as the numerator and
denominator of a quotient. The numerator and denominator are
separated by <sep/>.
<cn type="rational">22<sep/>7</cn>
Sample Presentation
<mrow><mn>22</mn><mo>/</mo><mn>7</mn></mrow>
- complex-cartesian
-
A complex cartesian number is given as two numbers specifying the real and
imaginary parts. The real and imaginary parts are separated
by the <sep/> element, and each part has
the format of a real number as described above.
<cn type="complex-cartesian"> 12.3 <sep/> 5 </cn>
Sample Presentation
<mrow>
<mn>12.3</mn><mo>+</mo><mn>5</mn><mo>⁢</mo><mi>i</mi>
</mrow>
- complex-polar
-
A complex polar number is given as two numbers specifying
the magnitude and angle. The magnitude and angle are separated
by the <sep/> element, and each part has
the format of a real number as described above.
<cn type="complex-polar"> 2 <sep/> 3.1415 </cn>
Sample Presentation
<mrow>
<mn>2</mn>
<mo>⁢</mo>
<msup>
<mi>e</mi>
<mrow><mi>i</mi><mo>⁢</mo><mn>3.1415</mn></mrow>
</msup>
</mrow>
<mrow>
<mi>Polar</mi>
<mo>⁡</mo>
<mrow><mo>(</mo><mn>2</mn><mo>,</mo><mn>3.1415</mn><mo>)</mo></mrow>
</mrow>
- constant
-
If the value type is constant,
then the content should be a Unicode representation of a
well-known constant. Some important constants and their
common Unicode representations are listed below.
This cn type is primarily for backward
compatibility with MathML 1.0. MathML 2.0 introduced many
empty elements, such as <pi/> to
represent constants, and using these representations or
a Strict csymbol representation is preferred.
In addition to the additional values of the type attribute, the
content of cn element can contain (in addition to the
sep element allowed in Strict Content MathML) mglyph
elements to refer to characters not currently available in Unicode, or
a general presentation construct (see 3.1.8 Summary of Presentation Elements),
which is used for rendering (see 4.1.2 Content Expressions).
If a base attribute is present, it specifies the base used for the digit
encoding of both integers. The use of base with
rational numbers is deprecated.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Ci |
Ci |
| Attributes |
CommonAtt, type? |
CommonAtt, DefEncAtt, type? |
type Attribute Values |
integer|
rational|
real|
complex|
complex-polar|
complex-cartesian|
constant|
function|
vector|
list|
set|
matrix
|
string |
| Qualifiers |
|
BvarQ,
DomainQ,
degree,
momentabout,
logbase
|
| Content |
text |
text | mglyph | PresentationExpression |
Content MathML uses the ci element (mnemonic for content
identifier
) to construct a variable. Content identifiers
represent mathematical variables
which have
properties, but no fixed value. For example, x and y are variables
in the expression x+y
, and the variable
x would be represented as
In MathML, variables are distinguished from symbols, which have fixed, external
definitions, and are represented by the csymbol element.
After white space normalization the content of a ci element is interpreted as a
name that identifies it. Two variables are considered equal, if and only if their
names
are identical and in the same scope (see 4.2.6 Bindings and Bound Variables <bind>
and <bvar> for a
discussion).
The ci element uses the type attribute to specify the basic type of
object that it represents. In Strict Content MathML, the set of permissible values
is
integer, rational, real,
complex, complex-polar,
complex-cartesian, constant, function,
vector, list, set, and matrix. These values correspond
to the symbols
integer_type,
rational_type,
real_type,
complex_polar_type,
complex_cartesian_type,
constant_type,
fn_type,
vector_type,
list_type,
set_type, and
matrix_type in the
mathmltypes Content Dictionary: In this sense the following two expressions are considered equivalent:
<ci type="integer">n</ci>
<semantics>
<ci>n</ci>
<annotation-xml cd="mathmltypes" name="type" encoding="MathML-Content">
<csymbol cd="mathmltypes">integer_type</csymbol>
</annotation-xml>
</semantics>
Note that complex should be considered
an alias for complex-cartesian and rewritten to the
same complex_cartesian_type
symbol. It is perhaps a more natural type name for use with
ci as the distinction between cartesian and polar form really
only affects the interpretation of literals encoded with cn.
The ci element allows any string value for the type
attribute, in particular any of the names of the MathML container elements 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. See [MathML-Types] for more examples.
If the content of a ci element consists of Presentation MathML, that
presentation is used. If no such tagging is supplied then the text
content is rendered as if it were the content of an mi element. If an
application supports bidirectional text rendering, then the rendering follows the
Unicode bidirectional rendering.
The type attribute can be interpreted to
provide rendering information. For example in
a renderer could display a bold V for the vector.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Csymbol |
Csymbol |
| Attributes |
CommonAtt, cd |
CommonAtt, DefEncAtt, type?, cd? |
| Content |
SymbolName |
text | mglyph | PresentationExpression |
| Qualifiers |
|
BvarQ, DomainQ, degree, momentabout, logbase |
A csymbol is used to refer to a specific,
mathematically-defined concept with an external definition. In the
expression x+y
, the plus sign is
a symbol since it has a specific, external definition, namely the addition function.
MathML 3 calls such an identifier a
symbol. Elementary functions and common mathematical
operators are all examples of symbols. Note that the term
symbol
is used here in an abstract sense and has no
connection with any particular presentation of the construct on screen
or paper.
The csymbol identifies the specific mathematical concept
it represents by referencing its definition via attributes.
Conceptually, a reference to an external definition is merely a URI,
i.e. a label uniquely identifying the definition. However, to be
useful for communication between user agents, external definitions
must be shared.
For this reason, several longstanding efforts have
been organized to develop systematic, public repositories of
mathematical definitions. Most notable of these, the OpenMath Society
repository of Content Dictionaries (CDs) is extensive, open and
active. In MathML 3, OpenMath CDs are the preferred source of external
definitions. In particular, the definitions of pre-defined MathML 3
operators and functions are given in terms of OpenMath CDs.
MathML 3 provides two mechanisms for referencing external definitions or content
dictionaries. The first, using the cd attribute, follows conventions
established by OpenMath specifically for referencing CDs. This is the
form required in Strict Content MathML. The second, using the
definitionURL attribute, is backward compatible with MathML 2, and can be used
to reference CDs or any other source of definitions that can be
identified by a URI. It is described in the following section.
When referencing OpenMath CDs, the preferred method is to use the cd
attribute as follows. Abstractly, OpenMath symbol definitions are identified by a
triple
of values: a symbol name, a CD name, and a CD base,
which is a URI that disambiguates CDs of the same name. To associate such a triple
with a
csymbol, the content of the csymbol specifies the symbol name, and the
name of the Content Dictionary is given using the cd attribute. The CD base is
determined either from the document embedding the math element which contains the
csymbol by a mechanism given by the embedding document format, or by system
defaults, or by the cdgroup attribute, which is optionally specified on the
enclosing math element; see 2.2.1 Attributes. In the absence
of specific information http://www.openmath.org/cd is assumed as the CD base
for all csymbol elements annotation, and annotation-xml. This
is the CD base for the collection of standard CDs maintained by the OpenMath Society.
The cdgroup specifies a URL to an OpenMath CD Group file. For a detailed
description of the format of a CD Group file, see Section 4.4.2 (CDGroups)
in [OpenMath]. Conceptually, a CD group file is a list of
pairs consisting of a CD name, and a corresponding CD base. When a csymbol
references a CD name using the cd attribute, the name is looked up in the CD
Group file, and the associated CD base value is used for that csymbol. When a CD
Group file is specified, but a referenced CD name does not appear in the group file,
or
there is an error in retrieving the group file, the referencing csymbol is not
defined. However, the handling of the resulting error is not defined, and is the
responsibility of the user agent.
While references to external definitions are URIs, it is strongly recommended that
CD
files be retrievable at the location obtained by interpreting the URI as a URL. In
particular, other properties of the symbol being defined may be available by inspecting
the Content Dictionary specified. These include not only the symbol definition, but
also
examples and other formal properties. Note, however, that there are multiple encodings
for OpenMath Content Dictionaries, and it is up to the user agent to correctly determine
the encoding when retrieving a CD.
In addition to the forms described above, the csymbol and element can contain
mglyph elements to refer to characters not currently available in Unicode, or a
general presentation construct (see 3.1.8 Summary of Presentation Elements), which is used for
rendering (see 4.1.2 Content Expressions). In this case, when
writing to Strict Content MathML, the csymbol should be treated as a
ci element, and rewritten using Rewrite: ci presentation mathml.
External definitions (in OpenMath CDs or elsewhere) may also be specified directly
for
a csymbol using the definitionURL attribute. When used to reference
OpenMath symbol definitions, the abstract triple of (symbol name, CD name, CD base)
is
mapped to a fully-qualified URI as follows:
URI = cdbase + '/' + cd-name + '#' + symbol-name
For example,
is mapped to
The resulting URI is specified as the value of the definitionURL attribute.
This form of reference is useful for backwards compatibility with MathML2 and to
facilitate the use of Content MathML within URI-based frameworks (such as RDF [RDF] in the Semantic Web or OMDoc [OMDoc1.2]). Another benefit is
that the symbol name in the CD does not need to correspond to the content of the
csymbol element. However, in general, this method results in much longer MathML
instances. Also, in situations where CDs are under development, the use of a CD Group
file allows the locations of CDs to change without a change to the markup. A third
drawback to definitionURL is that unlike the cd attribute, it is not
limited to referencing symbol definitions in OpenMath content dictionaries. Hence,
it is
not in general possible for a user agent to automatically determine the proper
interpretation for definitionURL values without further information about the
context and community of practice in which the MathML instance occurs.
Both the cd and definitionURL mechanisms of external reference
may be used within a single MathML instance. However, when both a cd and a
definitionURL attribute are specified on a single csymbol, the
cd attribute takes precedence.
If the content of a csymbol element is tagged using presentation tags,
that presentation is used. If no such tagging is supplied then the text
content is rendered as if it were the content of an mi element. In
particular if an application supports bidirectional text rendering, then the
rendering follows the Unicode bidirectional rendering.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Cs |
Cs |
| Attributes |
CommonAtt |
CommonAtt, DefEncAtt |
| Content |
text |
text |
The cs element encodes string literals
which may be used in Content MathML expressions.
The content of cs is text; no
Presentation MathML constructs are allowed even when used in
non-strict markup. Specifically, cs may not contain
mglyph elements, and the content does not undergo white space
normalization.
Content MathML
<set>
<cs>A</cs><cs>B</cs><cs> </cs>
</set>
Sample Presentation
<mrow>
<mo>{</mo>
<ms>A</ms>
<mo>,</mo>
<ms>B</ms>
<mo>,</mo>
<ms>  </ms>
<mo>}</mo>
</mrow>
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Apply |
Apply |
| Attributes |
CommonAtt |
CommonAtt, DefEncAtt |
| Content |
ContExp+ |
ContExp+
|
(ContExp,
BvarQ,
Qualifier?,
ContExp*) |
The most fundamental way of building a compound object in
mathematics is by applying a function or an operator to some
arguments.
In MathML, the apply element is used to build an expression tree that
represents the application of a function or operator to its arguments. The
resulting tree corresponds to a complete mathematical expression. Roughly
speaking, this means a piece of mathematics that could be surrounded by
parentheses or logical brackets
without changing its meaning.
For example, (x + y) might be encoded as
<apply><csymbol cd="arith1">plus</csymbol><ci>x</ci><ci>y</ci></apply>
The opening and closing tags of apply specify exactly the scope of any
operator or function. The most typical way of using apply is simple and
recursive. Symbolically, the content model can be described as:
<apply> op [ a b ...] </apply>
where the operands a, b, ... are MathML
expression trees themselves, and op is a MathML expression tree that
represents an operator or function. Note that apply constructs can be
nested to arbitrary depth.
An apply may in principle have any number of operands. For example,
(x + y + z) can be encoded as
<apply><csymbol cd="arith1">plus</csymbol>
<ci>x</ci>
<ci>y</ci>
<ci>z</ci>
</apply>
Note that MathML also allows applications without operands, e.g. to represent functions
like random(), or current-date().
Mathematical expressions involving a mixture of operations result in nested
occurrences of apply. For example, a x + b
would be encoded as
<apply><csymbol cd="arith1">plus</csymbol>
<apply><csymbol cd="arith1">times</csymbol>
<ci>a</ci>
<ci>x</ci>
</apply>
<ci>b</ci>
</apply>
There is no need to introduce parentheses or to resort to
operator precedence in order to parse expressions correctly. The
apply tags provide the proper grouping for the re-use
of the expressions within other constructs. Any expression
enclosed by an apply element is well-defined, coherent
object whose interpretation does not depend on the surrounding
context. This is in sharp contrast to presentation markup,
where the same expression may have very different meanings in
different contexts. For example, an expression with a visual
rendering such as (F+G)(x)
might be a product, as in
<apply><csymbol cd="arith1">times</csymbol>
<apply><csymbol cd="arith1">plus</csymbol>
<ci>F</ci>
<ci>G</ci>
</apply>
<ci>x</ci>
</apply>
or it might indicate the application of the function F + G to
the argument x. This is indicated by constructing the sum
<apply><csymbol cd="arith1">plus</csymbol><ci>F</ci><ci>G</ci></apply>
and applying it to the argument x as in
<apply>
<apply><csymbol cd="arith1">plus</csymbol>
<ci>F</ci>
<ci>G</ci>
</apply>
<ci>x</ci>
</apply>
In both cases, the interpretation of the outer apply is
explicit and unambiguous, and does not change regardless of
where the expression is used.
The preceding example also illustrates that in an
apply construct, both the function and the arguments
may be simple identifiers or more complicated expressions.
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 in order to be properly
formed.
Strict Content MathML applications are rendered as mathematical
function applications. If
<mi>F</mi> denotes the rendering of
<ci>f</ci> and
<mi>Ai</mi>
the rendering of
<ci>ai</ci>, the sample
rendering of a simple application is as follows:
Content MathML
<apply><ci>f</ci>
<ci>a1</ci>
<ci>a2</ci>
<ci>...</ci>
<ci>an</ci>
</apply>
Sample Presentation
<mrow>
<mi>F</mi>
<mo>⁡</mo>
<mrow>
<mo fence="true">(</mo>
<mi>A1</mi>
<mo separator="true">,</mo>
<mi>...</mi>
<mo separator="true">,</mo>
<mi>A2</mi>
<mo separator="true">,</mo>
<mi>An</mi>
<mo fence="true">)</mo>
</mrow>
</mrow>
Non-Strict MathML applications may also be used with qualifiers. In the absence of
any more specific rendering rules for well-known operators, rendering
should follow the sample presentation below, motivated by the typical
presentation for sum. Let
<mi>Op</mi> denote the rendering of
<ci>op</ci>,
<mi>X</mi>
the rendering of
<ci>x</ci>, and so on. Then:
Content MathML
<apply><ci>op</ci>
<bvar><ci>x</ci></bvar>
<domainofapplication><ci>d</ci></domainofapplication>
<ci>expression-in-x</ci>
</apply>
Sample Presentation
<mrow>
<munder>
<mi>Op</mi>
<mrow><mi>X</mi><mo>∈</mo><mi>D</mi></mrow>
</munder>
<mo>⁡</mo>
<mrow>
<mo fence="true">(</mo>
<mi>Expression-in-X</mi>
<mo fence="true">)</mo>
</mrow>
</mrow>
Many complex mathematical expressions are constructed with the use of bound
variables, and bound variables are an important concept of logic and formal
languages. Variables become bound in the scope of an expression through
the use of a quantifier. Informally, they can be thought of as the dummy variables
in expressions such as integrals, sums, products, and the logical quantifiers for
all
and there exists
. A bound variable is characterized by the property that
systematically renaming the variable (to a name not already appearing in the
expression) does not change the meaning of the expression.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Bind |
Bind |
| Attributes |
CommonAtt |
CommonAtt, DefEncAtt |
| Content |
ContExp,
BvarQ*,
ContExp
|
ContExp,
BvarQ*,
Qualifier*,
ContExp+
|
Binding expressions are represented as MathML expression trees using the bind
element. Its first child is a MathML expression that represents a binding operator,
for
example integral operator. This is followed by a non-empty list of bvar
elements denoting the bound variables, and then the final child which is a general
Content MathML expression, known as the body of the binding.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
BVar |
BVar |
| Attributes |
CommonAtt |
CommonAtt, DefEncAtt |
| Content |
ci | semantics-ci |
(ci | semantics-ci), degree? |
degree?, (ci | semantics-ci)
|
The bvar element is used to denote the bound variable of a binding
expression, e.g. in sums, products, and quantifiers or user defined functions.
The content of a bvar element is an annotated variable,
i.e. either a content identifier represented by a ci element or a
semantics element whose first child is an annotated variable. The
name of an annotated variable of the second kind is the name of its first
child. The name of a bound variable is that of the annotated variable
in the bvar element.
Bound variables are identified by comparing their names. Such
identification can be made explicit by placing an id on the ci
element in the bvar element and referring to it using the xref
attribute on all other instances. An example of this approach is
<bind><csymbol cd="quant1">forall</csymbol>
<bvar><ci id="var-x">x</ci></bvar>
<apply><csymbol cd="relation1">lt</csymbol>
<ci xref="var-x">x</ci>
<cn>1</cn>
</apply>
</bind>
This id based approach is especially helpful when constructions
involving bound variables are nested.
It is sometimes necessary to associate additional
information with a bound variable. 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 the ci
and the additional information. Recognition of an 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 following example encodes
.
<bind><csymbol cd="quant1">forall</csymbol>
<bvar><ci>x</ci></bvar>
<apply><csymbol cd="relation1">eq</csymbol>
<apply><csymbol cd="arith1">plus</csymbol><ci>x</ci><ci>y</ci></apply>
<apply><csymbol cd="arith1">plus</csymbol><ci>y</ci><ci>x</ci></apply>
</apply>
</bind>
In non-Strict Content markup, the bvar element is used in
a number of idiomatic constructs. These are described in 4.3.3 Qualifiers and 4.3 Content MathML for Specific Structures.
It is a defining property of bound variables that they can be renamed
consistently in the scope of their parent bind element.
This operation, sometimes known as α-conversion,
preserves the semantics of the expression.
A bound variable
may be renamed to say
so long as
does not occur free in the body of the binding, or in any annotations of
the bound variable,
to be renamed, or later bound variables.
If a bound variable
is renamed, all free occurrences of
in annotations in its bvar element,
any following bvar children of the bind
and in the expression in the body of the bind should be renamed.
In the example in the previous section, note how renaming
to
produces the equivalent expression
,
whereas
may not be renamed to
, as
is free in the body of the binding and would be
captured, producing the expression
which is not equivalent to the original expression.
If
<ci>b</ci> and
<ci>s</ci> are Content MathML expressions
that render as the Presentation MathML expressions
<mi>B</mi> and
<mi>S</mi>
then the sample rendering of a binding element is as follows:
Content MathML
<bind><ci>b</ci>
<bvar><ci>x1</ci></bvar>
<bvar><ci>...</ci></bvar>
<bvar><ci>xn</ci></bvar>
<ci>s</ci>
</bind>
Sample Presentation
<mrow>
<mi>B</mi>
<mrow>
<mi>x1</mi>
<mo separator="true">,</mo>
<mi>...</mi>
<mo separator="true">,</mo>
<mi>xn</mi>
</mrow>
<mo separator="true">.</mo>
<mi>S</mi>
</mrow>
To conserve space in the XML encoding, MathML expression trees can make use of
structure sharing.
|
Schema Fragment |
| Class |
Share |
| Attributes |
CommonAtt,
src
|
src Attribute Values |
URI |
| Content |
Empty |
The share element has an src attribute used to
reference a MathML expression tree. The value of the
src attribute is a URI specifying the id
attribute of the root node of the expression tree. When building a
MathML expression tree, the share element is equivalent to a copy of the MathML
expression tree referenced by the src attribute. Note that this copy is
structurally equal, but not identical to the element referenced. The
values of the share will often be relative URI references, in which case they
are resolved using the base URI of the document containing the share element.
For instance, the mathematical object f(f(f(a,a),f(a,a)),f(f(a,a),f(a,a))) can
be encoded as either one of the following representations (and some intermediate versions
as well).
<apply><ci>f</ci>
<apply><ci>f</ci>
<apply><ci>f</ci>
<ci>a</ci>
<ci>a</ci>
</apply>
<apply><ci>f</ci>
<ci>a</ci>
<ci>a</ci>
</apply>
</apply>
<apply><ci>f</ci>
<apply><ci>f</ci>
<ci>a</ci>
<ci>a</ci>
</apply>
<apply><ci>f</ci>
<ci>a</ci>
<ci>a</ci>
</apply>
</apply>
</apply>
|
<apply><ci>f</ci>
<apply id="t1"><ci>f</ci>
<apply id="t11"><ci>f</ci>
<ci>a</ci>
<ci>a</ci>
</apply>
<share src="#t11"/>
</apply>
<share src="#t1"/>
</apply>
|
Say that an element dominates all its children and all
elements they dominate. Say also that a
share element dominates its target, i.e. the element that carries the
id attribute pointed to by the src attribute. For instance in the
representation on the right above, the apply element with id="t1" and also the
second share (with src="t11") both dominate the
apply element with id="t11".
The occurrences of the share element must obey the following global
acyclicity constraint: An element may not dominate itself. For example, the
following representation violates this constraint:
<apply id="badid1"><csymbol cd="arith1">divide</csymbol>
<cn>1</cn>
<apply><csymbol cd="arith1">plus</csymbol>
<cn>1</cn>
<share src="#badid1"/>
</apply>
</apply>
Here, the apply element with id="badid1" dominates its third child,
which dominates the share element, which dominates its target: the element with
id="badid1". So by transitivity, this element dominates itself. By the
acyclicity constraint, the example is not a valid MathML expression tree. It
might be argued that such an expression could be given the interpretation of the continued
fraction
.
However, the procedure of building an expression tree by replacing
share element does not terminate for such an
expression, and hence such expressions are not allowed by Content MathML.
Note that the acyclicity constraint is not restricted to such simple cases, as the
following
example shows:
<apply id="bar"> <apply id="baz">
<csymbol cd="arith1">plus</csymbol> <csymbol cd="arith1">plus</csymbol>
<cn>1</cn> <cn>1</cn>
<share src="#baz"/> <share src="#bar"/>
</apply> </apply>
Here, the apply with id="bar" dominates its third child, the
share with src="#baz". That element dominates its target apply
(with id="baz"), which in turn dominates its third child, the share
with src="#bar". Finally, the share with
src="#bar" dominates its target, the original
apply element with id="bar". So this pair of representations
ultimately violates the acyclicity constraint.
Note that the share element is a syntactic referencing mechanism:
a share element stands for the exact element it points to. In particular,
referencing does not interact with binding in a semantically intuitive way, since
it
allows a phenomenon called variable capture to
occur. Consider an example:
<bind id="outer"><csymbol cd="fns1">lambda</csymbol>
<bvar><ci>x</ci></bvar>
<apply><ci>f</ci>
<bind id="inner"><csymbol cd="fns1">lambda</csymbol>
<bvar><ci>x</ci></bvar>
<share id="copy" src="#orig"/>
</bind>
<apply id="orig"><ci>g</ci><ci>x</ci></apply>
</apply>
</bind>
This represents a term
which has two sub-terms of the form
,
one with id="orig"
(the one explicitly represented) and one with id="copy",
represented by the share element.
In the original, explicitly-represented term,
the variable is bound by the
outer bind element.
However, in the copy, the variable is
bound by the inner bind element.
One says that the inner bind
has captured the variable .
Using references that capture variables in this way can easily lead to representation
errors, and is not recommended. For instance, using
α-conversion to rename the inner occurrence of
into, say, leads to the semantically equivalent expression
.
However, in this form, it is no longer possible to share the expression
.
Replacing with in the inner
bvar without replacing the share element results in a change
in semantics.
There are several acceptable renderings for the share element. These include rendering the element
as a hypertext link to the referenced element and using the rendering of the element
referenced by the
src attribute.
Content elements can be annotated with additional information via the
semantics element. MathML uses the
semantics element to wrap the annotated element and the
annotation-xml and annotation elements used for representing the
annotations themselves. The use of the semantics, annotation and
annotation-xml is described in detail in 6. Annotating MathML: semantics.
The semantics element is considered part of both
presentation MathML and Content MathML. MathML considers a semantics element
(strict) Content MathML, if and only if its first child is (strict) Content MathML.
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Error |
Error |
| Attributes |
CommonAtt |
CommonAtt, DefEncAtt |
| Content |
csymbol, ContExp*
|
csymbol, ContExp*
|
A content error expression is made up of a csymbol
followed by a sequence of zero or more MathML expressions. The
initial expression must be a csymbol indicating the kind of
error. Subsequent children, if present, indicate the context in
which the error occurred.
The cerror element has no direct mathematical meaning.
Errors occur as the result of some action performed on an expression
tree and are thus of real interest only when some sort of
communication is taking place. Errors may occur inside other objects
and also inside other errors.
As an example, to encode a division by zero error, one might
employ a hypothetical aritherror Content Dictionary
containing a DivisionByZero symbol, as in the following
expression:
<cerror>
<csymbol cd="aritherror">DivisionByZero</csymbol>
<apply><csymbol cd="arith1">divide</csymbol><ci>x</ci><cn>0</cn></apply>
</cerror>
Note that error markup generally should enclose only the smallest
erroneous sub-expression. Thus a cerror will often be a sub-expression of
a bigger one, e.g.
<apply><csymbol cd="relation1">eq</csymbol>
<cerror>
<csymbol cd="aritherror">DivisionByZero</csymbol>
<apply><csymbol cd="arith1">divide</csymbol><ci>x</ci><cn>0</cn></apply>
</cerror>
<cn>0</cn>
</apply>
The default presentation of a cerror element is an
merror expression whose first child is a presentation of the
error symbol, and whose subsequent children are the default
presentations of the remaining children of the cerror. In
particular, if one of the remaining children of the cerror is
a presentation MathML expression, it is used literally in the
corresponding merror.
<cerror>
<csymbol cd="aritherror">DivisionByZero</csymbol>
<apply><csymbol cd="arith1">divide</csymbol><ci>x</ci><cn>0</cn></apply>
</cerror>
Sample Presentation
<merror>
<mtext>DivisionByZero: </mtext>
<mfrac><mi>x</mi><mn>0</mn></mfrac>
</merror>
Note that when the context where an error occurs is so nonsensical
that its default presentation would not be useful, an application may
provide an alternative representation of the error context. For
example:
<cerror>
<csymbol cd="error">Illegal bound variable</csymbol>
<cs> <bvar><plus/></bvar> </cs>
</cerror>
|
Schema Fragment (Strict) |
Schema Fragment (Full) |
| Class |
Cbytes |
Cbytes |
| Attributes |
CommonAtt |
CommonAtt, DefEncAtt |
| Content |
base64 |
base64 |
The content of cbytes represents a stream of bytes as a
sequence of characters in Base64 encoding, that is it matches the
base64Binary data type defined in [XMLSchemaDatatypes]. All white space is ignored.
The cbytes element is mainly used for OpenMath
compatibility, but may be used, as in OpenMath, to encapsulate output
from a system that may be hard to encode in MathML, such as binary
data relating to the internal state of a system, or image data.
The rendering of cbytes is not expected to represent the
content and the proposed rendering is that of an empty
mrow. Typically cbytes is used in an
annotation-xml or is itself annotated with Presentation
MathML, so this default rendering should rarely be used.
The elements of Strict Content MathML described in
the previous section are sufficient to
encode logical assertions and expression structure, and they do so
in a way that closely models the standard constructions of
mathematical logic that underlie the foundations of mathematics. As a
consequence, Strict markup can be used to represent all of
mathematics, and is ideal for providing consistent mathematical
semantics for all Content MathML expressions.
At the same time, many notational idioms of mathematics are not
straightforward to represent directly with Strict Content markup.
For example, standard notations for sums, integrals, sets, piecewise
functions and many other common constructions require non-obvious
technical devices, such as the introduction of lambda functions, to
rigorously encode them using Strict markup. Consequently, in order
to make Content MathML easier to use, a range of additional elements
have been provided for encoding such idiomatic constructs more
directly. This section discusses the general approach for encoding
such idiomatic constructs, and their Strict Content equivalents.
Specific constructions are discussed in detail in 4.3 Content MathML for Specific Structures.
Most idiomatic constructions which Content markup addresses fall
into about a dozen classes. Some of these classes, such as container elements, have
their own syntax. Similarly, a small number of non-Strict
constructions involve a single element with an exceptional syntax,
for example partialdiff. These exceptional elements are
discussed on a case-by-case basis in 4.3 Content MathML for Specific Structures. However, the majority of constructs consist of
classes of operator elements which all share a particular usage of
qualifiers.
These classes of operators are described in 4.3.4 Operator Classes.
In all cases, non-Strict expressions may be rewritten using only
Strict markup. In most cases, the transformation is completely
algorithmic, and may be automated. Rewrite rules for classes of
non-Strict constructions are introduced and discussed later in this
section, and rewrite rules for exceptional constructs involving a
single operator are given in 4.3 Content MathML for Specific Structures. The
complete algorithm for rewriting arbitrary Content MathML as Strict
Content markup is summarized at the end of the Chapter in F. The Strict Content MathML Transformation.
Many mathematical structures are constructed from subparts or
parameters. For example, a set is a mathematical object that
contains a collection of elements, so it is natural for the
markup for a set to contain the markup for its constituent
elements. The markup for a set may define the set of elements
explicitly by enumerating them, or implicitly by rule that uses
qualifier elements. In either case, the markup for the elements is
contained in the markup for the set, and this style of
representation is called container markup in MathML. By
contrast, Strict markup represents an instance of a set as the
result of applying a function or constructor symbol to
arguments. In this style of markup, the markup for the set
construction is a sibling of the markup for the set elements in an
enclosing apply element.
MathML provides container markup for the following mathematical
constructs: sets, lists, intervals, vectors, matrices (two
elements), piecewise functions (three elements) and lambda
functions. There are corresponding constructor symbols in Strict
markup for each of these, with the exception of lambda functions,
which correspond to binding symbols in Strict markup.
The rewrite rules for obtaining equivalent Strict Content
markup from container markup depend on the operator class of the particular
operator involved. For details about a specific container
element, obtain its operator class (and any applicable special
case information) by consulting the syntax table and discussion
for that element in E. The Content MathML Operators. Then apply the
rewrite rules for that specific operator class as described in
F. The Strict Content MathML Transformation.
The arguments to container elements that correspond to
constructors may be explicitly given as a sequence of child
elements, or implicitly given by a rule using qualifiers. The
exceptions are the interval, piecewise, piece, and
otherwise elements. The
arguments of these elements must be specified explicitly.
Here is an example of container markup with explicitly specified arguments:
<set><ci>a</ci><ci>b</ci><ci>c</ci></set>
This is equivalent to the following Strict Content MathML expression:
<apply><csymbol cd="set1">set</csymbol><ci>a</ci><ci>b</ci><ci>c</ci></apply>
Another example of container markup, where the list of arguments is
given indirectly as an expression with a bound variable. The container markup
for the set of even integers is:
<set>
<bvar><ci>x</ci></bvar>
<domainofapplication><integers/></domainofapplication>
<apply><times/><cn>2</cn><ci>x</ci></apply>
</set>
This may be written as follows in Strict Content MathML:
<apply><csymbol cd="set1">map</csymbol>
<bind><csymbol cd="fns1">lambda</csymbol>
<bvar><ci>x</ci></bvar>
<apply><csymbol cd="arith1">times</csymbol>
<cn>2</cn>
<ci>x</ci>
</apply>
</bind>
<csymbol cd="setname1">Z</csymbol>
</apply>
The lambda element is a container element
corresponding to the lambda symbol
in the fns1 Content Dictionary. However, unlike the
container elements of the preceding section, which purely
construct mathematical objects from arguments, the lambda
element performs variable binding as well. Therefore, the child
elements of lambda have distinguished roles. In
particular, a lambda element must have at least one
bvar child, optionally followed by qualifier elements, followed by a
Content MathML element. This basic difference between the
lambda container and the other constructor container
elements is also reflected in the OpenMath symbols to which they
correspond. The constructor symbols have an OpenMath role of
application
, while the lambda symbol has a role of bind
.
This example shows the use of lambda container element and the equivalent use of bind in Strict Content MathML
<lambda><bvar><ci>x</ci></bvar><ci>x</ci></lambda>
<bind><csymbol cd="fns1">lambda</csymbol>
<bvar><ci>x</ci></bvar><ci>x</ci>
</bind>
MathML allows the use of the apply element to perform
variable binding in non-Strict constructions instead of
the bind element. This usage conserves backwards
compatibility with MathML 2. It also simplifies the encoding of
several constructs involving bound variables with qualifiers as
described below.
Use of the apply element to bind variables is allowed
in two situations. First, when the operator to be applied is
itself a binding operator, the apply element merely
substitutes for the bind element. The logical quantifiers
<forall/>, <exists/> and the
container element lambda are the primary examples of this
type.
The second situation arises when the operator being applied
allows the use of bound variables with qualifiers. The most
common examples are sums and integrals. In most of these cases,
the variable binding is to some extent implicit in the notation,
and the equivalent Strict representation requires the introduction
of auxiliary constructs such as lambda expressions for formal
correctness.
Because expressions using bound variables with qualifiers are
idiomatic in nature, and do not always involve true variable
binding, one cannot expect systematic renaming (alpha-conversion)
of variables bound
with apply to preserve meaning in
all cases. An example for this is the diff element where
the bvar term is technically not bound at all.
The following example illustrates the use of apply
with a binding operator. In these cases, the corresponding Strict
equivalent merely replaces the apply element with a
bind element:
<apply><forall/>
<bvar><ci>x</ci></bvar>
<apply><geq/><ci>x</ci><ci>x</ci></apply>
</apply>
The equivalent Strict expression is:
<bind><csymbol cd="logic1">forall</csymbol>
<bvar><ci>x</ci></bvar>
<apply><csymbol cd="relation1">geq</csymbol><ci>x</ci><ci>x</ci></apply>
</bind>
In this example, the sum operator is not itself a binding
operator, but bound variables with qualifiers are implicit in the
standard notation, which is reflected in the non-Strict markup.
In the equivalent Strict representation, it is necessary to
convert the summand into a lambda expression, and recast the
qualifiers as an argument expression:
<apply><sum/>
<bvar><ci>i</ci></bvar>
<lowlimit><cn>0</cn></lowlimit>
<uplimit><cn>100</cn></uplimit>
<apply><power/><ci>x</ci><ci>i</ci></apply>
</apply>
The equivalent Strict expression is:
<apply><csymbol cd="arith1">sum</csymbol>
<apply><csymbol cd="interval1">integer_interval</csymbol>
<cn>0</cn>
<cn>100</cn>
</apply>
<bind><csymbol cd="fns1">lambda</csymbol>
<bvar><ci>i</ci></bvar>
<apply><csymbol cd="arith1">power</csymbol>
<ci>x</ci>
<ci>i</ci>
</apply>
</bind>
</apply>
Many common mathematical constructs involve an operator
together with some additional data. The additional data is either
implicit in conventional notation, such as a bound variable, or
thought of as part of the operator, as is the case with the limits
of a definite integral. MathML 3 uses qualifier
elements to represent the additional data in such cases.
Qualifier elements are always used in conjunction with operator or container
elements. Their meaning is idiomatic, and depends on the context in which they are
used. When used with an operator, qualifiers always follow the operator and precede
any arguments that are present. In all cases, if more than one qualifier is present,
they appear in the order bvar, lowlimit, uplimit,
interval, condition, domainofapplication, degree,
momentabout, logbase.
The precise function of qualifier elements depends on the
operator or container that they modify. The majority of use cases
fall into one of several categories, discussed below, and usage
notes for specific operators and qualifiers are given in 4.3 Content MathML for Specific Structures.
| Class |
qualifier |
| Attributes |
CommonAtt |
| Content |
ContExp |
(For the syntax of interval see 4.3.10.3 Interval <interval>.)
The primary use of domainofapplication, interval,
uplimit, lowlimit and condition is to
restrict the values of a bound variable. The most general qualifier
is domainofapplication. It is used to specify a set (perhaps
with additional structure, such as an ordering or metric) over which
an operation is to take place. The interval qualifier, and
the pair lowlimit and uplimit also restrict a bound
variable to a set in the special case where the set is an
interval.
Note that interval is only interpreted as a qualifier if it immediately
follows bvar.
The condition qualifier, like
domainofapplication, is general, and can be used to restrict
bound variables to arbitrary sets. However, unlike the other
qualifiers, it restricts the bound variable by specifying a
Boolean-valued function of the bound variable. Thus,
condition qualifiers always contain instances of the bound
variable, and thus require a preceding bvar, while the other
qualifiers do not. The other qualifiers may even be used when no
variables are being bound, e.g. to indicate the restriction of a
function to a subdomain.
In most cases, any of the qualifiers capable of representing the
domain of interest can be used interchangeably. The most general
qualifier is domainofapplication, and therefore has a
privileged role. It is the preferred form, unless there are
particular idiomatic reasons to use one of the other qualifiers,
e.g. limits for an integral. In MathML 3, the other forms are treated
as shorthand notations for domainofapplication because they
may all be rewritten as equivalent domainofapplication
constructions. The rewrite rules to do this are given below. The other
qualifier elements are provided because they correspond to common
notations and map more easily to familiar presentations. Therefore,
in the situations where they naturally arise, they may be more
convenient and direct than domainofapplication.
To illustrate these ideas, consider the following examples showing alternative
representations of a definite integral. Let
denote the interval from 0 to 1,
and . Then
domainofapplication could be used to express the integral of a
function over
in this way:
<apply><int/>
<domainofapplication>
<ci type="set">C</ci>
</domainofapplication>
<ci type="function">f</ci>
</apply>
Note that no explicit bound variable is identified in this
encoding, and the integrand is a function. Alternatively, the
interval qualifier could be used with an explicit bound variable:
<apply><int/>
<bvar><ci>x</ci></bvar>
<interval><cn>0</cn><cn>1</cn></interval>
<apply><power/><ci>x</ci><cn>2</cn></apply>
</apply>
The pair lowlimit and uplimit can also be used.
This is perhaps the most standard
representation of this integral:
<apply><int/>
<bvar><ci>x</ci></bvar>
<lowlimit><cn>0</cn></lowlimit>
<uplimit><cn>1</cn></uplimit>
<apply><power/><ci>x</ci><cn>2</cn></apply>
</apply>
Finally, here is the same integral, represented using
a condition on the bound variable:
<apply><int/>
<bvar><ci>x</ci></bvar>
<condition>
<apply><and/>
<apply><leq/><cn>0</cn><ci>x</ci></apply>
<apply><leq/><ci>x</ci><cn>1</cn></apply>
</apply>
</condition>
<apply><power/><ci>x</ci><cn>2</cn></apply>
</apply>
Note the use of the explicit bound variable within the
condition term. Note also that when a bound
variable is used, the integrand is an expression in the bound
variable, not a function.
The general technique of using a condition element
together with domainofapplication is quite powerful. For
example, to extend the previous example to a multivariate domain, one
may use an extra bound variable and a domain of application
corresponding to a cartesian product:
<apply><int/>
<bvar><ci>x</ci></bvar>
<bvar><ci>y</ci></bvar>
<domainofapplication>
<set>
<bvar><ci>t</ci></bvar>
<bvar><ci>u</ci></bvar>
<condition>
<apply><and/>
<apply><leq/><cn>0</cn><ci>t</ci></apply>
<apply><leq/><ci>t</ci><cn>1</cn></apply>
<apply><leq/><cn>0</cn><ci>u</ci></apply>
<apply><leq/><ci>u</ci><cn>1</cn></apply>
</apply>
</condition>
<list><ci>t</ci><ci>u</ci></list>
</set>
</domainofapplication>
<apply><times/>
<apply><power/><ci>x</ci><cn>2</cn></apply>
<apply><power/><ci>y</ci><cn>3</cn></apply>
</apply>
</apply>
Note that the order of the inner and outer bound variables is significant.
| Class |
qualifier |
| Attributes |
CommonAtt |
| Content |
ContExp |
The degree element is a qualifier used to specify the
degree
or order
of an operation. MathML uses the
degree element in this way in three contexts: to specify the degree of a
root, a moment, and in various derivatives. Rather than introduce special elements
for
each of these families, MathML provides a single general construct, the
degree element in all three cases.
Note that the degree qualifier is not used to restrict a bound variable in
the same sense of the qualifiers discussed above. Indeed, with roots and moments,
no
bound variable is involved at all, either explicitly or implicitly. In the case of
differentiation, the degree element is used in conjunction with a
bvar, but even in these cases, the variable may not be genuinely bound.
For the usage of degree with the root and moment operators, see the discussion of those
operators below. The usage of degree in differentiation is more complex. In
general, the degree element indicates the order of the derivative with
respect to that variable. The degree element is allowed as the second child of a
bvar element identifying a variable with respect to which the derivative is
being taken. Here is an example of a second derivative using the degree
qualifier:
<apply><diff/>
<bvar>
<ci>x</ci>
<degree><cn>2</cn></degree>
</bvar>
<apply><power/><ci>x</ci><cn>4</cn></apply>
</apply>
For details see 4.3.8.2 Differentiation <diff/> and 4.3.8.3 Partial Differentiation <partialdiff/>.
The qualifiers momentabout and logbase are
specialized elements specifically for use with the moment
and log operators
respectively. See the descriptions of those operators below for their usage.
The Content MathML elements described in detail in the following
sections may be broadly separated into classes. The class
of each element is listed in the operator syntax table given in
E.3 The Content MathML Operators. The class gives an indication of the
general intended mathematical usage of the element, and also
determines its usage as determined by the schema. Links to the
operator syntax and schema class for each element are provided
in the sections that introduce the elements.
The operator class also determines the applicable rewrite rules
for mapping to Strict Content MathML. These rewrite rules are
presented in detail in F. The Strict Content MathML Transformation. They include
use cases applicable to specific operator classes, special-case
rewrite rules for individual elements, and a generic rewrite rule
F.8 Rewrite operators used by operators from almost all
operator classes.
The following sections present elements representing a core set of
mathematical operators, functions and constants. Most are empty
elements, covering the subject matter of standard mathematics
curricula up to the level of calculus. The remaining elements are
container elements for
sets, intervals, vectors and so on. For brevity, all elements
defined in this section are sometimes called operator
elements.
Many MathML operators may be used with an arbitrary number of
arguments. The corresponding OpenMath symbols for elements in these classes
also take an arbitrary number of arguments.
In all such cases, either the arguments may be given
explicitly as children of the apply or bind element, or
the list may be specified implicitly via the use of qualifier
elements.
Operator Syntax,
Schema Class
The plus and times elements represent the addition and multiplication operators. The
arguments are normally specified explicitly in the enclosing
apply element. As an n-ary commutative operator, they can
be used with qualifiers to specify arguments, however,
this is discouraged, and the sum or product operators should be
used to represent such expressions instead.
Content MathML
<apply><plus/><ci>x</ci><ci>y</ci><ci>z</ci></apply>
Sample Presentation
<mrow><mi>x</mi><mo>+</mo><mi>y</mi><mo>+</mo><mi>z</mi></mrow>
The gcd and lcm elements represent the n-ary operators which return the greatest common divisor, or least common multiple of their arguments. The arguments may be explicitly specified in the enclosing apply element, or specified by quantifiers.
This default renderings are English-language locale specific: other locales may have
different default renderings.
Content MathML
<apply><gcd/><ci>a</ci><ci>b</ci><ci>c</ci></apply>
Sample Presentation
<mrow>
<mi>gcd</mi>
<mo>⁡</mo>
<mrow><mo>(</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>,</mo><mi>c</mi><mo>)</mo></mrow>
</mrow>
Operator Syntax,
Schema Class
The sum element represents the n-ary addition operator.
The terms of the sum are normally specified by rule through the use of
qualifiers. While it can be used with an explicit list of
arguments, this is strongly discouraged, and the plus
operator should be used instead in such situations.
The sum operator may be used either with or without
explicit bound variables. When a bound variable is used, the
sum element is followed by one or more bvar
elements giving the index variables, followed by qualifiers giving
the domain for the index variables. The final child in the enclosing
apply is then an expression in the bound variables, and the
terms of the sum are obtained by evaluating this expression at each
point of the domain of the index variables. Depending on the
structure of the domain, the domain of summation is often given
by using uplimit and lowlimit to specify upper and
lower limits for the sum.
When no bound variables are explicitly given, the final child of
the enclosing apply element must be a function, and the
terms of the sum are obtained by evaluating the function at
each point of the domain specified by qualifiers.
Content MathML
<apply><sum/>
<bvar><ci>x</ci></bvar>
<lowlimit><ci>a</ci></lowlimit>
<uplimit><ci>b</ci></uplimit>
<apply><ci>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>
Sample Presentation
<mrow>
<munderover>
<mo>∑</mo>
<mrow><mi>x</mi><mo>=</mo><mi>a</mi></mrow>
<mi>b</mi>
</munderover>
<mrow><mi>f</mi><mo>⁡</mo><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>
</mrow>
<mrow>
<munder>
<mo>∑</mo>
<mrow><mi>x</mi><mo>∈</mo><mi>B</mi></mrow>
</munder>
<mrow><mi>f</mi><mo>⁡</mo><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>
</mrow>
<mrow><munder><mo>∑</mo><mi>B</mi></munder><mi>f</mi></mrow>
Operator Syntax,
Schema Class
The product element represents the n-ary multiplication operator.
The terms of the product are normally specified by rule through the use of
qualifiers. While it can be used with an explicit list of
arguments, this is strongly discouraged, and the times
operator should be used instead in such situations.
The product operator may be used either with or without
explicit bound variables. When a bound variable is used, the
product element is followed by one or more bvar
elements giving the index variables, followed by qualifiers giving
the domain for the index variables. The final child in the enclosing
apply is then an expression in the bound variables, and the
terms of the product are obtained by evaluating this expression at
each point of the domain. Depending on the structure of the domain,
it is commonly given using uplimit and lowlimit
qualifiers.
When no bound variables are explicitly given, the final child of
the enclosing apply element must be a function, and the
terms of the product are obtained by evaluating the function
at each point of the domain specified by qualifiers.
Content MathML
<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>f</ci><ci>x</ci></apply>
</apply>
Sample Presentation
<mrow>
<munderover>
<mo>∏</mo>
<mrow><mi>x</mi><mo>=</mo><mi>a</mi></mrow>
<mi>b</mi>
</munderover>
<mrow><mi>f</mi><mo>⁡</mo><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>
</mrow>
<mrow>
<munder>
<mo>∏</mo>
<mrow><mi>x</mi><mo>∈</mo><mi>B</mi></mrow>
</munder>
<mrow><mi>f</mi><mo>⁡</mo><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>
</mrow>
Operator Syntax,
Schema Class
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.
The compose element is a commutative n-ary operator. Consequently, it may be
lifted to the induced operator defined on a collection of arguments indexed by a (possibly
infinite) set by using qualifier elements as described in 4.3.5.4 N-ary Functional Operators:
<compose/>.
Content MathML
<apply><compose/><ci>f</ci><ci>g</ci><ci>h</ci></apply>
<apply><eq/>
<apply>
<apply><compose/><ci>f</ci><ci>g</ci></apply>
<ci>x</ci>
</apply>
<apply><ci>f</ci><apply><ci>g</ci><ci>x</ci></apply></apply>
</apply>
Sample Presentation
<mrow>
<mi>f</mi><mo>∘</mo><mi>g</mi><mo>∘</mo><mi>h</mi>
</mrow>
<mrow>
<mrow>
<mrow><mo>(</mo><mi>f</mi><mo>∘</mo><mi>g</mi><mo>)</mo></mrow>
<mo>⁡</mo>
<mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow>
</mrow>
<mo>=</mo>
<mrow>
<mi>f</mi>
<mo>⁡</mo>
<mrow>
<mo>(</mo>
<mrow>
<mi>g</mi>
<mo>⁡</mo>
<mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow>
</mrow>
<mo>)</mo>
</mrow>
</mrow>
</mrow>
Operator Syntax,
Schema Class
These elements represent
n-ary functions taking Boolean arguments and returning a Boolean value.
The arguments may be explicitly specified
in the enclosing apply element, or specified via qualifier elements.
and is true if all arguments are true, and false otherwise.
or is true if any of the arguments are true, and false otherwise.
xor is the logical exclusive or
function. It is true if there are an odd number of true arguments or false otherwise.
Content MathML
<apply><and/><ci>a</ci><ci>b</ci></apply>
<apply><and/>
<bvar><ci>i</ci></bvar>
<lowlimit><cn>0</cn></lowlimit>
<uplimit><ci>n</ci></uplimit>
<apply><gt/><apply><selector/><ci>a</ci><ci>i</ci></apply><cn>0</cn></apply>
</apply>
Strict Content MathML
<apply><csymbol cd="logic1">and</csymbol><ci>a</ci><ci>b</ci></apply>
<apply><csymbol cd="fns2">apply_to_list</csymbol>
<csymbol cd="logic1">and</csymbol>
<apply><csymbol cd="list1">map</csymbol>
<bind><csymbol cd="fns1">lambda</csymbol>
<bvar><ci>i</ci></bvar>
<apply><csymbol cd="relation1">gt</csymbol>
<apply><csymbol cd="linalg1">vector_selector</csymbol>
<ci>i</ci>
<ci>a</ci>
</apply>
<cn>0</cn>
</apply>
</bind>
<apply><csymbol cd="interval1">integer_interval</csymbol>
<cn type="integer">0</cn>
<ci>n</ci>
</apply>
</apply>
</apply>
Sample Presentation
<mrow><mi>a</mi><mo>∧</mo><mi>b</mi></mrow>
<mrow>
<munderover>
<mo>⋀</mo>
<mrow><mi>i</mi><mo>=</mo><mn>0</mn></mrow>
<mi>n</mi>
</munderover>
<mrow>
<mo>(</mo>
<msub><mi>a</mi><mi>i</mi></msub>
<mo>></mo>
<mn>0</mn>
<mo>)</mo>
</mrow>
</mrow>
Operator Syntax,
Schema Class
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; so the resulting list is of matrix rows given entry by entry.
That is, for a matrix , where the indices denote row
and column, respectively, the ordering would be
,
, …,
,
, … etc.
When two arguments are given, and the first is a vector or list, the second argument
specifies the index of an entry in the list or vector. If the first argument is a
matrix then
the second argument specifies the index of a matrix row.
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
indices of
the selected element.
Content MathML
<apply><selector/><ci type="vector">V</ci><cn>1</cn></apply>
<apply><eq/>
<apply><selector/>
<matrix>
<matrixrow><cn>1</cn><cn>2</cn></matrixrow>
<matrixrow><cn>3</cn><cn>4</cn></matrixrow>
</matrix>
<cn>1</cn>
</apply>
<matrix>
<matrixrow><cn>1</cn><cn>2</cn></matrixrow>
</matrix>
</apply>
Sample Presentation
<msub><mi>V</mi><mn>1</mn></msub>
<mrow>
<msub>
<mrow>
<mo>(</mo>
<mtable>
<mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd></mtr>
<mtr><mtd><mn>3</mn></mtd><mtd><mn>4</mn></mtd></mtr>
</mtable>
<mo>)</mo>
</mrow>
<mn>1</mn>
</msub>
<mo>=</mo>
<mrow>
<mo>(</mo>
<mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd></mtr></mtable>
<mo>)</mo>
</mrow>
</mrow>
Operator Syntax,
Schema Class
The union element is used to denote the n-ary union of sets. It takes sets as arguments,
and denotes the set that contains all the elements that occur in any
of them.
The intersect element is used to denote the n-ary union of sets. It takes sets as arguments,
and denotes the set that contains all the elements that occur in all
of them.
The cartesianproduct element is used to represent the
Cartesian product operator.
Arguments may be explicitly specified in the enclosing apply element, or
specified using qualifier elements as described in 4.3.5 N-ary Operators.
Content MathML
<apply><union/><ci>A</ci><ci>B</ci></apply>
<apply><intersect/><ci>A</ci><ci>B</ci><ci>C</ci></apply>
<apply><cartesianproduct/><ci>A</ci><ci>B</ci></apply>
Sample Presentation
<mrow><mi>A</mi><mo>∪</mo><mi>B</mi></mrow>
<mrow><mi>A</mi><mo>∩</mo><mi>B</mi><mo>∩</mo><mi>C</mi></mrow>
<mrow><mi>A</mi><mo>×</mo><mi>B</mi></mrow>
Content MathML
<apply><union/>
<bvar><ci type="set">S</ci></bvar>
<domainofapplication>
<ci type="list">L</ci>
</domainofapplication>
<ci type="set"> S</ci>
</apply>
<apply><intersect/>
<bvar><ci type="set">S</ci></bvar>
<domainofapplication>
<ci type="list">L</ci>
</domainofapplication>
<ci type="set"> S</ci>
</apply>
Sample Presentation
<mrow><munder><mo>⋃</mo><mi>L</mi></munder><mi>S</mi></mrow>
<mrow><munder><mo>⋂</mo><mi>L</mi></munder><mi>S</mi></mrow>
Operator Syntax,
Schema Class
A vector is an ordered n-tuple of values representing an element of an
n-dimensional vector space.
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 as a matrix consisting of a single row.
The components of a vector may be given explicitly as
child elements, or specified by rule as described in 4.3.1.1 Container Markup for Constructor Symbols.
Content MathML
<vector>
<apply><plus/><ci>x</ci><ci>y</ci></apply>
<cn>3</cn>
<cn>7</cn>
</vector>
Sample Presentation
<mrow>
<mo>(</mo>
<mtable>
<mtr><mtd><mrow><mi>x</mi><mo>+</mo><mi>y</mi></mrow></mtd></mtr>
<mtr><mtd><mn>3</mn></mtd></mtr>
<mtr><mtd><mn>7</mn></mtd></mtr>
</mtable>
<mo>)</mo>
</mrow>
<mrow>
<mo>(</mo>
<mrow><mi>x</mi><mo>+</mo><mi>y</mi></mrow>
<mo>,</mo>
<mn>3</mn>
<mo>,</mo>
<mn>7</mn>
<mo>)</mo>
</mrow>
A matrix is regarded as made up of matrix rows, each of which can be
thought of as a special type of vector.
Note that the behavior of the matrix and matrixrow elements is
substantially different from the mtable and mtr presentation
elements.
The matrix element is a constructor
element, so the entries may be given explicitly as child elements,
or specified by rule as described in 4.3.1.1 Container Markup for Constructor Symbols. In the latter case, the
entries are specified 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.
Matrix rows are not directly rendered by themselves outside of the
context of a matrix.
Content MathML
<matrix>
<bvar><ci type="integer">i</ci></bvar>
<bvar><ci type="integer">j</ci></bvar>
<condition>
<apply><and/>
<apply><in/>
<ci>i</ci>
<interval><ci>1</ci><ci>5</ci></interval>
</apply>
<apply><in/>
<ci>j</ci>
<interval><ci>5</ci><ci>9</ci></interval>
</apply>
</apply>
</condition>
<apply><power/><ci>i</ci><ci>j</ci></apply>
</matrix>
Sample Presentation
<mrow>
<mo>[</mo>
<msub><mi>m</mi><mrow><mi>i</mi><mo>,</mo><mi>j</mi></mrow></msub>
<mo>|</mo>
<mrow>
<msub><mi>m</mi><mrow><mi>i</mi><mo>,</mo><mi>j</mi></mrow></msub>
<mo>=</mo>
<msup><mi>i</mi><mi>j</mi></msup>
</mrow>
<mo>;</mo>
<mrow>
<mrow>
<mi>i</mi>
<mo>∈</mo>
<mrow><mo>[</mo><mi>1</mi><mo>,</mo><mi>5</mi><mo>]</mo></mrow>
</mrow>
<mo>∧</mo>
<mrow>
<mi>j</mi>
<mo>∈</mo>
<mrow><mo>[</mo><mi>5</mi><mo>,</mo><mi>9</mi><mo>]</mo></mrow>
</mrow>
</mrow>
<mo>]</mo>
</mrow>
Operator Syntax,
Schema Class
The set element represents the n-ary function which constructs a mathematical set from its arguments. The set element takes the attribute type which may have the values set and multiset. The members of the set to be constructed may be given explicitly as child elements of the constructor, or specified by rule as described in 4.3.1.1 Container Markup for Constructor Symbols. There is no implied ordering to the elements of a set.
The list element represents the n-ary function which constructs a list from its arguments. Lists differ from sets in that there is an explicit order to the elements. The list element takes the attribute order which may have the values numeric and lexicographic. The list entries and order may be given explicitly or specified by rule as described in 4.3.1.1 Container Markup for Constructor Symbols.
Content MathML
<set>
<ci>a</ci><ci>b</ci><ci>c</ci>
</set>
<list>
<ci>a</ci><ci>b</ci><ci>c</ci>
</list>
Sample Presentation
<mrow>
<mo>{</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>,</mo><mi>c</mi><mo>}</mo>
</mrow>
<mrow>
<mo>(</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>,</mo><mi>c</mi><mo>)</mo>
</mrow>
In general sets and lists can be constructed by providing a function and
a domain of application. The elements correspond to the
values obtained by evaluating the function at the points of the
domain. When this method is used for lists, the ordering of the list elements
may not be clear, so the kind of ordering may be specified by the
order attribute. Two orders are supported: lexicographic
and numeric.
Content MathML
<set>
<bvar><ci>x</ci></bvar>
<condition>
<apply><lt/><ci>x</ci><cn>5</cn></apply>
</condition>
<ci>x</ci>
</set>
<list order="numeric">
<bvar><ci>x</ci></bvar>
<condition>
<apply><lt/><ci>x</ci><cn>5</cn></apply>
</condition>
</list>
<set>
<bvar><ci type="set">S</ci></bvar>
<condition>
<apply><in/><ci>S</ci><ci type="list">T</ci></apply>
</condition>
<ci>S</ci>
</set>
<set>
<bvar><ci> x </ci></bvar>
<condition>
<apply><and/>
<apply><lt/><ci>x</ci><cn>5</cn></apply>
<apply><in/><ci>x</ci><naturalnumbers/></apply>
</apply>
</condition>
<ci>x</ci>
</set>
Sample Presentation
<mrow>
<mo>{</mo>
<mi>x</mi>
<mo>|</mo>
<mrow><mi>x</mi><mo><</mo><mn>5</mn></mrow>
<mo>}</mo>
</mrow>
<mrow>
<mo>(</mo>
<mi>x</mi>
<mo>|</mo>
<mrow><mi>x</mi><mo><</mo><mn>5</mn></mrow>
<mo>)</mo>
</mrow>
as opposed to the default rendering
.
![[Image of a circle and box around x plus y]](image/circlebox.png)
![[image of actuarial notation for a angle n at i]](image/actuarial.png)
![[image of phasorangle notation for the angle negative pi over 2]](image/phasorangle.png)
![[Image of 12 factorial in Arabic style]](image/madruwb12.png)
