Issue cds_normative  wiki (member only) 

Are CDs normative in MathML3  
The CDs now contain a lot of information that is not in any normative part of MathML any more (after the rewriting of Chapter 3). This means that we may have to make the CDs in this chapter normative 

Resolution  None recorded 
The primary role of MathML content elements is to provide a mechanism for recording
that a particular notational structure has a particular mathematical meaning. To this
end, every content element must have a mathematical definition associated with it in
some form. These definitions are provided in the form of content
dictionaries, XML files of a certain structure (see . The purpose of this appendix is to provide a default
set of content dictionaries for the K14 fragment of mathematics. Authors may adopt
these and come up with additional ones, fixing additional content elements that are
encoded via the csymbol
element.
Content Dictionaries (CDs) are central to the MathML philosophy of transmitting mathematical information. It is the Content Dictionaries which actually hold the meanings of the objects being transmitted.
For example if application A is talking to application B, and sends, say, an equation involving multiplication of matrices, then A and B must agree on what a matrix is, and on what matrix multiplication is, and even on what constitutes an equation. All this information is held within some Content Dictionaries which both applications agree upon.
Intuitively, a Content Dictionary holds the meanings of (various) mathematical "words", that are represented by symbols in Content MathML
With a set of symbol definitions (perhaps from several Content Dictionaries), A and B can now talk in a common "language".
The concept of a content dictionary has initially been introduced by the OpenMath1 format [OpenMath2000], and has been stabilized and generalized to abstract content dictionaries in the OpenMath2 standard [OpenMath2004], keeping a variant of OpenMath1 CDs as a reference encoding. MathML 3 introduces a content dictionary format that is designed to meet the requirements of the MathML language, while meeting the requirements of OpenMath abstract CDs. We will introduce the format in the next section and then include the MathML3 content dictionaries for the K14 fragments as part of the MathML3 recommendataion. These CDs are called the MathML3 Recommendation Content Dictionaries
When working with the content elements, it can be useful to keep in mind the following.
The role of the content elements is analogous to data entry in a mathematical system. The information that is provided is there to facilitate the successful parsing of an expression as the intended mathematical object by a receiving application.
MathML content elements do not by themselves "perform" any mathematical evaluations or operations. They do not "evaluate" in a browser and any "action" that is ultimately taken on those objects is determined entirely by the receiving mathematical application. For example, editing programs and applications geared to computation for the lower grades would typically leave 3 + 4 as is, whereas computational systems targeting a more advanced audience might evaluate this as 7. Similarly, some computational systems might evaluate sin(0) to 0, whereas others would leave it unevaluated. Yet other computational systems might be unable to deal with pure symbolic expressions like sin(x) and may even regard them as data entry errors. None of this has any bearing on the correctness of the original MathML representation. Where evaluation is mentioned at all in the descriptions below, it is merely to help clarify the meaning of the underlying operation.
Apart from the instances where there is an explicit interaction with presentation tagging, there is no required rendering (visual or aural) – only a suggested default. As such, the presentations that are included in this section are merely to help communicate to the reader the intended mathematical meaning by association with the same expression written in a more traditional notation.
We will now detail the MathML3 Content Dictionary format, on an abstract level and discuss the special case of the MathML Recommendation CDs. Note that the latter are not the only possible ones, any individual or group can set up and publish CDs for the purposes of communication.
Editorial note: MiKo  
the material here is copied frm OMstyle abstract content dictionaries. 
An abstract Content Dictionary consists of the following mandatory pieces of information:
A name which is an XML1.1 name [xml11].
A description of the Content Dictionary.
A revision date, the date of the last change to the Content Dictionary. Dates should be stored in the ISOcompliant format YYYYMMDD, e.g. 19660203. For the MathML specification CDs the revision date is the date of the publication of the respective MathML recommendation.
A review date, a date until which the content dictionary is guaranteed to remain unchanged.
Issue mcd_dates  wiki (member only) ISSUE4 (member only) 

Revision date for MathML3 Spec content dictionaries  
There is not really a sensible review date for MathML3 spec CDs. We have no idea, when the spec will be revised. Unless we want to make them less normative than the MathML3 spec, and set up a revision process, then we will have to make this optional (and remove the requirement in OpenMath3) 

Resolution  None recorded 
A version number which consists of a major and minor part. For the MathML specification CDs, this is the version number of the respective MathML recommendation.
A status, which is one of
official
: i.e. approved by W3C as part of the MathML specification
experimental
: under development and thus liable to change;
private
: used by a private group of users;
obsolete
: an obsolete Content Dictionary kept only for
archival purposes.
Issue official_mcd  wiki (member only) ISSUE5 (member only) 

Approving bodies for CDs?  
OpenMath2 standard only allows 

Resolution  None recorded 
A CD base which, when combined with the CD name, forms a unique identifier for the Content Dictionary. It may or may not refer to an actual location from which it can be retrieved.
A series of one or more symbol definitions as described below.
A symbol definition consists of the following pieces of information:
A mandatory name which is an XML1.1 name [xml11].
A mandatory description of the symbol, which can be as formal or informal as the author likes.
An optional role as described in Section C.2.3 Symbol Roles.
A mandatory default rendering specification (see Section C.2.4 Default Rendering Specifications for details.
Zero or more attribute specifications for the case, where the MathML token takes attributes.
Zero or more signature declarations for type information
Zero or more commented mathematical properties which are mathematical properties of the symbol expressed in a humanreadable way.
Zero or more properties which are mathematical properties of the symbol. A property can be expressed in natural language and as a MathML expression tree in the same property. The former is directly aimed at human readers, and the latter could be used for validation or evaluation in mathematical software systems.
property may be given an optional kind attribute. An author of a Content Dictionary may use this to indicate whether, for example, the property provides an algorithm for evaluation of the concept it is associated with. At present no fixed scheme is mandated for how this information should be encoded or used by an application.
Zero or more mathematical examples which are intended to demonstrate the use of the symbol within a content MathML expression tree.
We say that a symbol is used to construct an MathML expression tree
if it is the first child of an apply
, bind
or error
element. The role of a symbol is a restriction on how it may be used to
construct a compound expression tree and, in the case of the key in an attribution
object, a clarification of how that attribution should be interpreted. The possible
roles are:
binder The symbol may appear as the first child of a
bind
element.
application The symbol may appear as the first child of an
apply
element.
constant The symbol cannot be used to construct a compound expression tree.
error The symbol may appear as the first child of a
error
element.
Issue mathml_roles  wiki (member only) 

More Roles for MathML?  
Those are the roles in OpenMath. Do we need more in MathML? We could have one
for constructor (so that we know that it is a container element in legacy
markup)... That could later be mapped to application. But maybe this would be
better done by the 

Resolution  None recorded 
A symbol cannot have more than one role and cannot be used to construct a compound expression tree object in a way which requires a different role (using the definition of construct given earlier in this section). This means that one cannot use a symbol which binds some variables to construct, say, an application object. However it does not prevent the use of that symbol as an argument in an application object (where by argument we mean a child with index greater than 1).
If no role is indicated then the symbol can be used anywhere. Note that this is not the same as saying that the symbol's role is constant.
Issue mcd_rendering  wiki (member only) ISSUE6 (member only) 

A MathML format for rendering?  
How do we want to specify rendings. There are a couple of options:
in the latter cases: what do we do for role:application? There are solutions from ORCCA or OMDoc 

Resolution  None recorded 
The basic content Elements
interval
This is the MathML constructor element for building an interval on the real line. While an interval can be expressed by combining relations appropriately, they occur here explicitly because of the frequency of their use.
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",
"openclosed", or "closedopen", 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 predefined nary 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.7 Qualifiers.
The interval
element expects two child elements that evaluate to real
numbers. or one or more bvar
elements and a child element
that is a condition
defining the interval
.
The interval
element denotes an interval on the real line with the
values represented by its children as end points. The closure
attribute
is used to qualify the type of interval being represented. For example,
<interval closure="openclosed"><ci>a</ci><ci>b</ci></interval>
represents the openclosed interval often written (a,b].
Name  Value  Default 

type  closed  open  openclosed  closedopen  closed 
[type=intervaltype](algebraic,algebraic) > interval(intervaltype)
<interval closure="open"> <ci>x</ci> <cn>1</cn> </interval>
<interval closure="openclosed"> <cn>0</cn> <cn>1</cn> </interval>
<interval> <bvar><ci>x</ci></bvar> <condition> <apply><lt/><cn>0</cn><ci>x</ci></apply> </condition> </interval>
<apply><int/> <interval><cn>0</cn><cn>1</cn></interval> <ci type="function">f</ci> </apply>
inverse
This MathML element is applied to a function in order to construct a new function that is to be interpreted as the inverse function of the original function. For a particular function F, inverse(F) composed with F behaves like the identity map on the domain of F and F composed with inverse(F) should be an identity function on a suitably restricted subset of the Range of F. The MathML definitionURL attribute should be used to resolve notational ambiguities, or to restrict the inverse to a particular domain or to make it onesided.
The inverse
element is applied to a function in order to construct a
generic expression nfor the functional inverse of that function. 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.
Given functions, it is natural to have functional inverses. This is handled by the
inverse
element.
Functional inverses can be problematic from a mathematical point of view in that they implicitly involve the definition of an inverse for an arbitrary function F. Even at the Kthrough12 level the concept of an inverse F ^{1} of many common functions F is not used in a uniform way. For example, the definitions used for the inverse trigonometric functions may differ slightly depending on the choice of domain and/or branch cuts.
MathML adopts the view: if F is a function from a domain D to D', then the inverse G of F is a function over D' such that G(F(x)) = x for x in D. This definition does not assert that such an inverse exists for all or indeed any x in D, or that it is singlevalued anywhere. Also, depending on the functions involved, additional properties such as F(G(y)) = y for y in D' may hold.
The inverse
element is applied to a function whenever an inverse is
required. For example, application of the inverse sine function to x,
i.e. sin^{1} (x), is encoded as:
<apply> <apply> <inverse/> <sin/> </apply> <ci> x </ci> </apply>
While
arcsin
is one of the predefined MathML functions, an explicit reference to
sin^{1}(x) might occur in a document discussing possible
definitions of arcsin
.
(function) > function
[definitionURL=URI](function) > function(definition)
ForAll( y, such y in domain( f^(1) ), f( f^(1)(y) ) = y
<apply><forall/> <bvar><ci>y</ci></bvar> <bvar><ci type="function">f</ci></bvar> <condition> <apply><in/> <ci>y</ci> <apply><csymbol definitionURL="domain"><mtext>Domain</mtext></csymbol> <apply><inverse/><ci type="function">f</ci></apply> </apply> </apply> </condition> <apply><eq/> <apply><ci type="function">f</ci> <apply><apply><inverse/><ci type="function">f</ci></apply> <ci>y</ci> </apply> </apply> <ci>y</ci> </apply> </apply>
<apply><inverse/> <sin/> </apply>
<apply><inverse definitionURL="www.example.com/MathML/Content/arcsin"/> <sin/> </apply>
<apply> <apply><inverse/> <ci type="matrix"> a </ci> </apply> <ci> A </ci> </apply>
lambda
This is the operation of lambda calculus that constructs a function from an expression and a variable. Lambda is an nary function, where all but an optional domain of application and the last argument are bound variables and the last argument is an expression possibly involving those variables. The lambda function can be viewed as the inverse of function application.
For example, Lambda( x, F ) is written as \lambda x [F] in the lambda calculus literature. The expression F may contain x but the full lambda expression is regarded to be free of x. A computational application receiving a MathML lambda expression should not evaluate x or test for x. Such an application may apply the lambda expression as a function to arguments in which case any result that is computed is computed through parameter substitutions into F.
Note that a lambda expression on an arbitrary function applied to a the bound variable is equivalent to that arbitrary function. A domain of application can be used to restrict the defined function to a specific domain.
The lambda
element is used to construct a userdefined 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
nary function that returns the expression in the last child where
the bound variables are replaced with the respective arguments.
The lambda
element is used to construct a userdefined function from
an expression. The last child is an expression defining the function in terms of
the bound variables declared by the bvar
and any
domainofapplication
(see Section 4.2.7 Qualifiers) elements
coming before it. The last element is typically an apply
element, but
can also be any container element. The following constructs
(x, sin x)
<lambda> <bvar><ci>x</ci></bvar> <apply><sin/><ci>x</ci></apply> </lambda>
The following constructs the constant function (x, 3)
<lambda><bvar><ci> x </ci></bvar><cn>3</cn></lambda>
The lambda calculus allows a user to construct a function from a variable and an expression. For example, the lambda construct underlies the common mathematical idiom illustrated here:
Let f be the function taking x to x^{2} + 2
There are various notations for this concept in mathematical literature, such as (x, F(x)) = F or (x, [F]) =F, where x is a free variable in F.
This concept is implemented in MathML with the lambda
element. A lambda
construct with n (possibly 0) internal variables is encoded by a
lambda
element, where the first n children are bvar
elements containing the identifiers of the internal variables. This is followed by an
optional domainofapplication
qualifier (see Section 4.2.7 Qualifiers) and an expression defining the function. The defining
expression is typically an apply
, but can also be any expression.
The following constructs (x, sin(x+1)):
<lambda> <bvar><ci> x </ci></bvar> <apply> <sin/> <apply> <plus/> <ci> x </ci> <cn> 1 </cn> </apply> </apply> </lambda>
To use declare
and lambda
to construct the function f for
which f( x) = x^{2} + x + 3 use:
<declare type="function"> <ci> f </ci> <lambda> <bvar><ci> x </ci></bvar> <apply> <plus/> <apply> <power/> <ci> x </ci> <cn> 2 </cn> </apply> <ci> x </ci> <cn> 3 </cn> </apply> </lambda> </declare>
The following markup declares and constructs the function J such that J(x, y) is the integral from x to y of t^{4} with respect to t.
<declare type="function"> <ci> J </ci> <lambda> <bvar><ci> x </ci></bvar> <bvar><ci> y </ci></bvar> <apply> <int/> <bvar><ci> t </ci></bvar> <lowlimit><ci> x </ci></lowlimit> <uplimit><ci> y </ci></uplimit> <apply> <power/> <ci>t</ci> <cn>4</cn> </apply> </apply> </lambda> </declare>
The function J can then in turn be applied to an argument pair.
(bvar*,anything) > function
(domainofapp,function) > function
(bvar+,domainofapp,anything) > function
ForAll( F, lambda(x,F(x)) = F )
<apply><forall/> <bvar><ci>F</ci></bvar> <apply><eq/> <lambda> <bvar><ci>x</ci></bvar> <apply><ci>F</ci><ci>x</ci></apply> </lambda> <ci>F</ci> </apply> </apply>
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 oneargument 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>
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. 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
<lambda> <domainofapplication><integers/></domainofapplication> <sin/> </lambda>
compose
This is the MathML constructor for composing functions. In order for a composition to be meaningful, the range of the first function should be the domain of the second function, etc. . However, since no evaluation takes place in MathML, such a construct can safely be used to make statements such as that f composed with g is undefined.
The result is a new function whose domain is the domain of the first function and whose range is the range of the last function and whose definition is equivalent to applying each function to the previous outcome in turn as in:
(f @ g )( x ) == f( g(x) ).
This function is often denoted by a small circle infix operator.
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 an nary operator. As an nary
operator, therefore it may take qualifiers.
(function*) > function
ForAll( x, (f@g)(x) = f(g(x) )
<apply><forall/> <bvar><ci>x</ci></bvar><bvar><ci>f</ci></bvar><bvar><ci>g</ci></bvar> <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> </apply>
The use of fn is deprecated. Use type="function" instead.
<apply><compose/> <ci type="function"> f </ci> <ci type="function"> g </ci> <sin/> </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>
ident
The ident element represents the identity function. MathML makes no assumption about the function space in which the identity function resides. Proper interpretation of the domain (and hence codomain) of the identity function depends on the context in which it is used.
function
ForAll( x, ident(x) = x )
<apply><forall/> <bvar><ci>x</ci></bvar> <apply><eq/> <apply><ident/><ci>x</ci></apply> <ci>x</ci> </apply> </apply>
<apply> <eq/> <apply><compose/> <fn><ci> f </ci></fn> <apply><inverse/> <fn><ci> f </ci></fn> </apply> </apply> <ident/> </apply>
<apply><eq/> <apply><compose/> <ci type="function"> f </ci> <apply><inverse/><ci type="function"> f </ci></apply> </apply> <ident/> </apply>
domain
The domain element denotes the domain of a given function, which is the set of values over which it is defined.
The domain
element denotes the domain of a given function, which is
the set of values over which it is defined.
(function) > set
If f is a function from the reals to the rationals, then:
<apply> <eq/> <apply><domain/> <fn><ci> f </ci></fn> </apply> <reals/> </apply>
codomain
The codomain (range) element denotes the codomain of a given function, which is a set containing all values taken by the function. The codomain may contain additional points which are not realized by applying the the function to elements of the domain.
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 integervalued, 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.
(function) > set
ForAll( y, Exists(x,y =f(x)), member(y,codomain(f)) )
If f is a function from the reals to the rationals, then:
<apply> <eq/> <apply><codomain/> <fn><ci> f </ci></fn> </apply> <rationals/> </apply>
image
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.
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.
(function) > set
ForAll( x, x in image(f), ThereExists(y,f(y)=x) )
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>
<apply><forall/> <bvar><ci>x</ci></bvar> <condition> <apply><in/> <ci>x</ci> <apply><image/><ci>f</ci></apply> </apply> </condition> <apply><in/> <ci>x</ci> <apply><codomain/><ci>f</ci></apply> </apply> </apply>
piecewise
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 piece and otherwise elements describe evaluation rules. If no rule applies or if more than one rule applies but they give different answers then the expression is undefined.
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.
The piecewise
, piece
, otherwise
elements are used to
support "piecewise" declarations of the form "
H(x) = 0 if x less than 0,
H(x) = x otherwise".
<piecewise> <piece> <cn>0</cn> <apply><lt/><ci>x</ci><cn>0</cn></apply> </piece> <otherwise><ci>x</ci></otherwise> </piecewise>
(piece*, otherwise?) > algebraic
(piece*, otherwise?) > anything
ForAll( x, x in domain(f), the evaluation rules collectively produce at most one value in codomain(f) )
<piecewise> <piece><cn> 0</cn><apply><lt/><ci> x</ci> <cn> 0</cn></apply></piece> <otherwise><ci>x</ci></otherwise> </piecewise>
The value of the abs function evaluated at x can be written as:
<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>
piece
The piece element is used to construct the conditionally defined values as part of a piecewise object.
(algebraic, boolean) > piece
(anything, boolean) > piece
<piecewise> <piece><cn>0</cn><apply><lt/><ci> x</ci> <cn> 0</cn></apply></piece> <otherwise><ci>x</ci></otherwise> </piecewise>
otherwise
The otherwise element is used to describe the value of a piecewise construct when none of the conditions of the associated pieces are satisfied.
(algebraic) > otherwise
(anything) > otherwise
<piecewise> <piece><cn> 0</cn><apply><lt/><ci> x</ci> <cn> 0</cn></apply></piece> <otherwise><ci>x</ci></otherwise> </piecewise>
quotient
quotient is the binary function used to represent the operation of integer division. quotient(a,b) denotes q such that a = b*q+r, with r less than b and a*r nonnegative.
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.)
Name  Value  Default 

type  MathMLType  integer 
(integer, integer) > integer
ForAll( [a,b], b != 0, a = b*quotient(a,b) + rem(a,b) )
<apply><forall/> <bvar><ci>a</ci></bvar> <bvar><ci>b</ci></bvar> <condition><apply><neq/><ci>b</ci><cn>0</cn></apply></condition> <apply><eq/> <ci>a</ci> <apply><plus/> <apply><times/> <ci>b</ci> <apply><quotient/><ci>a</ci><ci>b</ci></apply> </apply> <apply><rem/><ci>a</ci><ci>b</ci></apply> </apply> </apply> </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 whena=13 and b=5.
<apply><quotient/> <ci> a </ci> <ci> b </ci> </apply>
<apply> <quotient/> <cn>5</cn> <cn>4</cn> </apply>
factorial
This is the unary operator used to construct factorials. Factorials are defined by n! = n*(n1)* ... * 1
Name  Value  Default 

type  MathMLType  integer 
(algebraic) > algebraic
(integer) > integer
ForAll( n, n \gt 0, n! = n*(n1)! )
<apply><forall/> <bvar><ci>n</ci></bvar> <condition><apply><gt/><ci>n</ci><cn>0</cn></apply></condition> <apply><eq/> <apply><factorial/><ci>n</ci></apply> <apply><times/> <ci>n</ci> <apply><factorial/> <apply><minus/><ci>n</ci><cn>1</cn></apply> </apply> </apply> </apply> </apply>
0! = 1
<apply><eq/> <apply><factorial/><cn>0</cn></apply> <cn>1</cn> </apply>
If this were evaluated at n = 5 it would evaluate to 120.
<apply><factorial/> <ci>n</ci> </apply>
divide
This is the binary MathML operator that is used indicate the mathematical operation a "divided by" b.
Name  Value  Default 

type  MathMLType  real 
(algebraic, algebraic) > algebraic
(complex, complex) > complex
(real, real) > real
(rational, rational) > rational
(integer, integer) > rational
Division by Zero error
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><divide/><ci> a </ci><cn> 0 </cn></apply> <notanumber/> </apply> </apply>
ForAll( a, a!= 0, a/a = 1 )
<apply><forall/> <bvar><ci>a</ci></bvar> <condition><apply><neq/><ci>a</ci><cn>0</cn></apply></condition> <apply><eq/> <apply><divide/><ci>a</ci><ci>a</ci></apply> <cn>1</cn> </apply> </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.
<apply><divide/> <ci> a </ci> <ci> b </ci> </apply>
max
This is the nary operator used to represent the maximum of a set of
elements. The elements may be listed explicitly or they may be described by a
domainofapplication
, for example, the maximum over all x in the set A. The
domainofapplication
is often abbreviated by placing a condition directly on a
bound variable.
The max
operator is a nary operators may use the domain of
application qualifiers as described in Section 4.4.10 Lifted Associative Commutative Operators. For
example, the min
and max
functions accept a bvar
schema
in cases where the maximum or minimum is being taken over a set of values
specified by a condition
schema together with an expression to be
evaluated on that set. In MathML1.0, the bvar
element was optional when
using a condition
; if a condition
element containing a single
variable was given by itself following a min
or max
operator,
the variable was implicitly assumed to be bound, and the expression to be
maximized or minimized (if absent) was assumed to be the single bound variable.
This usage is deprecated in MathML 2.0 in
favor of explicitly stating the bound variable(s) and the expression to be
maximized or minimized in all cases.
The min
and max
elements may also be applied to a list of
values in which case no qualifier schemata are used.
Name  Value  Default 

type  MathMLType  real 
(algebraic*) > algebraic
(domainofapp,function) > algebraic
(bvar+,domainofapp,algebraic) > algebraic
ForAll( x in S, max(y in S,y) \geq x )
Maximum of a finite listing of elements
<apply><max/><cn>2</cn><cn>3</cn><cn>5</cn></apply>
Max(y^3, y in (0,1))
<apply> <max/> <bvar><ci>y</ci></bvar> <condition> <apply><in/><ci>y</ci><interval><cn>0</cn><cn>1</cn> </interval></apply> </condition> <apply><power/><ci> y</ci><cn>3</cn></apply> </apply>
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>
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>
min
This is the nary operator used to represent the minimum of a set of
elements. The elements may be listed explicitly or they may be described by a
condition
, e.g., the minimum over all x in the set A.
The elements must all be comparable if the result is to be well defined.
The min
operator is a are nary operators may use the domain of
application qualifiers as described in Section 4.4.10 Lifted Associative Commutative Operators. For
example, the min
and max
functions accept a bvar
schema
in cases where the maximum or minimum is being taken over a set of values
specified by a condition
schema together with an expression to be
evaluated on that set. In MathML1.0, the bvar
element was optional when
using a condition
; if a condition
element containing a single
variable was given by itself following a min
or max
operator,
the variable was implicitly assumed to be bound, and the expression to be
maximized or minimized (if absent) was assumed to be the single bound variable.
This usage is deprecated in MathML 2.0 in
favor of explicitly stating the bound variable(s) and the expression to be
maximized or minimized in all cases.
The min
and max
elements may also be applied to a list of
values in which case no qualifier schemata are used.
The element min
is used to compare the values of its arguments. It
returns the minimum of these values respectively.
Name  Value  Default 

type  MathMLType  real 
(algebraic*) > algebraic
(domainofapp,function) > algebraic
(bvar+,domainofapp,anything) > algebraic
Minimum of a finite listing of elements
<apply><min/><cn>2</cn><cn>3</cn><cn>5</cn></apply>
min(y^2, y in (0,1))
<apply> <min/> <bvar><ci>y</ci></bvar> <condition> <apply><in/><ci>y</ci><interval><cn>0</cn><cn>1</cn></interval></apply> </condition> <apply><power/><ci> y</ci><cn>2</cn></apply> </apply>
The elements to be compared may also be described using bound variables with a condition
element and an expression to be minimized, as in:
Note that the bound variable must be stated even if it might be implicit in conventional notation.
<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>
minus
This is the subtraction operator for an additive group.
If one argument is provided this operator constructs the additive inverse of that group element. If two arguments, say a and b, are provided it constructs the mathematical expression a  b.
The minus
element is the subtraction operator.
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).
Name  Value  Default 

type  MathMLType  real 
(real) > real
(algebraic) > algebraic
(real,real) > real
(algebraic,algebraic) > algebraic
[type=MathMLtype](MathMLtype) > MathMLtype
[type=MathMLtype](MathMLtype,MathMLtype) > MathMLtype
(set,set) > set
(multiset,multiset) > multiset
ForAll( x, xx=0 )
<apply><forall/> <bvar><ci> x </ci></bvar> <apply><eq/> <apply><minus/><ci> x </ci><ci> x </ci></apply> <cn>0</cn> </apply> </apply>
If this were evaluated at x=5 and y=2 it would yield 3.
<apply> <minus/> <ci> x </ci> <ci> y </ci> </apply>
<apply><minus/> <cn>3</cn> </apply>
plus
This is the nary addition operator of an algebraic structure. Ordinarily, the operands are provided explicitly. As an nary operation the operands can also be generated by allowing a function or expression vary over a domain of application though the sum element is normally used for that purpose. If no operands are provided, the expression represents the additive identity. If one operand, a, is provided the expression evaluates to "a". If two or more operands are provided, the expression represents the (semi) group element corresponding to a left associative binary pairing of the operands. The meaning of mixed operand types not covered by the signatures shown here are left up to the target system.
To use different type coercion rules different from those indicated by the signatures, use the definitionURL attribute to identify a new definition.
The plus
element is the addition operator.
As an nary operator, the operands may in principle also be provided using a
domain of application as described in Section 4.4.10 Lifted Associative Commutative Operators. However, such expressions can already be
represented explicitly using sum so the plus
does not normally take qualifiers.
Name  Value  Default 

type  MathMLType  real 
[type=MathMLtype](anything*) > MathMLtype
(set*) > set
(multiset*) > multiset
(algebraic*) > algebraic
(real*) > real
(complex*) > complex
(integer*) > integer
(domainofapp,function) > algebraic
(bvar+,domainofapp,algebraic) > algebraic
an sum of no terms is 0
<apply><eq/> <apply><plus/></apply> <cn>0</cn> </apply>
a sum of one term is equal to itself
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><plus/><ci>a</ci></apply> <cn>a</cn> </apply> </apply>
Commutativity
<apply><forall/> <bvar><ci>a</ci></bvar> <bvar><ci>b</ci></bvar> <condition> <apply><and/> <apply><in/><ci>a</ci><reals/></apply> <apply><in/><ci>b</ci><reals/></apply> </apply> </condition> <apply><eq/> <apply><plus/><ci>a</ci><ci>b</ci></apply> <apply><plus/><ci>b</ci><ci>a</ci></apply> </apply> </apply>
<apply><plus/> <cn>3</cn> </apply>
<apply><plus/> <cn>3</cn> <cn>5</cn> </apply>
If this were evaluated at x = 5, y = 2 and z = 1 it would yield 8.
<apply> <plus/> <ci> x </ci> <ci> y </ci> <ci> z </ci> </apply>
power
This is the binary powering operator that is used to construct expressions such as a "to the power of" b. In particular, it is the operation for which a "to the power of" 2 is equivalent to a * a.
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".
Name  Value  Default 

type  MathMLType  real 
(algebraic, algebraic) > algebraic
(complex, complex) > complex
(real, real) > complex
(rational, integer) > rational
(integer, integer) > rational
[type=MathMLtype](anything,anything) > MathMLtype
ForAll( a, a!=0, a^0=1 )
<apply><forall/> <bvar><ci>a</ci></bvar> <condition><apply><neq/><ci>a</ci><cn>0</cn></apply></condition> <apply><eq/> <apply><power/><ci>a</ci><cn>0</cn></apply> <cn>1</cn> </apply> </apply>
ForAll( a, a^1=a )
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><power/><ci>a</ci><cn>1</cn></apply> <ci>a</ci> </apply> </apply>
ForAll( a, 1^a=1 )
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><power/><cn>1</cn><ci>a</ci></apply> <cn>1</cn> </apply> </apply>
<apply><power/><cn>2</cn><ci>x</ci></apply>
<apply><power/><ci> x </ci><cn> 3 </cn></apply>
If this were evaluated at x= 5 it would yield 125.
<apply> <power/> <ci> x </ci> <cn> 3 </cn> </apply>
rem
This is the binary operator used to represent the integer remainder a mod b. For arguments a and b, such that a = b*q + r with r < b it represents the value r.
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.)
Name  Value  Default 

type  MathMLType  integer 
(integer, integer) > integer
[type=MathMLtype](MathMLtype,MathMLtype) > MathMLtype
rem(a, 0) is undefined
ForAll( [a,b], b!=0, a = b*quotient(a,b) + rem(a,b))
<apply><forall/> <bvar><ci>a</ci></bvar> <bvar><ci>b</ci></bvar> <condition><apply><neq/><ci>b</ci><cn>0</cn></apply></condition> <apply><eq/> <ci>a</ci> <apply><plus/> <apply><times/> <ci>b</ci> <apply><quotient/><ci>a</ci><ci>b</ci></apply> </apply> <apply><rem/> <ci>a</ci> <ci>b</ci> </apply> </apply> </apply> </apply>
If this were evaluated at a = 15 and b = 8 it would yield 7.
<apply><rem/><ci> a </ci><ci> b </ci></apply>
times
This is the nary multiplication operator of a ring. Ordinarily, the operands are provided explicitly. As an nary operation the operands can also be generated by allowing a function or expression vary over a domain of application though the product element is normally used for that purpose. If no arguments are supplied then this represents the multiplicative identity. If one argument is supplied, this represents an expression that would evaluate to that single argument.
The times
element is the nary multiplication operator.The operands
are usually listed explicitly. As an nary operator, the operands may in
principle also be provided using a domain of application as described in
Section 4.4.10 Lifted Associative Commutative Operators. However, such expressions can already be
represented explicitly by using product so the
times
does not normally take qualifiers.
Name  Value  Default 

type  MathMLType  real 
(algebraic*) > algebraic
(complex*) > complex
(real*) > real
(rational*) > rational
(integer*) > integer
(domainofapp,function) > algebraic
(bvar+,domainofapp,anything) > algebraic
ForAll( [a,b], condition(in({a,b}, Commutative)), a*b=b*a )
ForAll( [a,b,c], Associative, a*(b*c)=(a*b)*c ), associativity
multiplicative identity
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><times/><cn>1</cn><ci>a</ci></apply> <ci>a</ci> </apply> </apply>
a*0=0
Commutative property
<apply><forall/> <bvar><ci>a</ci></bvar> <bvar><ci>b</ci></bvar> <condition> <apply><and/> <apply><in/><ci>a</ci><reals/></apply> <apply><in/><ci>b</ci><reals/></apply> </apply> </condition> <apply><eq/> <apply><times/><ci>a</ci><ci>b</ci></apply> <apply><times/><ci>b</ci><ci>a</ci></apply> </apply> </apply>
a*0=0
<apply><forall/> <bvar><ci>a</ci></bvar> <apply><eq/> <apply><times/><cn>0</cn><ci>a</ci></apply> <cn>0</cn> </apply> </apply>
If this were evaluated at a = 5.5 and b = 3 it would yield 16.5.
<apply><times/><ci>a</ci><ci>b</ci></apply>
root
This is the binary operator used to construct the nth root of an expression. The first argument "a" is the expression and the second object "n" denotes the root, as in ( a ) ^ (1/n)
The root
element is used to construct roots. The kind of root to be
taken is specified by a "degree" child, 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.
Note that MathML3 supports a degree
element in the legacy container representation (see Section 4.4.8 degree for details). If no degree
is present, a default
value of 2 is used.
Name  Value  Default 

type  real  complex  principal_branch  MathMLType  real 
(algebraic) > root(degree(2),algebraic)
(anything) > root(degree(2),anything)
(degree,anything) > root
ForAll( bvars(a,n), root(degree(n),a) = a^(1/n) )
The nth root of a is is given by
<apply><root/> <degree><ci> n </ci></degree> <ci> a </ci> </apply>
gcd
This is the nary operator used to construct an expression which represents the greatest common divisor of its arguments. If no argument is provided, the gcd is 0. If one argument is provided, the gcd is that argument.
Name  Value  Default 

type  MathMLType  integer 
[type=MathMLtype](MathMLtype*) >MathMLtype
(integer*) > integer
(domainofapp,function) > algebraic
(bvar+,domainofapp,algebraic) > algebraic
<apply><forall/> <forall/> <bvar><ci>x</ci></bvar> <apply><eq/> <apply><gcd/> <ci>x</ci> <cn>1</cn> </apply> <cn>1</cn> </apply> </apply>
<apply><gcd/> <cn>12</cn> <cn>17</cn> </apply>
<apply><gcd/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </apply>
If this were evaluated at a = 15, b = 21, c = 48, it would yield 3
<apply> <gcd/> <ci> a </ci> <ci> b </ci> <ci> c </ci> </apply>
and
This is the nary logical "and" operator. It is used to construct the logical expression which were it to be evaluated would have a value of "true" when all of its operands have a truth value of "true", and "false" otherwise.
The and
element is the Boolean "and" operator.
As an nary operator, its operands may also be generated as described inSection 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
Name  Value  Default 

type  MathMLType  boolean 
(boolean*) > boolean
ForAll( p, (true and p = p) )
ForAll( [p,q], (p and q = q and p) )
x and not(x) = false
If this were evaluated and both a and b had truth values of "true", then the result would be "true".
<apply><and/> <ci>a</ci> <ci>b</ci> </apply>
or
The is the nary logical "or" operator. The constructed expression has a truth value of true if at least one of its arguments is true.
The or
element is the Boolean "or" operator.
As an nary operator, its operands may also be generated as described inSection 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
Name  Value  Default 

type  MathMLType  boolean 
(boolean*) > boolean
[type="boolean"](symbolic*) > boolean
<apply> <or/> <ci> a </ci> <ci> b </ci> </apply>
xor
The is the nary logical "xor" operator. The constructed expression has a truth value of true if an odd number of its arguments are true.
As an nary operator, its operands may also be generated as described inSection 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
Name  Value  Default 

type  MathMLType  boolean 
(boolean*) > boolean
[type="boolean"](symbolic*) > symbolic
x xor x = false
x xor not(x) = true
<apply> <xor/> <ci> a </ci> <ci> b </ci> </apply>
not
This is the unary logical "not" operator. It negates the truth value of its single argument. e.g., not P is true when P is false and false when P is true.
The not
operator is the Boolean"not" operator.
Name  Value  Default 

type  MathMLType  boolean 
(boolean) > boolean
[type="boolean"](algebraic) > boolean
<apply> <not/> <ci> a </ci> </apply>
implies
This is the binary "implies" operator. It is used to construct the logical expression "A implies B".
The implies
element is the Boolean relational operator
"implies".
Name  Value  Default 

type  MathMLType  boolean 
(boolean,boolean) > boolean
false implies x
Mathematical applications designed for the evaluation of such expressions would evaluate this to "true" when a = "false" and b = "true".
<apply> <implies/> <ci> A </ci> <ci> B </ci> </apply>
forall
The forall operator is the logical "For all" quantifier. The bound variables, if any, appear first and are tagged using the bvar element. Next comes an optional condition on the bound variables. The last argument is the boolean expression that is asserted to be true for all values of the bound variables that meet the specified conditions (if any).
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.7 Qualifiers in
which case the assertion corresponds to applying the function to an element of
the specified domain., which should take the form of an apply
element.
The universal quantifier forall
is used in conjunction with one or
more bvar
schemata to represent simple logical assertions. There are
two main main ways of using the logical quantifier operators. The first usage is
for representing a simple, quantified assertion. For example, the statement
"there exists x < 9" would be represented as:
<bind> <exists/> <bvar><ci> x </ci></bvar> <apply><lt/><ci>x</ci><cn>9</cn></apply> </bind>
The second usage is for representing implications. Hypotheses are given by a
condition
element following the bound variables. For example the statement
"for all x < 9, x < 10" would be represented as:
<bind> <forall/> <bvar><ci>x</ci></bvar> <condition><apply><lt/><ci>x</ci><cn>9</cn></apply></condition> <apply><lt/><ci>x</ci><cn>10</cn></apply> </bind>
Note that in both these usages one or more bvar
qualifiers are mandatory.
Name  Value  Default 

type  MathMLType  boolean 
(domainofapp,function) > boolean
(bvar+,domainofapp?,boolean) > boolean
The 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 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 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>
<apply> <forall/> <bvar><ci> x </ci></bvar> <condition><apply><lt/><ci> x </ci><cn> 0 </cn></apply></condition> <ci> x </ci> </apply>
exists
This is the MathML operator that is used to assert existence, as in "There exists an x such that x is real and x is positive."
 The first argument indicates the bound variable,
 The second optional argument places conditions on that bound variable.
 The last argument is the expression that is asserted to be true.
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.7 Qualifiers. For such uses the assertion is obtained
by applying the function to an element of the specified domain.
The universal quantifier forall
is used in conjunction with one or
more bvar
schemata to represent simple logical assertions. There are
two main main ways of using the logical quantifier operators. The first usage is
for representing a simple, quantified assertion. For example, the statement
"there exists x < 9" would be represented as:
<bind> <exists/> <bvar><ci> x </ci></bvar> <apply><lt/><ci>x</ci><cn>9</cn></apply> </bind>
The second usage is for representing implications. Hypotheses are given by a
condition
element following the bound variables. For example the statement
"for all x < 9, x < 10" would be represented as:
<bind> <forall/> <bvar><ci>x</ci></bvar> <condition><apply><lt/><ci>x</ci><cn>9</cn></apply></condition> <apply><lt/><ci>x</ci><cn>10</cn></apply> </bind>
Note that in both these usages one or more bvar
qualifiers are mandatory.
Name  Value  Default 

type  MathMLType  boolean 
(bvar+,boolean) > boolean
(bvar+,domainofapp,anything) > boolean
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><ci>f</ci> <ci>x</ci> </apply> <cn>0</cn> </apply> </apply>
<apply> <exists/> <bvar><ci> x </ci></bvar> <domainofapplication> <ci type="set">C</ci> </domainofapplication> <apply> <eq/> <apply> <power/><ci>x</ci><cn>2</cn> </apply> <cn>4</cn> </apply> </apply>
abs
A unary operator which represents the absolute value of its argument. In the complex case this is often referred to as the modulus.
The abs
element represents the absolute value of a real quantity or
the modulus of a complex quantity.
Name  Value  Default 

type  MathMLType  real 
(algebraic) > algebraic
(real) > real
(complex) > real
for all x and y, abs(x) + abs(y) >= abs(x+y)
The following example encodes the absolute value of x.
<apply><abs/><ci>x</ci></apply>
conjugate
The unary "conjugate" arithmetic operator is used to represent the complex conjugate of its argument.
The conjugate
element represents the complex conjugate of a complex quantity.
(algebraic) > algebraic
(complex) > complex
The following example encodes the conjugate of x + iy.
<apply><conjugate/> <apply><plus/> <ci> x </ci> <apply><times/> <cn> ⅈ </cn> <ci> y </ci> </apply> </apply> </apply>
arg
The unary "arg" operator is used to construct an expression which represents the "argument" of a complex number.
The arg
operator 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 + .
Name  Value  Default 

type  MathMLType  real 
(complex) > real
The following example encodes the argument operation onx + iy.
<apply><arg/> <apply><plus/> <ci> x </ci> <apply><times/><imaginaryi/><ci>y</ci></apply> </apply> </apply>
real
A unary operator used to construct an expression representing the "real" part of a complex number.
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
Name  Value  Default 

type  MathMLType  real 
(complex) > real
ForAll( [x,y], x in R, Y in R, real(x+i*y)=x) )
<apply><forall/> <bvar><ci>x</ci></bvar> <bvar><ci>y</ci></bvar> <condition> <apply><and/> <apply><in/><ci>x</ci><reals/></apply> <apply><in/><ci>y</ci><reals/></apply> </apply> </condition> <apply><eq/> <apply><real/> <apply><plus/> <ci> x </ci> <apply><times/><imaginaryi/><ci>y</ci></apply> </apply> </apply> <ci> x </ci> </apply> </apply>
The following example encodes the real operation onx + iy.A MathMLaware evaluation system would return the x component, suitably encoded.
<apply><real/> <apply><plus/> <ci> x </ci> <apply><times/><imaginaryi/><ci>y</ci></apply> </apply> </apply>
imaginary
The unary function used to construct an expression which represents the imaginary part of a complex number.
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.
Name  Value  Default 

type  MathMLType  real 
(complex) > real
ForAll( [x,y], Imaginary(x + i*y) = y )
<apply><forall/> <bvar><ci type="real"> x </ci></bvar> <bvar><ci type="real"> y </ci></bvar> <apply><eq/> <apply><imaginary/> <apply><plus/> <ci type="real"> x </ci> <apply><times/><imaginaryi/><ci>y</ci></apply> </apply> </apply> <ci type="real"> y </ci> </apply> </apply>
The following example encodes the imaginary operation on x + iy.A MathMLaware evaluation system would return the y component, suitably encoded.
<apply><imaginary/> <apply><plus/> <ci> x </ci> <apply><times/><imaginaryi/><ci>y</ci></apply> </apply> </apply>
lcm
This nary operator is used to construct an expression which represents the least common multiple of its arguments. If no argument is provided, the lcm is 1. If one argument is provided, the lcm is that argument. The least common multiple of x and 1 is x.
The
lcm
element (introduced in MathML 2.0) is used to denote the lowest common
multiple of its arguments.
As an nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
Name  Value  Default 

type  MathMLType  integer 
[type=MathMLtype](MathMLtype*) > MathMLtype
(integer*) > integer
(algebraic*) > algebraic
(domainofapp,function) > algebraic
(bvar+,domainofapp,anything) > algebraic
ForAll( x, lcm(x,1)=x )
<apply><forall/> <bvar><ci>x</ci></bvar> <apply><eq/> <apply><lcm/><ci>x</ci><cn>1</cn></apply> <ci>x</ci> </apply> </apply>
<apply><lcm/> <cn>12</cn> <cn>17</cn> </apply>
<apply><lcm/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </apply>
If this were evaluated at a = 2, b = 4, c = 6 it would yield 12.
<apply> <lcm/> <ci> a </ci> <ci> b </ci> <ci> c </ci> </apply>
floor
The floor element is used to denote the rounddown (towards infinity) operator.
The floor
element (introduced in MathML 2.0) is used to denote the
rounddown (towards infinity) operator.
Name  Value  Default 

type  MathMLType  integer 
(real) > integer
[type=MathMLtype](algebraic) > algebraic
ForAll( x, floor(x) <= x )
<apply><forall/> <bvar><ci>x</ci></bvar> <apply><leq/> <apply><floor/> <ci>x</ci> </apply> <ci>x</ci> </apply> </apply>
If this were evaluated at a = 15.015, it would yield 15.
<apply> <floor/> <ci> a </ci> </apply>
<apply> <forall/> <bvar><ci> a </ci></bvar> <apply><and/> <apply><leq/> <apply><floor/> <ci>a</ci> </apply> <ci>a</ci> </apply> <apply><lt/> <ci>a</ci> <apply><plus/> <apply><floor/> <ci>a</ci> </apply> <cn>1</cn> </apply> </apply> </apply> </apply>
ceiling
The ceiling element is used to denote the roundup (towards +infinity) operator.
The ceiling
element (introduced in MathML 2.0) is used
to denote the roundup (towards +infinity) operator.
Name  Value  Default 

type  MathMLType  integer 
(real) > integer
[type=MathMLtype](algebraic) > algebraic
ForAll( x, ceiling(x) >= x )
<apply><forall/> <bvar><ci>x</ci></bvar> <apply><geq/> <apply><ceiling/> <ci>x</ci> </apply> <ci>x</ci> </apply> </apply>
If this were evaluated at a = 15.015, it would yield 16.
<apply> <ceiling/> <ci> a </ci> </apply>
<apply> <forall/> <bvar><ci> a </ci></bvar> <apply><and/> <apply><lt/> <apply><minus/> <apply><ceiling/> <ci>a</ci> </apply> <cn>1</cn> </apply> <ci>a</ci> </apply> <apply><leq/> <ci>a</ci> <apply><ceiling/> <ci>a</ci> </apply> </apply> </apply> </apply>
eq
This nary function is used to indicate that two or more quantities are equal. There must be at least two arguments.
The eq
element is the relational operator
"equals".
As an nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(real,real+) > boolean
(boolean, boolean+) > boolean
(set,set+) > set
(multiset,multiset+) > multiset
(domainofapp,function) > boolean
(bvar+,domainofapp,anything) > boolean
Symmetric
Transitive
Reflexive
<apply><eq/> <cn type="rational">2<sep/>4</cn><cn type="rational">1<sep/>2</cn> </apply>
<apply><eq/><ci type="set">A</ci><ci type="set">B</ci></apply>
<apply><eq/><ci type="multiset">A</ci><ci type="multiset">B</ci></apply>
If this were tested at a = 5.5 and b = 6 it would yield the truth value false.
<apply><eq/><ci> a </ci><ci> b </ci></apply>
neq
This binary relation represents the relation "not equal to" which returns true unless the two arguments are equal.
The neq
element is the "not equal to" relational
operator.
The neq
element is a binary
relation.
(real,real) > boolean
(boolean,boolean) > boolean
(set,set) > set
(multiset,multiset) > multiset
Symmetric
<apply><neq/><cn>3</cn><cn>4</cn></apply>
If this were tested at a = 5.5 and b = 6 it would yield the truth value true.
<apply> <neq/> <ci> a </ci> <ci> b </ci> </apply>
gt
This nary function represents the relation "greater than" which returns true if each argument in turn is greater than the one following it. There must be at least two arguments.
The gt
element is the "greater than" relational
operator.
The gt
element is an nary relation. As an nary
operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(real,real+) > boolean
(domainofapp,function) > boolean
(bvar+,domainofapp,algebraic) > boolean
Transitive
<apply><gt/><cn>3</cn><cn>2</cn></apply>
If this were tested at a = 5.5 and b = 6 it would yield the truth value false.
<apply><gt/><ci>a</ci><ci>b</ci></apply>
lt
(role: application)
This nary function represents the relation "less than" which returns true if each argument in turn is less than the one following it. There must be at least two arguments.
The lt
element is the "less than" relational
operator.
The lt
element is an nary relation. As an nary
operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(real,real+) > boolean
( domainofapp , function ) > boolean
( bvar+ , domainofapp , algebraic) > boolean
Transitive
<apply><lt/><cn>2</cn><cn>3</cn><cn>4</cn></apply>
If this were tested at a = 5.5 and b = 6 it would yield the truth value "true".
<apply> <lt/> <ci> a </ci> <ci> b </ci> </apply>
geq
This element represents the nary greater than or equal to function. which returns true if each argument in turn is greater than or equal to the one following it. . There must be at least two arguments.
The geq
element is the relational operator "greater than or
equal".
The geq
element is an nary relation. As an nary
operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(real,real+) > boolean
( domainofapp , function ) > boolean
( bvar+ , domainofapp , algebraic ) > boolean
Transitive
Reflexive
<apply><geq/><cn>4</cn><cn>3</cn><cn>3</cn></apply>
If this were tested for a = 5.5 and b = 5.5 it would yield the truth value true.
<apply> <geq/> <ci> a </ci> <ci> b </ci> </apply>
leq
This nary function represents the relation "less than or equal to" which returns true if each argument in turn is less or equal to the one following it. There must be at least two arguments.
The leq
element is the relational operator "less than or
equal".
The leq
element is an nary relation. As an nary
operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(real,real+) > boolean
( domainofapp , function ) > boolean
( bvar+ , domainofapp , arithmetic ) > boolean
Transitive
Reflexive
<apply><leq/><cn>3</cn><cn>3</cn><cn>4</cn></apply>
If a = 5.4 and b = 5.5 this will yield the truth value true.
<apply> <leq/> <ci> a </ci> <ci> b </ci> </apply>
equivalent
This element represents the nary logical equivalence function in which two boolean expressions are said to be equivalent if their truth values are equal for all choices of values of the boolean variables appearing in them.
The equivalent
element is the "equivalence" relational
operator.
Its operands may be generated by allowing a function or expression to vary over a domain of application. Therefore it may take qualifiers.
(boolean,boolean+) > boolean
(domainofapp,function) > boolean
(bvar+,domainofapp,boolean) > boolean
Symmetric
Transitive
Reflexive
This yields the truth value true for all values of a.
<apply> <equivalent/> <ci> a </ci> <apply> <not/> <apply> <not/> <ci> a </ci> </apply> </apply> </apply>
approx
This element is used to indicate that two or more quantities are approximately equal. If a more precise definition of approximately equal is required the definintionURL should be used to identify a suitable definition.
The approx
element is the relational operator "approximately
equal". This is a generic relational operator and no specific arithmetic
precision is implied
Name  Value  Default 

type  MathMLType  real 
(real,real+) > boolean
(domainofapp,function) > boolean
(bvar+,domainofapp,boolean) > boolean
Symmetric
Transitive
Reflexive
<apply><approx/><pi/><cn type="rational">22<sep/>7</cn></apply>
factorof
This is the binary MathML operator that is used indicate the mathematical relationship a "is a factor of" b. This relationship is true just if b mod a = 0
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 is an binary relational
operator
Name  Value  Default 

type  MathMLType  integer 
(integer, integer) > boolean
ForAll( [a,b], a and b integers, a divides b if there is an integer c such that a*c = b )
<apply><factorof/> <ci> a </ci> <ci> b </ci> </apply>
int
The indefinite integral of a function.
The int
element is the operator element for an integral.
(function) > function
The integral over the sine function is cosine function.
<apply><eq/><apply><int/><sin/></apply><cos/></apply>
int
The definite integral of a function over a domain of application.
The defint
element is the operator element for function over a domain
of integration.
(set,function) > function
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><defint/> <interval><ci>a</ci><ci>b</ci></interval> <cos/> </apply>
<apply><defint/><ci type="set">D</ci><ci type="function">f</ci></apply>
int
The definite (without condition
or indefinite (with) integral of an
algebraic expression with respect to a bound variable.
The Int
element is the operator element for an integral, bound variables
serve as the integration variables and definite integrals are indicated by providing
a domain of integration.
(bvar,algebraic) > algebraic
(bvar+,domainofapp,algebraic) > algebraic
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/> </bind>
This example specifies the integrand using an expression involving a bound variable and an interval
<bind><Int/> <bvar><ci>x</ci></bvar> <domainofapplication><apply><interval/><ci>a</ci><ci>b</ci></apply></domainofapplication> <apply><cos/><ci>x</ci></apply> </bind>
<bind><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> </bind>
diff
The diff
element is the differentiation operator element for
functions of a single variable.
diff
is applied directly to an actual function such as sine or
cosine, thereby denoting a function which is the derivative of the original
function, as in
<apply><diff/><ci type="function>f</ci></apply>
If diff
is given a number n as a second argument, then it is
interpreted as a nfold differentiation operator.
<apply><ndiff/><cn>2</cn><ci type="function>f</ci></apply>
function > function
diff(sin) = cos
<apply><eq/><apply><diff/><sin/></apply><cos/></apply>
diff (2,sin) = sin
<apply><eq/><apply><ndiff/><cn>2</cn><sin/></apply><sin/></apply>
Diff
Diff
is the algebraic differentiation operator.
Issue algebraic_diff  wiki (member only) ISSUE10 (member only) 

Algebraic differentiation operator  
In the For seeing how things work out in the concert of things, I have added an


Resolution  None recorded 
Diff
is the binding operator for operator takes two (or three)
arguments: an expression involving a single variable such as sin(x),
or cos(x) or a polynomial in x and the variable modulo
which the derivative is being taken. For instance:
<bind><Diff/> <bvar><ci>x</ci></bvar> <apply><ci>f</ci><ci>x</ci></apply><ci>x</ci> </bind>
If Diff
is given a number n as a third argument, then it
is interpreted as a nfold algebraic differentiation operator.
Issue algebraic_ndiff  wiki (member only) ISSUE10 (member only) 

nfold algebraic differentiation  
I have some trouble representing the iterated differentiation operator. I actually think that the degree should be something that is a parameter to the binding operator, so the following would be the most natural representation. <bind> <apply><Diff/><cn>3</cn></apply> <bvar><ci>x</ci></bvar> <apply><ci>f</ci><ci>x</ci></apply> </apply>
But this messes up the 

Resolution  None recorded 
(var,algebraic) > algebraic
ForAll( [x,n], n!=0, diff( x^n , x ) = n*x^(n1) )
diff( sin(x) , x ) = cos
<apply><eq/> <bind><Diff/> <bvar><ci>x</ci></bvar> <apply><sin/><ci>x</ci></apply> </bind> <apply><cos/><ci>x</ci></apply> </apply>
Diff(x^2,x)
<apply><Diff/> <apply><power/><ci>x</ci><cn>2</cn></apply> <ci>x</ci> </apply>
Diff(f(x),x)
The derivative with respect to x of an expression in x such as f (x) can be written as:
<apply><Diff/> <apply><ci type="function">f</ci><ci>x</ci></apply> <ci>x</ci> </apply>
anDiff( sin(x) , x, 2) = sin(x)
<apply><eq/> <apply><Diff/> <apply><sin/><ci>x</ci></apply> <ci>x</ci> <cn>2</cn> </apply> <apply><sin/><ci>x</ci></apply> </apply>
partialdiff
This symbol is used to express partial differentiation. It occurs in two forms: one form corresponding to the differentiation of algebraic expressions (often displayed using the Leibnitz notation), and the other to express partial derivatives of actual functions (often expressed as $D_{1,2} f $ )
For the first form, the arguments are the bound variables followed by the algebraic expression. The result is an algebraic expression. Repetitions of the bound variables are indicated using the degree element. The total degree is indicated by use of a degree element at the top level.
For the second form, there are two arguments: a list of indices indicating by position which coordinates are involved in constructing the partial derivatives, and the actual function. The coordinates may be repeated.
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
operator accepts zero or more bvar
schemata, and an optional degree
qualifier schema. The bvar
schema specify, in order, the variables with respect to which the derivative is
being taken. Each bvar
element may contain a degree
schema
which is used to specify the order of the derivative being taken with respect to
that variable. The optional degree
schema qualifier associated with the
partialdiff
element itself (that is, appearing as a child of the
enclosing apply
element rather than of one of the bvar
qualifiers) is used to represent the total degree of the differentiation. Each
degree
schema used with partialdiff
is expected to contain a
single child schema. For example,
<bind><partialdiff/> <bvar> <degree><cn>2</cn></degree> <ci>x</ci> </bvar> <bvar><ci>y</ci></bvar> <bvar><ci>x</ci></bvar> <degree><cn>4</cn></degree> <ci type="function">f</ci> </apply>
denotes the mixed partial derivative ( d^{4} / d^{2}x dy dx ) f.
Name  Value  Default 

type  function  algebraic  algebraic 
(bvar+,degree?,algebraic) > algebraic
(vector,function) > function
ForAll( [x,y], partialdiff( x * y , x ) = partialdiff(x,x)*y + partialdiff(y,x)*x )
ForAll( [x,a,b], partialdiff( a + b , x ) = partialdiff(a,x) + partialdiff(b,x) )
d^k/(dx^m dy^n) f(x,y)
<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>
d^2/(dx dy) f(x,y)
<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>
D_{1,1,3}(f)
<apply><partialdiff/> <list><cn>1</cn><cn>1</cn><cn>3</cn></list> <ci type="function">f</ci> </apply>
divergence
This symbol is used to represent the divergence function.
Given, one argument which is a vector of scalar valued functions defined on the coordinates x_1, x_2, ... x_n. It returns a scalar value function. That function satisfies the defining relation:
divergence(F) = \partial(F_(x_1))/\partial(x_1) + ... + \partial(F_(x_n))/\partial(x_n)
The functions defining the coordinates may be defined implicitly as expressions defined in terms of the coordinate names, in which case the coordinate names must be provided as bound variables.
The divergence
element is the vector calculus divergence operator,
often called div.
(vector(function)) > function
(bvar+,vector(algebraic)) > algebraic
<apply> <divergence/> <ci> a </ci> </apply>
<apply><divergence/><ci type="vector"> E</ci></apply>
<declare><ci>F</ci><vector><ci>f1</ci><ci>f2</ci><ci>f3</ci></vector></declare> <apply><divergence/><ci>F</ci></apply>
<apply><divergence/> <bvar><ci>x</ci></bvar><bvar><ci>y</ci></bvar><bvar><ci>z</ci></bvar> <vector> <apply><plus/><ci>x</ci><ci>y</ci></apply> <apply><plus/><ci>x</ci><ci>z</ci></apply> <apply><plus/><ci>z</ci><ci>y</ci></apply> </vector> </apply>
If a is a vector field defined inside a closed surface S enclosing a volume V, then the divergence of a is given by
<apply> <eq/> <apply><divergence/><ci type="vectorfield">a</ci></apply> <apply> <limit/> <bvar><ci> V </ci></bvar> <condition> <apply> <tendsto/> <ci> V </ci> <cn> 0 </cn> </apply> </condition> <apply> <divide/> <apply> <int encoding="text" definitionURL="SurfaceIntegrals.htm"/> <bvar><ci> S</ci></bvar> <ci> a </ci> </apply> <ci> V </ci> </apply> </apply> </apply>
grad
The gradient element is the vector calculus gradient operator, often called grad. It represents the operation that constructs a vector of partial derivatives vector( df/dx_1 , df/dx_2, ... df/dx_n )
The grad
element is the vector calculus gradient operator, often
called grad.
(function) > vector(function)
(bvar+,algebraic) > vector(algebraic)
Where for example f is a scalar function of three real variables.
<apply><grad/><ci type="function"> f</ci></apply>
<apply><grad/> <bvar><ci>x</ci></bvar><bvar><ci>y</ci></bvar><bvar><ci>z</ci></bvar> <apply><times/><ci>x</ci><ci>y</ci><ci>z</ci></apply> </apply>
curl
This symbol is used to represent the curl operator. It requires both a coordinates and a vector of expressions defined over those coordinates. It returns a vector valued expression.
In its functional form the coordinates are implicit in the definition of the function so it needs only one argument which is a vector valued function and returns a vector of functions.
Given F = F(x,y,z) = ( f1(x,y,z) , f2(x,y,z), f3(x,y,z) ) and coordinate names (x,y,z) the following relationship must hold:
curl(F) = i X \partial(F)/\partial(x) + j X \partial(F)/\partial(y) + j X \partial(F)/\partial(Z) where i,j,k are the unit vectors corresponding to the x,y,z axes respectivly and the multiplication X is cross multiplication.
The curl
element is the vector calculus curl operator.
(bvar,bvar,bvar,algebraic) > vector(algebraic)
(vector(function) ) > vector(function)
curl(F) = i X \partial(F)/\partial(x) + j X \partial(F)/\partial(y) + j X \partial(F)/\partial(Z)
Where for example a is a vector field.
<apply><curl/><ci>a</ci></apply>
<apply><curl/><ci type="vector">f</ci></apply>
laplacian
This is the element used to indicate an application of the laplacian operator. It may be applied directly to expressions, in which case the coordinate names are provided in order by use of bvar. It may also be applied directly to a function F in which case, the definition below is for F = F(x_1, x_2, ... x_n) where x_1, x_2, ... x_n are the coordinate names.
laplacian(F) = \partial^2(F)/\partial(x_1)^2 + ... + \partial^2(F)/\partial(x_n)^2
The laplacian
element is the vector calculus
laplacian operator.
(bvar+,algebraic) > algebraic
(scalar_valued_function) > scalar_valued_function
<apply><laplacian/><ci type="vector"> E</ci></apply>
<declare><ci>F</ci><vector><ci>f1</ci><ci>f2</ci><ci>f3</ci></vector></declare> <apply><laplacian/><ci>F</ci></apply>
<apply><laplacian/> <bvar><ci>x</ci></bvar><bvar><ci>y</ci></bvar><bvar><ci>z</ci></bvar> <apply><ci>f</ci> <ci>x</ci><ci>y</ci> </apply> </apply>
Where for examplef is a scalar function of three real variables.
<apply> <eq/> <apply><laplacian/> <ci> f </ci> </apply> <apply> <divergence/> <apply><grad/> <ci> f </ci> </apply> </apply> </apply>
set
The set element is the container element that constructs a set of elements. They may be explicitly listed, or defined by expressions or functions evaluated over a domain of application. The domain of application may be given explicitly, or provided by means of one of the shortcut notations.
Editorial note: MiKo  
Take the list and set parts of the discussion apart and
make the MMLdefinition s selfcontained, maybe move some of the discussion
into the CD description

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.7 Qualifiers.
The type
attribute indicates type of the set. Predefined values:
"normal", "multiset". "multiset"
indicates that repetitions are allowed. The default value is
"normal".
Issue type_on_set  wiki (member only) 

Keep type attribute on set ?


It seems very awkward to keep this, it would probably be better to have an


Resolution  None recorded 
The child elements of a possibly empty list
element are the actual
components of an ordered list. For example, an ordered list of the
three symbols a, b, and c is encoded as
<list><ci>a</ci><ci>b</ci><ci>c</ci></list>
Sets and lists can also be constructed by evaluating a function over a domain of
application, each evaluation corresponding to a term of the set or list. In the
most general form a domain is explicitly specified by a domainofapplication
element together with optional bvar
elements. Qualifications involving a
domainofapplication
element can be abbreviated in several ways as described
in Section 4.2.7 Qualifiers. For example, a bvar
and a
condition
element can be used to define lists where membership depends on
satisfying certain conditions.
An order
attribute can be used to specify what ordering is to be
used. When the nature of the child elements permits, the ordering defaults to a
numeric or lexicographic ordering.
Sets are structured much the same as lists except that there is no implied
ordering and the type
of set may be "normal" or
"multiset" with "multiset" indicating that repetitions
are allowed.
For both sets and lists, the child elements must be valid MathML content elements. The type of the child elements is not restricted. For example, one might construct a list of equations, or of inequalities.
The child elements of a possibly empty list
element are the actual
components of an ordered list. For example, an ordered list of the
three symbols a, b, and c is encoded as
<list><ci>a</ci><ci>b</ci><ci>c</ci></list>
Sets and lists can also be constructed by evaluating a function over a domain of
application, each evaluation corresponding to a term of the set or list. In the
most general form a domain is explicitly specified by a domainofapplication
element together with optional bvar
elements. Qualifications involving a
domainofapplication
element can be abbreviated in several ways as described
in Section 4.2.7 Qualifiers. For example, a bvar
and a
condition
element can be used to define lists where membership depends on
satisfying certain conditions.
An order
attribute can be used to specify what ordering is to be
used. When the nature of the child elements permits, the ordering defaults to a
numeric or lexicographic ordering.
Sets are structured much the same as lists except that there is no implied
ordering and the type
of set may be "normal" or
"multiset" with "multiset" indicating that repetitions
are allowed.
For both sets and lists, the child elements must be valid MathML content elements. The type of the child elements is not restricted. For example, one might construct a list of equations, or of inequalities.
Name  Value  Default 

order  lexicographic  numeric  none 
(anything*) > list
[order=ordering](anything*) > list
(domainofapp,function) > list
(bvar+,domainofapp,anything) > list
[order=ordering](domainofapp,function) > list(ordering)
[order=ordering](bvar*,domainofapp,anything) > list(ordering)
<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> </list>
list
The list element is the container element that constructs a list of elements. They may be explicitly listed, or defined by expressions or functions evaluated over a domain of application. The domain of application may be given explicitly, or provided by means of one of the shortcut notations.
Name  Value  Default 

order  lexicographic  numeric  none 
(anything*) > list
[order=ordering](anything*) > list
(domainofapp,function) > list
(bvar+,domainofapp,anything) > list
[order=ordering](domainofapp,function) > list(ordering)
[order=ordering](bvar*,domainofapp,anything) > list(ordering)
<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> </list>
union
This is the settheoretic operation of union of sets. This nary operator generalizes to operations on multisets by tracking the frequency of occurrence of each element in the union. As an nary operation the operands can be generated by allowing a function or expression to range over the elements of a domain of application. Thus it accepts qualifiers.
The union
element is the operator for a settheoretic union or join
of two (or more) sets. The operands are usually listed explicitly.
As an nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(set*) > set
(multiset*) > multiset
(domainofapp, set_valued_function) > set
(bvar+,domainofapp,set_valued_expression) > set
(domainofapp, multiset_valued_function) > multiset
(bvar+,domainofapp,multiset_valued_expression) > multiset
<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>
intersect
This nary operator indicates the intersection of two sets. If the two sets are multisets, the result is a multiset. in which each element is present with a repetition determined by the smallest number of occurrences in any of the sets (multisets) that occur as arguments.
The intersect
element is the operator for the settheoretic
intersection or meet of two (or more) sets. The operands are usually listed
explicitly.
As an nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(set*) > set
(multiset*) > multiset
(domainofapp, set_valued_function) > set
(bvar+,domainofapp,set_valued_expression) > set
(domainofapp, multiset_valued_function) > multiset
(bvar+,domainofapp,multiset_valued_expression) > multiset
<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>
in
The in element is the relational operator used for a settheoretic inclusion ('is in' or 'is a member of').
The in
element is the relational operator used for a settheoretic
inclusion ("is in" or "is a member of").
The in
element is a binary set relation.
(anything,set) > boolean
(anything,multiset) > boolean
<apply><in/> <ci> a </ci> <ci type="set"> A </ci> </apply>
notin
The notin element is the relational operator element used to construct settheoretic exclusion ('is not in' or 'is not a member of').
The notin
element is the relational operator element used for
settheoretic exclusion ("is not in" or "is not a member
of").
The notin
element is a binary set relation.
(anything,set) > boolean
(anything,multiset) > boolean
<apply><notin/> <ci> a </ci> <ci type="set"> A </ci> </apply>
subset
The subset element is the nary relational operator element for a settheoretic containment ('is a subset of').
The subset
element is the relational operator element for a
settheoretic containment ("is a subset of").
The subset
element is an nary set relation. As an
nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(set*) > boolean
(multiset*) > boolean
(domainofapp,function) > boolean
(bvar+,domainofapp,algebraic) > boolean
<apply><subset/> <ci type="set"> A </ci> <ci type="set"> B </ci> </apply>
<apply> <subset/> <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>
prsubset
The prsubset
element is the nary relational operator element for
settheoretic proper containment ('is a proper subset of').
The prsubset
element is the relational operator element for
settheoretic proper containment ("is a proper subset of").
The prsubset
element is an nary set relation. As an
nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(set*) > boolean
(multiset*) > boolean
(domainofapp,function) > boolean
(bvar+,domainofapp,boolean) > boolean
<apply><prsubset/> <ci type="set"> A </ci> <ci type="set"> 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>
notsubset
The notsubset element is the relational operator element for the settheoretic relation 'is not a subset of'.
The notsubset
element is the relational operator element for the
settheoretic relation "is not a subset of".
The notsubset
element is a binary set relation.
(set, set) > boolean
(multiset,multiset) > boolean
<apply><notsubset/> <ci type="set"> A </ci> <ci type="set"> B </ci> </apply>
notprsubset
The notprsubset element is the element for constructing the settheoretic relation 'is not a proper subset of'.
The notprsubset
element is the operator element for the
settheoretic relation "is not a proper subset of".
The notprsubset
element is a binary set
relation.
(set,set) > boolean
(multiset,multiset) > boolean
<apply><notprsubset/> <ci type="set"> A </ci> <ci type="set"> B </ci> </apply>
setdiff
The setdiff element is the operator element for a settheoretic difference of two sets.
The setdiff
element is the operator element for a settheoretic
difference of two sets.
(set,set) > set
(multiset,multiset) > multiset
<apply><setdiff/> <ci type="set"> A </ci> <ci type="set"> B </ci> </apply>
card
The card element is the operator element for deriving the size or cardinality of a set. The size of a multset is simply the total number of elements in the multiset.
The card
element is the operator element for the size or cardinality
of a set.
(set) > scalar
(multiset) > scalar
where A is a set with 5 elements.
<apply><eq/> <apply><card/><ci> A </ci></apply> <ci> 5 </ci> </apply>
cartesianproduct
The cartesianproduct element is the operator for a settheoretic cartesian product of two (or more) sets. The cartesian product of multisets produces a multiset since ntuples may be repeated if elements in the base sets are repeated.
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.
As an nary operator, its operands may also be generated as described in Section 4.4.10 Lifted Associative Commutative Operators Therefore it may take qualifiers.
(set*) > set
(multiset*) > multiset
<apply><cartesianproduct/> <ci> A </ci> <ci> B </ci> </apply>
<apply><cartesianproduct/> <reals/> <reals/> <reals/> </apply>
sum
The sum element denotes the summation operator. It may be qualified by providing a domainofapplication. This may be provided using one of the shorthand notations for domainofapplication such as an uplimit,lowlimit pair or a condition or an interval. The index for the summation is specified by a bvar element.
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
function accept the bvar
, lowlimit
,
uplimit
, interval
, condition
and
domainofapplication
schemata. If both lowlimit
and
uplimit
schemata are present, they denote the limits of the sum or
product. The limits may alternatively be specified using the interval
,
condition
or domainofapplication
schema. The bvar
schema
signifies the internal variable in the sum or product. A typical example might be:
<apply> <sum/> <bvar><ci>i</ci></bvar> <lowlimit><cn>0</cn></lowlimit> <uplimit><cn>100</cn></uplimit> <apply> <power/> <ci>x</ci> <ci>i</ci> </apply> </apply>
When used with sum
or product
, each qualifier schema is expected to
contain a single child schema; otherwise an error is generated.
(function ) > function
(bvar,algebraic ) > algebraic
(domainofapp,function) > function
(bvar+,domainofapp,algebraic) > algebraic
<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>
product
The product element denotes the product operator. It may be qualified by providing a domainofapplication. This may be provided using one of the shorthand notations for domainofapplication such as an uplimit,lowlimit pair or a condition or an interval. The index for the product is specified by a bvar element.
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 sum
function accepts the bvar
, lowlimit
,
uplimit
, interval
, condition
and
domainofapplication
schemata. If both lowlimit
and
uplimit
schemata are present, they denote the limits of the sum or
product. The limits may alternatively be specified using the interval
,
condition
or domainofapplication
schema. The bvar
schema signifies the internal variable in the sum or product.
(function) > function
(bvar,algebraic) > algebraic
(domainofapp,function) > function
(bvar+,domainofapp,algebraic) > algebraic
<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>
limit
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 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
function accepts zero or more bvar
schemata, and
optional condition
and lowlimit
schemata. A condition
may be used to place constraints on the bvar
. The bvar
schema
denotes the variable with respect to which the limit is being taken. The
lowlimit
schema denotes the limit point. When used with limit
,
the bvar
and lowlimit
schemata are expected to contain a
single child schema; otherwise an error is generated.
(bvar+, lowlimit, uplimit, algebraic) > real
(bvar+, condition , algebraic) > real
<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/><ci>x</ci><cn>0</cn></apply> </condition> <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>
tendsto
The tendsto element is used to express the relation that a quantity is tending to a specified value.
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. It occurs as a container
so that it can more easily be used in the construction of a limit expression.
Predefined values: "above", "below",
"twosided". The default value is "twosided".
Issue type_on_tendsto  wiki (member only) 

keep type attribute on tendsto ?


It seems very awkward to keep this, it would probably be better to have an


Resolution  None recorded 
Name  Value  Default 

type  above  below  all  MathMLType  all 
(algebraic,algebraic) > tendsto
[ type=direction ](algebraic,algebraic) > tendsto(direction)
<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>
The names of the common trigonometric functions supported by MathML are listed below. Since their standard interpretations are widely known, they are discussed as a group.
sin 
cos 
tan 
sec 
csc 
cot 
sinh 
cosh 
tanh 
sech 
csch 
coth 
arcsin 
arccos 
arctan 
arccosh 
arccot 
arccoth 
arccsc 
arccsch 
arcsec 
arcsech 
arcsinh 
arctanh 
These operator elements denote the standard trigonometric functions.
exp
This element represents the exponentiation function as described in Abramowitz and Stegun, section 4.2. It takes one argument.
The exp
element represents the exponential
function associated with the inverse of the ln
function. In particular, exp(1) is approximately 2.718281828.
(real) > real
(complex) > complex
<apply><eq/> <apply><exp/><cn>0</cn></apply> <cn>1</cn> </apply>
for all k if k is an integer then e^(z+2*pi*k*i)=e^z
<apply><exp/><ci> x </ci></apply>
ln
This element represents the ln function (natural logarithm) as described in Abramowitz and Stegun, section 4.1. It takes one argument.
The ln
element represents the natural logarithm
function.
(real) > real
(complex) > complex
pi lt Im ln x leq pi
If a = e, (where e is the base of the natural logarithms) this will yield the value 1.
<apply><ln/><ci> a </ci></apply>
log
This element represents the log function. It is defined in Abramowitz and Stegun, Handbook of Mathematical Functions, section 4.1 If its first argument is a logbase element, it specifies the base and the second argument is the argument to which the function is applied using that base. If no logbase element is present, the base is assumed to be 10.
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
function accepts only the logbase
schema. If
present, the logbase
schema denotes the base with respect to which the
logarithm is being taken. Otherwise, the log is assumed to be base 10. When used
with log
, the logbase
schema is expected to contain a single
child schema; otherwise an error is generated.
(logbase,real) > real
(logbase,complex) > complex
(real) > real
(complex) > complex
a^b = c implies log_a c = b
This markup represents "the base 3 logarithm of x". For natural logarithms base e, the ln
element should be used instead.
<apply><log/> <logbase><cn> 3 </cn></logbase> <ci> x </ci> </apply>
<apply><log/><ci>x</ci></apply>
sin
This element represents the sin function as described in Abramowitz and Stegun, section 4.3. It takes one argument.
(real) > real
(complex) > complex
sin(0) = 0
sin(integer*Pi) = 0
sin(x) = (exp(ix)exp(ix))/2i
<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>
cos
This element represents the cos function as described in Abramowitz and Stegun, section 4.3. It takes one argument. It takes one argument.
(real) > real
(complex) > complex
cos(0) = 1
cos(integer*Pi+Pi/2) = 0
cos(x) = (exp(ix)+exp(ix))/2
<apply><cos/><ci>x</ci></apply>
tan
This element represents the tan function as described in Abramowitz and Stegun, section 4.3. It takes one argument.
(real) > real
(complex) > complex
tan(integer*Pi) = 0
tan(x) = sin(x)/cos(x)
<apply><tan/><ci>x</ci></apply>
sec
This element represents the sec function as described in Abramowitz and Stegun, section 4.3. It takes one argument.
(real) > real
(complex) > complex
sec(x) = 1/cos(x)
<apply><sec/><ci>x</ci></apply>
csc
This element represents the csc function as described in Abramowitz and Stegun, section 4.3. It takes one argument.
(real) > real
(complex) > complex
csc(x) = 1/sin(x)
<apply><csc/><ci>x</ci></apply>
cot
This element represents the cot function as described in Abramowitz and Stegun, section 4.3. It takes one argument. It takes one argument.
(real) > real
(complex) > complex
cot(integer*Pi+Pi/2) = 0
cot(x) = cos(x)/sin(x)
cot A = 1/tan A
<apply><cot/><ci>x</ci></apply>
sinh
This element represents the sinh function as described in Abramowitz and Stegun, section 4.5. It takes one argument.
(real) > real
(complex) > complex
sinh A = 1/2 * (e^A  e^(A))
<apply><sinh/><ci>x</ci></apply>
cosh
This symbol represents the cosh function as described in Abramowitz and Stegun, section 4.5. It takes one argument. It takes one argument.
(real) > real
(complex) > complex
cosh A = 1/2 * (e^A + e^(A))
<apply><cosh/><ci>x</ci></apply>
tanh
This element represents the tanh function as described in Abramowitz and Stegun, section 4.5. It takes one argument.
(real) > real
(complex) > complex
tanh A = sinh A / cosh A
<apply><tanh/><ci>x</ci></apply>
sech
This element represents the sech function as described in Abramowitz and Stegun, section 4.5. It takes one argument.
(real) > real
(complex) > complex
sech A = 1/cosh A
<apply><sech/><ci>x</ci></apply>
csch
This element represents the csch function as described in Abramowitz and Stegun, section 4.5. It takes one argument.
(real) > real
(complex) > complex
csch A = 1/sinh A
<apply><csch/><ci>x</ci></apply>
coth
This element represents the coth function as described in Abramowitz and Stegun, section 4.5. It takes one argument.
(real) > real
(complex) > complex
coth A = 1/tanh A
<apply><coth/><ci>x</ci></apply>
arcsin
This element represents the arcsin function which is the inverse of the sin function as described in Abramowitz and Stegun, section 4.4. It takes one argument.
(real) > real
(complex) > complex
arcsin(z) = i ln (sqrt(1z^2)+iz)
<apply><arcsin/><ci>x</ci></apply>
arccos
This element represents the arccos function which is the inverse of the cos function as described in Abramowitz and Stegun, section 4.4. It takes one argument.
(real) > real
(complex) > complex
arccos(z) = i ln(z+i \sqrt(1z^2))
<apply><arccos/><ci>x</ci></apply>
arctan
This element represents the arctan function which is the inverse of the tan function as described in Abramowitz and Stegun, section 4.4. It takes one argument.
(real) > real
(complex) > complex
arctan(z) = (ln(1+iz)ln(1iz))/2i
<apply><arctan/><ci>x</ci></apply>
arccosh
This symbol represents the arccosh function as described in Abramowitz and Stegun, section 4.6. It takes one argument.
(real) > real
(complex) > complex
arccosh(z) = 2*ln(\sqrt((z+1)/2) + \sqrt((z1)/2))
<apply><arccosh/><ci>x</ci></apply>
arccot
This element represents the arccot function as described in Abramowitz and Stegun, section 4.4. It takes one argument.
(real) > real
(complex) > complex
arccot(z) =  arccot(z)
<apply><arccot/><ci>x</ci></apply>
arccoth
This element represents the arccoth function as described in Abramowitz and Stegun, section 4.6. It takes one argument.
(real) > real
(complex) > complex
arccoth(z) = (ln(1z)ln(1z))/2
<apply><arccoth/><ci>x</ci></apply>
arccsc
This element represents the arccsc function as described in Abramowitz and Stegun, section 4.4. It takes one argument.
(real) > real
(complex) > complex
arccsc(z) = i ln(i/z + \sqrt(1  1/z^2))
<apply><arccsc/><ci>x</ci></apply>
arccsch
This element represents the arccsch function as described in Abramowitz and Stegun, section 4.6. It takes one argument.
(real) > real
(complex) > complex
arccsch(z) = ln(1/z + \sqrt(1+(1/z)^2))
<apply><arccsch/><ci>x</ci></apply>
arcsec
This element represents the arcsec function as described in Abramowitz and Stegun, section 4.4. It takes one argument.
(real) > real
(complex) > complex
arcsec(z) = i ln(1/z + i \sqrt(11/z^2))
<apply><arcsec/><ci>x</ci></apply>
arcsech
This element represents the arcsech function as described in Abramowitz and Stegun, section 4.6. It takes one argument.
(real) > real
(complex) > complex
arcsech(z) = 2 ln(\sqrt((1+z)/(2z)) + \sqrt((1z)/(2z)))
<apply><arcsech/><ci>x</ci></apply>
arcsinh
This element represents the arcsinh function as described in Abramowitz and Stegun, section 4.6. It takes one argument.
(real) > real
(complex) > complex
arcsinh z = ln(z + \sqrt(1+z^2))
<apply><arcsinh/><ci>x</ci></apply>
arctanh
This element represents the arctanh function as described in Abramowitz and Stegun, section 4.6. It takes one argument.
(real) > real
(complex) > complex
arctanh(z) =  i * arctan(i * z)
<apply><arctanh/><ci>x</ci></apply>
mean
The mean value of a set of data, or of a random variable. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, section 7.7.1
mean
is the operator element representing a mean or
average.
(random_variable) > scalar
(scalar+) > scalar
<apply><mean/><ci type="discrete_random_variable"> X </ci></apply>
<apply><mean/><cn>3</cn><cn>4</cn><cn>3</cn><cn>7</cn><cn>4</cn></apply>
<apply><mean/><ci> X </ci></apply>
sdev
This element represents a function denoting the sample standard deviation of its arguments. The arguments are either all data, or a discrete random variable, or a continuous random variable.
For numeric data at least two values are required and this is the square root of (the sum of the squares of the deviations from the mean of the arguments, divided by the number of arguments less one). For a "discrete_random_variable", this is the square root of the second moment about the mean. This further generalizes to identifiers of type continuous_random_variable.
See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, (7.7.11) section 7.7.1.
sdev
is the operator element representing the statistical
standard deviation operator.
(scalar,scalar+) > scalar
(discrete_random_variable) > scalar
(continuous_random_variable) > scalar
<apply><sdev/><cn>3</cn><cn>4</cn><cn>2</cn><cn>2</cn></apply>
sdev
is an nary operator.
<apply><sdev/><ci type="discrete_random_variable"> X </ci></apply>
variance
This symbol represents a function denoting the variance of its arguments, that is, the square of the standard deviation. The arguments are either all data in which case there are two or more of them, or an identifier of type discrete_random_variable, or continuous_random_variable. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, [7.1.2] and [7.7].
variance
is the operator element representing the
statistical variance operator.
(scalar,scalar+) > scalar
(descrete_random_variable) > scalar
(continuous_random_variable) > scalar
<apply><variance/><cn>3</cn><cn>4</cn><cn>2</cn><cn>2</cn></apply>
variance
is an nary operator.
<apply><variance/><ci type="discrete_random_variable"> X </ci></apply>
median
This symbol represents an nary function denoting the median of its arguments. That is, if the data were placed in ascending order then it denotes the middle one (in the case of an odd amount of data) or the average of the middle two (in the case of an even amount of data). See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, section 7.7.1
median
is the operator element representing the statistical
median operator.
(scalar+) > scalar
<apply><median/><cn>3</cn><cn>4</cn><cn>2</cn><cn>2</cn></apply>
median
is an nary operator.
<apply> <median/> <ci> X </ci> </apply>
mode
This represents the mode of n data values. The mode is the data value that occurs with the greatest frequency. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, section 7.7.1
mode
is the operator element representing the statistical
mode operator.
(scalar+) > scalar
<apply><mode/><cn>3</cn><cn>4</cn><cn>2</cn><cn>2</cn></apply>
mode
is an nary operator.
<apply> <mode/> <ci> X </ci> </apply>
moment
This symbol is used to denote the i'th moment of a set of data, or a random variable. Unless otherwise specified, the moment is about the origin. For example, the i'th moment of X about the origin is given by moment( i , 0 , x ).
The first argument indicates which moment about that point is being specified. For the i'th moment the first argument should be i. The second argument specifies the point about which the moment is computed. It is either an actual point ( e.g. 0 ), or a function which can be used on the data to compute that point. To indicate a central moment, specify the element "mean". The third argument is either a discrete or continuous random variable, or the start of a sequence of data. If there is a sequence of data then the i'th moment is (1/n) (x_1^i + x_2^i + ... + x_n^i).
See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, section 7.7.1
The moment
element represents the statistical moment
operator. Use the qualifier degree
for the n in "
nth moment". Use the qualifier momentabout
for the
p in "moment about p".
The moment
function accepts the degree
and
momentabout
schema. If present, the degree
schema denotes the
order of the moment. Otherwise, the moment is assumed to be the first order
moment. When used with moment
, the degree
schema is expected
to contain a single child schema; otherwise an error is generated. If present,
the momentabout
schema denotes the point about which the moment is
taken. Otherwise, the moment is assumed to be the moment about zero.
(degree,momentabout?,scalar+) > scalar
(degree,momentabout?,discrete_random_variable) > scalar
(degree,momentabout?,continuous_random_variable) > scalar
The third moment about the point p of a discrete random variable
moment
is an operator taking qualifiers (see Section 4.2.7 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>
The 3rd central moment of a set of data.
<apply><moment/> <degree><cn>3</cn></degree> <momentabout><mean/></momentabout> <cn>6</cn><cn>4</cn><cn>2</cn><cn>2</cn><cn>5</cn> </apply>
The 3rd central moment of a discrete random variable.
<apply><moment/> <degree><cn>3</cn></degree> <momentabout><mean/></momentabout> <ci type="discrete_random_variable"> X </ci> </apply>
The 3rd moment about the origin of a set of data.
<apply><moment/> <degree><cn>3</cn></degree> <momentabout><cn>0</cn></momentabout> <cn>6</cn><cn>4</cn><cn>2</cn><cn>2</cn> </apply>
momentabout
This qualifier element is used to identify the point about which a moment is to be computed. It may be an explicit point, or it may identify a method by which the point is to be computed from the given data. For example the moment may be computed about the mean by specifying the element used for the mean.
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".
(function) > method
(scalar) > point
The third moment of the distribution X about the point p of a discrete random variable is written:
<apply> <moment/> <degree> <cn> 3 </cn> </degree> <momentabout> <ci> p </ci> </momentabout> <ci> X </ci> </apply>
The 3rd central moment of a set of data.
<apply><moment/> <degree><cn> 3 </cn></degree> <momentabout><mean/></momentabout> <cn>6</cn><cn>4</cn><cn>2</cn><cn>2</cn><cn>5</cn> </apply>
vector
A vector is an ordered ntuple of values representing an element of an ndimensional vector space. The "values" are all from the same ring, typically real or complex. Where orientation is important, such as for pre or post multiplication by a matrix a vector is treated as if it were a column vector and its transpose is treated a row vector. The type attribute can be used to explicitly specify that a vector is a "row" vector. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, [2.4]
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
1dimensional 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.
The vector
element constructs vectors from an ndimensional
vector space so that its n child elements typically represent real or
complex valued scalars as in the threeelement vector
<vector> <apply><plus/><ci>x</ci><ci>y</ci></apply> <cn>3</cn> <cn>7</cn> </vector>
A vector can also be constructed by evaluating a function over a specific domain
of application, each evaluation corresponding to an entry in the vector. In its
most general form a domain is explicitly specified by a
domainofapplication
element and a function. Optionally the
domainofapplication
can be augmented by a bvar
element and an
algebraic expression expressed in terms of it. Qualifications defined by a
domainofapplication
element can be abbreviated in several ways as
described in Section 4.2.7 Qualifiers.
Name  Value  Default 

type  row  column  MathMLType  column 
(real*) > vector(type=real)
[type=vectortype]((anything)*) > vector(type=vectortype)
(domainofapp,function) > vector
(bvar+,domainofapp,anything) > vector
vector=column_vector
matrix * vector = vector
matrix * column_vector = column_ vector
row_vector*matrix = row_vector
transpose(vector) = row_vector
transpose(column_vector) = row_vector
transpose(row_vector) = column_vector
distributive over scalars
associativity.
Matrix * column vector
row vector * Matrix
vector
is a constructor element.
<vector><cn>1</cn><cn>2</cn><cn>3</cn><ci>x</ci></vector>
<vector type="row"><cn>1</cn><cn>2</cn><cn>3</cn><ci>x</ci></vector>
<vector> <bvar><ci type="integer">i</ci></bvar> <lowlimit><ci>1</ci></lowlimit> <uplimit><ci>10</ci></uplimit> <apply><power/> <ci>x</ci> <ci>i</ci> </apply> </vector>
matrix
This is the constructor for a matrix. It requires matrixrow's as arguments. It is used to represent matrices. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, [2.5.1].
The matrix
element is the container element for matrix rows, which
are represented by matrixrow
. The matrixrow
s contain the
elements of a matrix.
In general a matrix can be constructed by providing a function and a
2dimensional 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.
The matrix
element is used to represent mathematical matrices. It
has zero or more child elements, all of which are matrixrow
elements. These in turn expect zero or more child elements that evaluate to
algebraic expressions or numbers. These subelements are often real numbers, or
symbols as in
<matrix> <matrixrow> <cn> 1 </cn> <cn> 2 </cn> </matrixrow> <matrixrow> <cn> 3 </cn> <cn> 4 </cn> </matrixrow> </matrix>
The matrixrow
elements must always be contained inside of a matrix, and
all rows in a given matrix must have the same number of elements.
Note that the behavior of the matrix
and matrixrow
elements
is substantially different from the mtable
and mtr
presentation
elements.
A matrix can also be constructed by evaluating a bivariate function over a
specific domain of application, each evaluation corresponding to an entry in the
matrix. In its most general form a domain of application is explicitly specified
by a domainofapplication
element and a function which when evaluated at
points of the domain produces entries in the matrix. Optionally the
domainofapplication
can be augmented by bvar
elements and an
algebraic expression expressed in terms of them.
Name  Value  Default 

type  real  complex  integer  symbolic  integer  MathMLType  real 
(matrixrow*) > matrix
[type=matrixtype](matrixrow*) > matrix(type=matrixtype)
(domainofapp,function) > matrix
(bvar,bvar,domainofapp,anything) > matrix
scalar multiplication
scalar multiplication
Matrix*column vector
scalar multiplication
Addition
scalar multiplication
Matrix*Matrix
matrix
is a constructor element.
<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>
<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> </vector>
matrixrow
This symbol is an nary constructor used to represent rows of matrices. Its arguments should be members of a ring.
The matrixrow
element is the container element
for the rows of a matrix.
(ringelement+) > matrixrow
<matrixrow><cn>1</cn><cn>2</cn></matrixrow>
determinant
The "determinant" of a matrix. This is a unary function. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, [2.5.4].
The determinant
element is the operator for constructing the
determinant of a matrix.
(matrix)> scalar
determinant
is a unary operator.
<apply><determinant/> <ci type="matrix"> A </ci> </apply>
transpose
The transpose of a matrix or vector. See CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, [2.4] and [2.5.1].
The transpose
element is the operator for constructing the transpose
of a matrix.
(vector)>vector(type=row)
(matrix)>matrix
(vector[type=row])>vector
transpose(transpose(A))= A
transpose(transpose(V))= V
transpose
is a unary operator.
<apply><transpose/><ci type="matrix">A</ci></apply>
<apply><transpose/><ci type="vector">V</ci></apply>
selector
The operator used to extract subobjects from vectors, matrices matrix rows and lists. Elements are accessed by providing one index element for each dimension. For matrices, submatrices are selected by providing one fewer index items. For a matrix A and a column vector V : select(i, j, A) is the i,j th element of A. select(i, A) is the matrixrow formed from the i'th row of A. select(i, V) is the i'th element of V. select(V) is the sequence of all elements of V. select(A) is the sequence of all elements of A, extracted row by row. select(i, L) is the i'th element of a list. select(L) is the sequence of elements of a list.
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 ith matrixrow. Thus, the preceding example selects the following row:
<matrixrow> <cn> 1 </cn> <cn> 2 </cn> </matrixrow>
selector
is classified as an nary linear algebra operator even
though it can take only one, two, or three arguments.
(matrix,scalar,scalar)>scalar
(matrix,scalar)>matrixrow
(matrix)>scalar*
((vectorlistmatrixrow),scalar )>scalar
(vectorlistmatrixrow)>scalar*
For all vectors V, V = vector(selector(V))
For all matrix rows Mrow, Mrow = matrixrow(selector(Mrow))
<apply><selector/><ci type="matrix">M</ci><cn>3</cn><cn>2</cn></apply>
vectorproduct
The vector or cross product of two nonzero threedimensional vectors v1 and v2 is defined by
v1 x v2 = n norm(v1) * norm(v2) sin(theta) where n is the unit normal vector perpendicular to both, adhering to the right hand rule. CRC Standard Mathematical Tables and Formulae, editor: Dan Zwillinger, CRC Press Inc., 1996, [2.4]
The vectorproduct
is the operator element for
deriving the vector product of two vectors.
The vectorproduct
element is a binary
vector operator.
(vector,vector)>vector
if v1 and v2 are parallel then their vector product is 0
<apply><vectorproduct/><ci>u</ci><ci>v</ci></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.
<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> θ </ci> </apply> <ci type="vector"> N </ci> </apply> </apply>
scalarproduct
This symbol represents the scalar product function. It takes two vector arguments and returns a scalar value. The scalar product of two vectors a, b is defined as a * b * cos(\theta), where \theta is the angle between the two vectors and . is a euclidean size function. Note that the scalar product is often referred to as the dot product.
The scalarproduct
is the operator element for deriving the scalar
product of two vectors.
The scalarproduct
element is a binary vector
operator.
(vector,vector) > scalar
if the scalar product of two vectors is 0 then they are orthogonal.
<apply><scalarproduct/><ci>u</ci><ci>v</ci></apply>
where A and B are vectors, a, b are the magnitudes of A, B and is the angle between A and B.
<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> θ </ci> </apply> </apply> </apply>
outerproduct
This symbol represents the outer product function. It takes two vector arguments and returns a matrix. It is defined as follows: if we write the {i,j}'th element of the matrix to be returned as m_{i,j}, then: m_{i,j}=a_i * b_j where a_i,b_j are the i'th and j'th elements of a, b respectively.
The outerproduct
is the operator element for deriving the outer
product of two vectors.
The outerproduct
element is a binary vector
operator.
(vector,vector) > matrix
<apply><outerproduct/><ci>u</ci><ci>v</ci></apply>
where A and B are vectors.
<apply> <outerproduct/> <ci type="vector">A</ci> <ci type="vector">B</ci> </apply>
integers
integers represents the set of all integers.
set
n is an integer implies n+1 is an integer.
<apply><implies/> <apply><in/><ci>n</ci><integers/></apply> <apply><in/><apply><plus/><ci>n</ci><cn>1</cn></apply><integers/></apply> </apply>
0 is an integer
<apply><in/><cn>0</cn><integers/></apply>
n is an integer implies n is an integer
<apply><implies/> <apply><in/><ci>n</ci><integers/></apply> <apply><in/><apply><minus/><ci>n</ci></apply><integers/></apply> </apply>
<apply><in/> <cn type="integer"> 42 </cn> <integers/> </apply>
reals
reals represents the set of all real numbers.
reals
represents the set of all real numbers.
set
(S \subset R and exists y in R : forall x in S x \le y) implies exists z in R such that ( ( forall x in S x \le z) and ( (forall x in S x \le w) implies z le w))
for all a,b  a,b rational with a<b implies there exists rational a,c s.t. a<c and c<b
<apply><in/> <cn type="real"> 44.997 </cn> <reals/> </apply>
rationals
rationals represents the set of all rational numbers.
rationals
represents the set of all rational numbers.
set
for all z where z is a rational, there exists integers p and q with p/q = z
<apply><forall/> <bvar><ci>z</ci></bvar> <condition><apply><in/><ci>z</ci><rationals/></apply></condition> <apply><exists/> <bvar><ci>p</ci></bvar> <bvar><ci>q</ci></bvar> <apply><and/> <apply><in/><ci>p</ci><integers/></apply> <apply><in/><ci>q</ci><integers/></apply> <apply><eq/> <apply><divide/><ci>p</ci><ci>q</ci></apply><integers/></apply> <ci>z</ci> </apply> </apply> </apply>
ForAll( [a,b], a and b are rational, a < b implies there exists c such that a < c and c < b )
<apply><in/> <cn type="rational"> 22 <sep/>7</cn> <rationals/> </apply>
naturalnumbers
naturalnumbers represents the set of all natural numbers, i.e.. nonnegative integers.
naturalnumbers
represents the set of all natural
numbers, i.e. nonnegative integers.
set
For all n  n is a natural number implies n+1 is a natural number.
<apply><forall/> <bvar><ci>n</ci></bvar> <apply><implies/> <apply><in/><ci>n</ci><naturalnumbers/></apply> <apply><in/> <apply><plus/><ci>n</ci><cn>1</cn></apply> <naturalnumbers/> </apply> </apply> </apply>
0 is a natural number.
<apply><in/><cn>0</cn><naturalnumbers/></apply>
for all n  n in the natural numbers is equivalent to saying n=0 or n1 is a natural number
<apply><in/> <cn type="integer">1729</cn> <naturalnumbers/> </apply>
complexes
complexes represents the set of all complex numbers, i.e., numbers which may have a real and an imaginary part.
complexes
represents the set of all complex
numbers, i.e. numbers which may have a real and an imaginary part.
set
for all z  if z is complex then there exist reals x,y s.t. z = x + i * y
<apply><in/> <cn type="complex">17<sep/>29</cn> <complexes/> </apply>
primes
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.
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.
set
ForAll( [d,p], p is prime, Implies( d  p , d=1 or d=p ) )
<apply><forall/> <bvar><ci>d</ci></bvar> <bvar><ci>p</ci></bvar> <condition> <apply><and/> <apply><in/><ci>p</ci><primes/></apply> <apply><in/><ci>d</ci><naturalnumbers/></apply> </apply> </condition> <apply><implies/> <apply><factorof/><ci>d</ci><ci>p</ci></apply> <apply><or/> <apply><eq/><ci>d</ci><cn>1</cn></apply> <apply><eq/><ci>d</ci><ci>p</ci></apply> </apply> </apply> </apply>
<apply> <in/> <cn type="integer">17</cn> <primes/> </apply>
exponentiale
exponentiale represents the mathematical constant which is the exponential base of the natural logarithms, commonly written e . It is approximately 2.718281828..
exponentiale
represents the mathematical constant which is the
exponential base of the natural logarithms, commonly written e. It
is approximately 2.718281828..
real constant
ln(e) = 1
<apply><eq/> <apply><ln/><exponentiale/></apply> <cn>1</cn> </apply>
e is approximately 2.718281828
<apply><approx/> <exponentiale/> <cn>2.718281828 </cn> </apply>
e = the sum as j ranges from 0 to infinity of 1/(j!)
<apply> <eq/> <apply><ln/><exponentiale/></apply> <cn>1</cn> </apply>
imaginaryi
imaginaryi represents the mathematical constant which is the square root of 1, commonly written i
imaginaryi
represents the mathematical constant which is the square
root of 1, commonly written i.
complex
sqrt(1) = i
<apply><eq/> <imaginaryi/> <apply><root/><degree><cn>2</cn></degree><cn>1</cn></apply> </apply>
<apply> <eq/> <apply><power/> <imaginaryi/> <cn>2</cn> </apply> <cn>1</cn> </apply>
notanumber
notanumber represents the result of an illdefined floating point operation, sometimes also called NaN.
notanumber
represents the result of an illdefined floating point
operation, sometimes also called NaN.
undefined
<apply><eq/> <apply><divide/><cn>0</cn><cn>0</cn></apply> <notanumber/> </apply>
true
true represents the logical constant for truth.
true
represents the logical constant for truth.
boolean
not true = false
<apply><eq/> <apply><not/><true/></apply> <false/> </apply>
For all boolean p, p or true is true
<declare type="boolean"><ci>p</ci></declare> <apply><forall/> <bvar><ci>p</ci></bvar> <apply><eq/> <apply><or/><ci>p</ci><true/></apply> <true/> </apply> </apply>
<apply> <eq/> <apply><or/> <true/> <ci type = "boolean">P</ci> </apply> <true/> </apply>
false
false represents the logical constant for falsehood.
false
represents the logical constant for falsehood.
boolean
not true = false
<apply><eq/> <apply><not/><true/></apply> <false/> </apply>
p and false = false
<declare type="boolean"><ci>p</ci></declare> <apply><forall/> <bvar><ci>p</ci></bvar> <apply><and/><ci>p</ci><false/></apply> <false/> </apply>
<apply><eq/> <apply><and/> <false/> <ci type = "boolean">P</ci> </apply> <false/> </apply>
emptyset
emptyset represents the empty set.
emptyset
represents the empty set.
set
for all sets S, intersect(S,emptyset) = emptyset
<apply><forall/><bvar><ci type="set">S</ci></bvar> <apply><eq/> <apply><intersect/><emptyset/><ci>S</ci></apply> <emptyset/> </apply> </apply>
<apply><neq/> <integers/> <emptyset/> </apply>
pi
pi represents the mathematical constant which is the ratio of a circle's circumference to its diameter, approximately 3.141592653.
pi
represents the mathematical constant which is the ratio of a
circle's circumference to its diameter, approximately 3.141592653.
real
<apply><approx/> <cn>pi</cn> <cn> 3.141592654 </cn> </apply>
pi = 4 * the sum as j ranges from 0 to infinity of ((1/(4j+1))(1/(4j+3)))
<apply><approx/> <pi/> <cn type = "rational">22<sep/>7</cn> </apply>
eulergamma
A symbol to convey the notion of the gamma constant as defined in Abramowitz and Stegun, Handbook of Mathematical Functions, section 6.1.3. It is the limit of 1 + 1/2 + 1/3 + ... + 1/m  ln m as m tends to infinity, this is approximately 0.5772 15664.
eulergamma
represents Euler's constant, approximately
0.5772156649
real
gamma is approx. 0.5772156649
<apply><approx/> <eulergamma/> <cn> .5772156649 </cn> </apply>
gamma = limit_(m > infinity)(sum_(j ranges from 1 to m)(1/j)  ln m)
<eulergamma/>
<apply><approx/> <eulergamma/> <cn>0.5772156649</cn> </apply>
infinity
Infinity. Interpretation depends on the context. The default value is the positive infinity used to extend the real number line. The "type" attribute can be use to indicate that this is a "complex" infinity.
infinity
represents the concept of
infinity. Proper interpretation depends on context.
constant
infinity/infinity is not defined.
<apply><eq/> <apply><divide/><infinity/><infinity/></apply> <notanumber/> </apply>
for all reals x, x \lt infinity
<apply><forall/> <bvar><ci>n</ci></bvar> <condition><apply><in/><ci>n</ci><reals/></apply></condition> <apply><lt/><ci>n</ci><infinity/></apply> </apply>
<infinity/>
<apply><eq/> <apply><limit/> <bvar><ci>x</ci></bvar> <condition><apply><tendsto/><ci>x</ci><infinity/></apply></condition> <apply><divide/><cn>1</cn><ci>x</ci></apply> </apply> <cn>0</cn> </apply>
unhandled_symbol
This symbol represents the error which is raised when an application reads a symbol which is present in the mentioned content dictionary, but which it has not implemented.
When receiving such a symbol, the application should act as if it had received the
MathML error object constructed from unhandled_symbol
and the unhandled symbol as in
the example below.
The application does not implement the Complex numbers:
<error> <csymbol cd="error" name="unhandled_symbol"/> <csymbol cd="setname1" name="C"/> </error>
unexpected_symbol
This symbol represents the error which is raised when an application reads a symbol which is not present in the mentioned content dictionary.
When receiving such a symbol, the application should act as if it had received the MathML error object constructed from unexpected_symbol and the unexpected symbol as in the example below.
The application received a mistyped symbol
<error> <csymbol cd="error" name="unexpected_symbol"/> <csymbol cd="arith1" name="plurse"/> </error>
unsupported_CD
This symbol represents the error which is raised when an application reads a symbol where the mentioned content dictionary is not present.
When receiving such a symbol, the application should act as if it had received the
MathML error object constructed from unsupported_CD
and the symbol from
the unsupported Content Dictionary as in the example below.
The application does not know about the CD specfun
<error> <csymbol cd="error" name="unsupported_CD"/> <csymbol cd="specfun" name="BesselJ"/> </error>