Overview: Mathematical Markup Language (MathML) Version 2.0
Previous: B Content Markup Validation Grammar
Next: D Operator Dictionary (Non-normative)
C Content Element Definitions
C.1 About Content Markup Elements
C.1.1 The Default Definitions
C.1.2 The Structure of an MMLdefinition.
C.2 Definitions of MathML Content Elements
C.2.1 Leaf Elements
C.2.2 Basic Content Element
C.2.3 Arithmetic, Algebra and Logic
C.2.4 Relations
C.2.5 Calculus
C.2.6 Theory of Sets
C.2.7 Sequences and Series
C.2.8 Trigonometry
C.2.9 Statistics
C.2.10 Lineary Algebra
The primary role of MathML content elements is to provide a mechanism for recording the fact 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. The purpose of this appendix is to provide default definitions. (An index to the definitions is provided later in this document.) The author may adapt the notation to their own particular needs by using the "definitionURL" to override these default definitions for selected content elements.
The mathematical definitions are not restricted to any one format. There are several reasons for allowing this flexibility, nearly all derived from the fact that if it is extremely important to allow authors to make use of existing definitions from the mathematical literature.
The key issues for both archival and computational purposes is that there be a definition and that the author have a mechanism to specify which definition is to be used for a given instance of a notational construct. This denotational requirement is important without regard to the existence of an implementation of a particular concept or object in a mathematical computation system. The definition may be as vague as claiming that, say F, is an unknown, but differentiable function from the real numbers to the real numbers, or as complicated as requiring that F to be an elaborate function or operation as defined in some recent (or classical) research paper. The important thing is that the reader always have a way of determining how the notation is being used.
An author's decision to use content elements is a decision to used defined objects. In order to make this task less onerous, default definitions are provided. In this way, an author only needs to provide explicit definitions where their usage differs from the default usage.
Where possible the default definitions have been chosen to reflect common usage in the same way that most well written mathematical communications (in any format) benefit substantially from the author's use of widely used and understood terms.
Definitions are overridden in a particular instance by making use of the
definitionURL attribute. The format of the content
of that URL is unspecified. It may even be the case that the definitionURL
is just a name invented by the author in which case it serves to warn the
reader (and computational systems) that the author is using their own
definition. It may be the URL of a mathematical paper whose whole purpose
is to define a new operator, or even a reference to a traditional text in
which the construct is defined. If the author's mathematical operator
matches exactly with an operator in a particular computational system, an
appropriate definition might be in terms of a MathML semantics element establishing a correspondence between
two encodings. Whatever format is chosen, the only requirement is that
some sort of definition be indicated.
This rest of this appendix provides detailed descriptions of the default semantics associated with each of the MathML content elements. Since this is exactly the role intended for the encodings under development by the OpenMath Consortium and one of our goals is to foster international cooperation in such standardization efforts we have presented the default definitions in a format modeled on OpenMath's content dictionaries. While the actual details differ somewhat from the OpenMath specification, the underlying principles are the same.
Each MathML element is described using an XML format. The top element is
MMLdefinition. The sub-elements identify the
various parts of the description and include:
PCDATA providing the name of the MathML element.sep element is used to separate the CDATA
defining a rational number into two parts in a manner that is easily parsed
by an XML application. These objects are refered to as
punctuation.declare construct is used to reset the default
attribute values, or to associate a name with a specific instance of an
object. These kinds of elements are referred to as descriptors
and the type of the resulting object is the same as that of
element being modified, but with the new attribute values.
No signature is provided for descriptors.lambda element constructs a function
definition from a list of variables and an expression. while the apply element constructs a function
application. By function application we mean the result
of applying the first element of the apply (the function) to the zero or
more remaining elements (the arguments). A function
application represents an object in the range of the function.
For each given combination of type and order of XML children, the
signature of a constructor indicates the type (and sometimes subtype) of
the resulting object.
plus and sin. These
function definitions are parameterized by their XML attribute
values (for example, they may be of type vector) and are either used as is,
for example when discussing the properties of a particular function or
operator, or they are applied to arguments using the apply. The latter case is referred to as function
application.
Functions are classified according to how they are used. For example the
empty sin element represents the unary
mathematical function sine. The plus element is an
nary operator. The signature of a function (see
below) describes how it is to be used a mathematical function inside an apply element. Each combination of types of function
arguments used inside an apply gives rise to an apply element of a given type.
type attribute of the cn
element is used to determine what type of constant (integer, real, etc.)
is being constructed. Only those attributes that affect the mathematical
properties of an object are listed here and typically these also appear
explicitly in the signature.apply. Modifiers modify the attributes of an
existing object. For example, a symbol might become a
symbol of type vector.
The signature must be able to record specific attribute values and
argument types on the left, and parameterized types on the right.. The
syntax used for signatures is of the general form:
[<attribute name>=<attributevalue>]( <list of argument types> ) --> <mathematical result type>(<mathematical subtype>)The MMLattributes, if any, appear in the form
<name>=<value>. They are separated notationally
from the rest of the arguments by square braces. The possible values are
usually taken from an enumerated list, and the signature is usually
affected by selection of a specific value.
For the actual function arguments and named parameters on the left,
the focus is on the mathematical types involved. The function argument
types are presented in a syntax similar to that used for a DTD, with the
one main exception. The types of the named parameters appear in the
signature as
<elementname>=<type>
in a manner analogous for that used for attribute values. For example,
if the argument is named (e.g. bvar) then it is
represented in the signature by an equation as in:
[<attribute name>=<attributevalue>]( bvar=symbol,<argument list> ) --> <mathematical result type>(<mathematical subtype>)No mathematical evaluation ever takes place in MathML. Every MathML content element either refers to a defined object such as a mathematical function or it combines such objects in some way to build a new object. For purposes of the signature, the constructed object represents an object of a certain type parameterized type. For example the result of applying
plus to arguments is an expression that represents
a sum. The type of the resulting expression depends on the types of the
operands, and the values of the MathML attributes.value or
approx (approximation) element that contains a
MathML description of this particular value. More elaborate conditions
on the object are expressed using the MathML syntax.
cn
<MMLdefinition>
<name> cn </name>
<description>
A numerical constant. The mathematical type of number
is given as an attribute. The default type is "real".
Numbers such as rational, complex or real, require two
parts for a complete specification. The parts of such
a number are separated by an empty "sep" element.
There are a number of pre-defined constants including:
π &Exponential; &ComplexI &true; &false; &NaN;
the properties of some of which are outlined below.
The &NaN; is IEEE's "Not a Number", as defined in
IEEE 854 standard for Floating point arithmetic.
</description>
<functorclass> constant </functorclass>
<MMLattribute>
<name> type </name>
<value> integer | rational | complex-cartesian
| complex-polar | real
</value>
<default> real </default>
</MMLattribute>
<MMLattribute>
<name> base </name>
<value> positive_integer </value>
<default> 10 </default>
</MMLattribute>
<signature> [type=integer](numstring) -> constant(integer) </signature>
<signature> [base=basevalue](numstring) -> constant(integer) </signature>
<signature> [type=rational](numstring,numstring) -> constant(rational) </signature>
<signature> [type=complex-cartesian](numstring,numstring) -> constant(complex) </signature>
<signature> [type=rational](numstring,numstring) -> constant(rational) </signature>
<signature> [type=real](π) -> constant(real) </signature>
<signature> [definition](numstring,numstring) -> constant(userdefined) </signature>
<signature> (γ) -> constant</signature>
<example> <cn> 245 </cn> </example>
<example> <cn type="integer"> 245 </cn> </example>
<example> <cn type="integer" base="16"> A </cn></example>
<example> <cn type="rational"> 245 <sep> 351 </cn> </example>
<example> <cn type="complex-cartesian"> 1 <sep/> 2 </cn> </example>
<example> <cn> 245 </cn> </example>
<property> <approx>
<cn> π </cn>
<cn> 3.141592654 </cn>
</approx></property>
<property> <approx>
<cn> γ </cn>
<cn> .5772156649 </cn>
</approx> </property>
<property> <reln><identity/>
<cn>ⅈ </cn>
<apply><root><cn>-1</cn><cn>2</cn></apply>
</reln>
</property>
<property> <reln><approx>
<cn> ⅇ </cn><cn>2.718281828 </cn>
</reln> </property>
<property> <apply><forall/>
<bvar><ci type=boolean>p</ci></bvar>
apply><and/>
<ci>p</ci><cn>&true;</cn></apply>
<ci>p</ci>
</apply>
</property>
<property> <apply><forall/>
<bvar><ci type=boolean>p</ci></bvar>
<apply><or/>
<ci>p</ci><cn>&true;</cn></apply>
<cn>&true;</cn>
</apply>
</property>
<bvar><ci type=boolean>p</ci></bvar>
<apply><or/>
<ci>p</ci><cn>&true;</cn></apply>
<cn>&true;</cn>
</apply>
</property>
<property>
<identity>
<apply><not/><cn> &true; </apply>
<cn> &false; </cn>
</identity>
</property>
<property> <reln><identity/>
<cn base="16"> A </cn> <cn> 10 </cn> </reln> </property>
<property> <reln><identity/>
<cn base="16"> B </cn> <cn> 11 </cn> </reln></property>
<property> <reln><identity/>
<cn base="16"> C </cn> <cn> 12 </cn> </reln></property>
<property> <reln><identity/>
<cn base="16"> D </cn> <cn> 13 </cn> </reln></property>
<property> <reln><identity/>
<cn base="16"> E </cn> <cn> 14 </cn> </reln></property>
<property> <reln><identity/>
<cn base="16"> F </cn> <cn> 15 </cn> </reln></property>
</MMLdefinition>
ci
<MMLdefinition>
<name> ci </name>
<description>
A symbolic name constructor. The type attribute can
be set to any valid MathML type.
</description>
<functorclass> constructor , unary </functorclass>
<MMLattribute>
<name> type </name>
<value> constant | matrix | set | vector | list | MathMLtype </value>
<default> real </default>
</MMLattribute>
<signature> ({string|mmlpresentation}) -> symbol(constant) </signature>
<signature> [type=MathMLType]({string|mmlpresentation}) -> symbol(MathMLType) </signature>
<example><ci> xyz </ci> </example>
<example><ci> type="vector"> V </ci> </example>
</MMLdefinition>
apply
<MMLdefinition> <name> apply </name> <description> This is the MathML constructor for function application. The first argument is applied to the remaining arguments. It may be the case that some of the child elements are named elements. (See the signature.) </description> <functorclass> constructor , nary </functorclass> <signature> (function,anything*) -> application </signature> <example><apply><plus/><ci>x</ci><cn>1</cn></apply></example> <example><apply><sin/><ci>x</ci></apply></example> </MMLdefinition>
reln
<MMLdefinition> <name> reln </name> <description> This is the MathML constructor for expressing a relation between two or more mathematical objects. The first argument indicates the type of "relation" between the remaining arguments. (See the signature.) No assumptions are made about the truth value of such a relation. Typically, the relation is used as a component in the construction of some logical assertion. Relations may be combined into sets, etc. just like any other mathematical object. </description> <functorclass> constructor </functorclass> <signature> (function,anything*) -> reln </signature> <example><reln><and/><ci>P</ci><ci>Q</ci></reln></example> <example><reln><lt/><ci>x</ci><ci>y</ci></reln></example> </MMLdefinition>
fn
<MMLdefinition> <name> fn </name> <description> This is the MathML constructor for building new function names. The "name" can be a general MathML content element. It identifies that object as "usable" in a function context. By setting its definitionURL value, you can associate it with a particular function definition. Use the MathML Declare to associate a name with a lambda construct. </description> <MMLattribute> <name>definitionURL</name> <value> URL </value> <default> none </default> </MMLattribute> <functorclass> constructor </functorclass> <signature> (anything) -> function </signature> <signature> [definitionURL=functiondef](anything) -> function(definitionURL=functiondef) </signature> <example><fn><ci>F</ci></fn></example> <example><fn definitionURL="http://www.w3c/..."> <lt/><ci>G</ci></fn> </example> <!--Declaring Id to be the identity function.--> <example> <declare><fn><ci>Id</ci></fn><lambda><ci>x</ci><ci>x</ci></declare> </example> </MMLdefinition>
interval
<MMLdefinition> <name> interval </name> <description> This is the MathML constructor element for building an interval on the real line. While an interval could be expressed by combining relations appropriately, they occur explicitly because of their frequence of occurrence in common use. </description> <MMLattribute> <name>type</name> <value> closed | open | open-closed | closed-open </value> <default> closed </default> </MMLattribute> <functorclass> constructor , binary </functorclass> <signature> [type=intervaltype](expression,expression) -> interval </signature> <example><reln><and/><ci>x</ci><cn>1</cn></reln></example> <example><reln><lt/><ci>x</ci></reln></example> </MMLdefinition>
inverse
<MMLdefinition>
<name> inverse </name>
<description>
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 make it one-sided.
</description>
<MMLattribute>
<name>definitionURL</name>
<value> CDATA </value>
<default> none </default>
<!--none corresponds to using the default MathML definition ...-->
</MMLattribute>
<functorclass> operator, unary </functorclass>
<signature> (function) -> function </signature>
<signature> [definitionURL=URL](function) ->
function(definition) </signature>
<example><apply><inverse/><sin/></apply></example>
<example>
<apply>
<inverse definitionURL="www.w3c.org/MathML/Content/arcsin"/>
<sin/>
</apply>
</example>
<property><apply><forall/>
<bvar><ci>y</ci></bvar>
<apply><sin/>
<apply>
<apply><inverse/><sin/></apply>
<ci>y</ci>
</apply>
</apply>
<value><ci>y</ci></value>
</apply>
</property>
<property>
<apply>
<apply><inverse/><sin/></apply>
<apply>
<sin/>
<ci>x</ci>
</apply>
</apply>
<value><ci>x</ci></value>
</property>
<property>F(inverse(F)(y))<value>y</value></property>
</MMLdefinition>
sep
<MMLdefinition> <name> sep </name> <description> This is the MathML infix constructor used to sub-divide PCDATA into separate components. for example, this is used in the description of a multipart number such as a rational or a complex number. </description> <functorclass> punctuation </functorclass> <example><cn type="complex-polar">123<sep/>456</cn></example> <example><cn>123</cn></example> </MMLdefinition>
condition
<MMLdefinition>
<name> condition </name>
<description>
This is the MathML constructor for building conditions.
A condition differs from a relation in how it is used.
A relation is simply an expression, while a condition
is used as a predicate to place a conditions on a bound
variables.
For a compound condition use relations or apply
operators such as "and" or "or" or a set of
relations).
</description>
<functorclass> constructor, unary </functorclass>
<signature> ({reln|apply|set}) -> predicate </signature>
<example>
<condition>
<reln><lt/>
<apply><power/>
<ci>x</ci><cn>5</cn>
</apply>
<cn>3</cn>
</reln>
</condition>
</example>
</MMLdefinition>
declare
<MMLdefinition> <name> declare </name> <description> This is the MathML constructor for redefining the properties and values with mathematical objects. For example V may be a name delcared to be a vector, or V may be a name that stands for a particular vector. The attribute values of the declare statement are assigned as the corresponding default attribute values of the first object. </description> <functorclass> modifier , (unary | binary) </functorclass> <MMLattribute> <name>definitionURL</definition> <value> Any valid URL </value> </MMLattribute> <MMLattribute> <name>type</name><value> MathMLType </value> </MMLattribute> <MMLattribute> <name>nargs</name><value> number of arguments for an object of type fn </value> </MMLattribute> <signature> [attributename=attributevalue](anything) -> anything(attributevalue) </signature> <!-- The two argument form updates the properties of the first object to be those of the second. The attribute values override the properties of the "value". --> <signature> [attributename=attributevalue](anything,anything) -> anything(attributevalue) </signature> <example><reln><and/><ci>x</ci><cn>1</cn></reln></example> <example><reln><lt/><ci>x</ci></reln></example> </MMLdefinition>
lambda
<MMLdefinition>
<name> lambda </name>
<description> The operation of lambda calculus that makes a
function from an expression and a variable. The definition
at this level uses only one variable. Lambda is a binary
function, where the first argument is the variable and
the second argument is a the expression.
Lambda( x, F ) is written as \lambda x [F] in the lambda
calculus literature.
The lambda function can be viewed as the inverse of function
application.
Although the expression F may contain x, the lambda expression
is interpreted to be free of x. That is, the x variable is
a variable local to the environment of the definition of
the function or operator. Formally, lambda(x,F) is free of
x, and any substitutions, evaluations or tests for x in
lambda(x,F) should not happen.
A lambda expression on an arbitrary function applied to a
simple argument is equivalent to the arbitrary function.
E.g. lambda(x, f(x)) == f. This is a common shortcut.
</description>
<functorclass> Nary , Constructor </functorclass>
<property>
<lambda><ci>x</ci>
<apply><fn><ci>F</ci></fn><ci>x</ci></apply>
</lambda>
<value> <fn><ci>F</ci></fn> </value>
</property>
<!-- Constructing a variant of the sine function -->
<example>
<lambda>
<ci> x </ci>
<apply><sin/>
<apply><plus/>
<ci> x </ci>
<cn> 3 </cn>
</apply>
</lambda>
</example>
<!-- the identity operator -->
<example>
<lambda><ci> x </ci> <ci> x </ci> </lambda>
</example>
<property>
<reln><identity/>
<lambda><ci>x</ci>
<apply><fn><ci>F</ci></fn><ci>x</ci></apply>
</lambda>
<fn><ci>F</ci></fn>
</reln>
</property>
<MMLdefinition>
compose
<MMLdefinition>
<name> compose </name>
<description>
This is the MathML constructor for composing functions.
In order for a composition to be meaningful, the range of
the first function must be the domain of the second function,
etc. .
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.
</description>
<functorclass> Nary , Operator </functorclass>
<signature> (fn*) -> fn </signature>
<example>
<apply><compose/>
<fn><ci> f </ci></fn>
<fn><ci> g </ci></fn>
</apply></example>
<property>
<apply><forall>
<bvar><ci>x</ci></bvar>
<reln><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>
</reln>
</apply>
</property>
</MMLdefinition>
ident
<MMLdefinition>
<name> ident </name>
<description>
This is the MathML constructor for the identity function.
This function has the property that
f( x ) = x, for all x in its domain.
</description>
<functorclass> Nary , Operator </functorclass>
<signature> (symbol) -> symbol </signature>
<example>
<apply><ident/>
<ci> f </ci>
<ci> x </ci>
</apply>
</example>
<property>
<apply><forall>
<bvar><ci>x</ci></bvar>
<reln><eq/>
<apply><ident/>
<ci>f</ci>
<ci>x</ci>
</apply>
<ci>x</ci>
</reln>
</apply>
</property>
</MMLdefinition>
quotient
<MMLdefinition>
The binary function used to represent
the quotient of two integers.
division. For arguments a and b, such that
sign of a, its value would be q.
classification=function
<MMLattribute>
<attname>definitionURL</attname>
<attvalue> CDATA </attvalue>
<attdefault> none </attdefault>
</MMLattribute>
<MMLattribute>
<name>type</name>
<values>
Any MathML type
</values>
<default>integer</default>
</MMLattribute>
<signature> (integer, integer) -> integer </signature>
<signature> [type=integer](symbolic, symbolic) -> symbolic </signature>
<property><apply><forall/>
<bvar><ci>a</ci>
</bvar>
<bvar><ci>b</ci>
</bvar>
<reln/>
<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></property>
<property><apply><ident/>
<apply><quotient/>
<ci>5</ci>
<ci>4</ci>
</apply>
<ci>1</ci>
</apply></property>
=======
<name> quotient </name>
<description> Integer quotient, the result of integer
division. For arguments a and b, it returns q,
where a = b*q+r, |r| < |b| and a*r >= 0 (or
the sign of r is the same as the sign of a).
</description>
<functorclass> Binary, Function </functorclass>
<signature> (integer, integer) -> integer </signature>
<signature> (symbolic, symbolic) -> symbolic -> => → </signature>
<property>
<description>
ForAll(bvar(a,b),identity(a ,b*Quotient(a,b) + Remainder(a,b))
</description>
<apply><forall/>
<bvar><ci>a</ci></bvar>
<bvar><ci>b</ci></bvar>
<reln/><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>
<reln>
</apply>
</property>
<property>
<description>
1 = quotient(5,4)
</description>
<apply><identity/>
<apply><quotient/>
<ci>5</ci>
<ci>4</ci>
</apply>
<ci>1</ci>
<apply>
</property>
</MMLdefinition>
exp
<MMLdefinition> The exponential function. <reference> M. Abramowitz and I. Stegun, Handbook of Mathematical Functions, [4.2]</reference> classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> any MathML Type </values> <default>real</default> </MMLattribute> <signature> real -> real </signature> <signature> symbolic -> symbolic </signature> <property><apply><eq/> <apply><exp/> <cn>0</cn> </apply> <cn>1</cn> </apply></property> <property><apply><ident/> <apply><exp/> <ci>x</ci> </apply> <apply><power/> <cn>ExponentialE;</cn> <ci>x</ci> </apply> </apply></property> <property> exp(x) = limit( (1+x/n)^n, n, infinity ) </property> </MMLdefinition>
factorial
<MMLdefinition>
This element is used to construct factorials
classification=function
<MMLattribute>
<attname>definitionURL</attname>
<attvalue> CDATA </attvalue>
<attdefault> none </attdefault>
</MMLattribute>
<MMLattribute>
<name>type</name>
<values>
any MathML Type
</values>
<default>integerl</default>
</MMLattribute>
<signature> ( algebraic ) -> algebraic </signature>
<signature>(integer)->integer</signature>
<property><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>
</property>
<example><apply><factorial/>
<ci>n</ci>
</apply></example>
</MMLdefinition>
divide
<MMLdefinition>
This is the binary MathML operator that is used to construct
the mathematical expression a "divided by" b. In
general, it constructs the expression that
is equivalent to right multiplication by
the multiplicative inverse of b.
classification=function
<MMLattribute>
<attname> type </attname>
<attvalue> anything <sep/>non-commutative</attvalue>
<attdefault> real </attdefault>
</MMLattribute>
<MMLattribute>
<attname>definitionURL</attname>
<attvalue> CDATA </attvalue>
<attdefault> none </attdefault>
</MMLattribute>
<signature> (complex, complex) -> complex </signature>
<signature> (real, real) -> real </signature>
<signature> (rational, rational) -> rational </signature>
<signature> (integer, integer) -> rational </signature>
<signature> (symbolic, symbolic) -> symbolic </signature>
<property><apply><forall/>
<bvar><ci>a</ci></bvar>
<apply><eq/>
<apply><divide/>
<ci> a </ci>
<ci> 0 </ci>
</apply>
<apply><ci>Error</ci>
<ci>Division by 0</ci>
</apply>
</apply>
</apply>
</property>
<property>whenever not(a=0) then a/a = 1 </property>
<example><apply><divide/>
<ci> a </ci>
<ci> b </ci>
</apply></example>
</MMLdefinition>
max
<MMLdefinition>
Represent the maximum of a set of elements. The elements
may be listed explicitly or they may be described by a
condition, e.g., the maximum over all x in
the set A.
To be well defined, the elements must all be
comparable.
classification= function
<MMLattribute>
<attname>definitionURL</attname>
<attvalue> CDATA </attvalue>
<attdefault> none </attdefault>
</MMLattribute>
<MMLattribute>
<name>type</name>
<values>
any MathML Type
</values>
<default>real</default>
</MMLattribute>
<signature> ( ordered_set_element * ) -> ordered_set_element </signature>
<signature> ( bvar,condition,anything ) -> ordered_set_element </signature>
<example><apply><max/>
<cn>2</cn>
<cn>3</cn>
<cn>5</cn>
</apply></example>
<example><apply>
<max/>
<bvar><ci>y</ci></bvar>
<condition>
</condition>
<apply>
<power/>
<ci> y</ci>
<cn>x </cn>
</apply>
</apply>
</example>
</MMLdefinition>
min
<MMLdefinition>
Represent the maximum of a set of elements. The elements
may be listed explicitly or they may be described by a
condition, e.g., the maximum over all x in
the set A.
To be well defined, the elements must all be
comparable.
classification= function
<MMLattribute>
<attname>definitionURL</attname>
<attvalue> CDATA </attvalue>
<attdefault> none </attdefault>
</MMLattribute>
<MMLattribute>
<name>type</name>
<values>
any MathML Type
</values>
<default>real</default>
</MMLattribute>
<signature> ( ordered_set_element * ) -> ordered_set_element </signature>
<signature> ( bvar,condition,anything ) -> ordered_set_element </signature>
<example><apply><min/>
<cn>2</cn>
<cn>3</cn>
<cn>5</cn>
</apply></example>
<example><apply>
<min/>
<bvar><ci>x</ci></bvar>
<condition>
</condition>
<apply>
<power/>
<ci> x </ci>
<cn> 2 </cn>
</apply>
</apply>
</example>
</MMLdefinition>
minus
<MMLdefinition> The subtraction operator for an additive group. If one argument is provided this constructs the additive inverse of that group element. If two arguments, say a and b, are provided it constructs the mathematical expression a - b. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> any MathML Type </values> <default>real</default> </MMLattribute> <signature>[type=typevalue](typevalue,typevaluel) -> typevalue </signature> <signature>[type=typevalue](typevalue)->typevalue </signature> <property><apply><eq/> <bvar><ci>n</ci> </bvar> <apply><minus/> <cn>1</cn> </apply> <cn>-1</cn> </apply></property> <example><apply><minus/> <cn>3</cn> <cn>5</cn> </apply></example> <example><apply><minus/> <cn>3</cn> </apply></example> </MMLdefinition>
plus
<MMLdefinition> The N-ary addition operator of an algebraic structure. If no operands are provided, the expression represents the additive identity. If one operand, a, is provided the expression would evaluate to "a". If two or more operands are provided, the expression represents the group element corresponding to a left associative binary pairing of the operands. Issues with regard to the "value" of mixed operands are left up to the target system. If the author wishes to refer to specific type coercion rules, then the definitionURL attribute should be used to refer to a suitable specification. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>real</default> </MMLattribute> <signature>[type=typevalue](typevalue*) -> typevalue </signature> <property> plus( ) = 0 </property> <property> +(a) = a </property> <property> ForAll(a,Commutative, a + b = b + a)</property> <example><apply><plus/> <cn>3</cn> </apply></example> <example><apply><plus/> <cn>3</cn> <cn>5</cn> </apply></example> <example><apply><plus/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </apply></example> </MMLdefinition>
power
<MMLdefinition> The binary powering operator 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. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>real</default> </MMLattribute> <signature> (complex complex) -> complex </signature> <signature> (real real) -> complex </signature> <signature> (rational rational) -> complex </signature> <signature> (rational integer) -> rational </signature> <signature> (integer integer) -> rational </signature> <signature> (symbolic symbolic) -> symbolic </signature> <signature>[type=typevalue](typevalue,typevalue) -> typevalue </signature> <property> ForAll(a,Condition(a_NE_0),a^0=1) </property> <property> ForAll(a,a^1=a) </property> <property> ForAll(a,1^a=1) </property> <property>ForAll(a,0^0=Undefined)</property> </MMLdefinition>
rem
<MMLdefinition> Integer remainder, the result of integer division. For arguments a and b, such that the same as the sign of a, its value would be r. classification= binary, function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>integer</default> </MMLattribute> <signature> (integer integer) -> integer </signature> <signature> (symbolic symbolic) -> symbolic </signature> <signature>[type=typevalue](typevalue,typevalue)->typevalue</signature> <property> a = b*rem(a,b) + rem(a,b) </property> <property>rem(a,0) = Division_by_Zero</property> </MMLdefinition>
times
<MMLdefinition>
The n-ary multiplication operator of a
ring.
classification=function
<MMLattribute>
<attname>definitionURL</attname>
<attvalue> CDATA </attvalue>
<attdefault> none </attdefault>
</MMLattribute>
<MMLattribute>
<name>type</name>
<values>
Any MathML type
</values>
<default>real</default>
</MMLattribute>
<signature> (complex *) -> complex </signature>
<signature> (real*) -> real </signature>
<signature> (rational*) -> rational </signature>
<signature> (integer*) -> integer </signature>
<signature> (symbolic*) -> symbolic </signature>
<property>ForAll(bvars(a,b),condition(in({a,b},Commutative)),a*b=b*a)</property>
<property>ForAll(bvars(a,b,c),Associative,a*(b*c)=(a*b)*c), associativity </property>
<property> a*1=a </property>
<property> 1*a=a </property>
<property> a*0=0 </property>
<property> 0*a=0 </property>
</MMLdefinition>
root
<MMLdefinition> Construct the nth root of an object. The first argument "a" is the object and the second object "n" denotes the root, as in ( a ) ^ (1/n) classification= binary , function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <attname> type </attname> <attvalue> real <sep/> complex <sep/> principle_branch </attvalue> <attdefault> real </attdefault> </MMLattribute> <signature> ( anything , anything) -> root </signature> <property> Forall(bvars(a,n),root(a,n) = a^(1/n)) </property> <example><apply><root/> <ci> a </ci> <ci> n </ci> </apply></example> </MMLdefinition>
gcd
<MMLdefinition> This operator is used to construct an expression which represents the greatest common divisor of its arguments. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>integer</default> </MMLattribute> <signature> [type=typevalue](typevalue*) ->typevalue </signature> <property>Forall(p,q,(is(p,prime) and is(q,prime)) , gcd(p,q)=1 </property> <example><apply><gcd/> <cn>12</cn> <cn>17</cn> </apply></example> </MMLdefinition>
and
<MMLdefinition> This is the n-ary logical "and" operator. It is used to construct the logical expression which has a value of "true" when all of its operands have a truth value of "true", and "false" otherwise. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <attname> type </attname> <attvalue> any MathML type</attvalue> <attdefault> complex </attdefault> </MMLattribute> <signature> (boolean*) -> boolean </signature> <signature> [type="boolean"](symbolic*) -> boolean </signature> <property> identity(true and p , p ) </property> <property> identity(p and q , q and p ) </property> <example><apply><and/> <ci>p</ci> <ci>q</ci> </apply></example> </MMLdefinition>
or
<MMLdefinition> The logical "or" operator. The constructed expression has a truth value of true if at least one of its arguments is true. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>boolean</default> </MMLattribute> <signature> (boolean*) -> boolean </signature> <signature> [type="boolean"](symbolic*) -> boolean </signature> <property> ...</property> </MMLdefinition>
xor
<MMLdefinition> The logical "xor" operator. The constructed expression has a truth value of true if exactly one of its arguments is true. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>boolean</default> </MMLattribute> <signature> (boolean*) -> boolean </signature> <signature> [type="boolean"](symbolic*) -> symbolic </signature> </MMLdefinition>
not
<MMLdefinition> The logical "not" operator negates the truth value of its single argument. e.g., not P classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>boolean</default> </MMLattribute> <signature> (boolean) -> boolean </signature> <signature> [type="boolean"](symbolic) -> symbolic </signature> </MMLdefinition>
implies
<MMLdefinition> The implies operator. This represents the construction of the logical expression "A implies B". classification= Binary, relation <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>boolean</default> </MMLattribute> <signature> (boolean,boolean) -> boolean </signature> <property><apply><forall/> <bvar><ci>A</ci> </bvar> <bvar><ci>B</ci> </bvar> <apply><eq/> <apply><implies/> <ci>A</ci> <ci>B</ci> </apply> <apply><or/> <ci>B</ci> <apply><not/> <ci> A </ci> </apply> </apply> </apply> </apply></property> </MMLdefinition>
forall
<MMLdefinition> The logical "For all" quantifier is applied to arguments to construct a predicate. The bound variables are tagged using bvar, and the last argument is the boolean predicate that is asserted to be true. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>boolean</default> </MMLattribute> <signature> (bvar*,condition?,apply) -> boolean </signature> <signature> (bvar*,condition?,(reln)) -> boolean </signature> </MMLdefinition>
exists
<MMLdefinition> This is the MathML operator that is used to assert existance, as in "There exists an x such that x is real and x is positive." It expects three arguments. The first argument indicates the bound variable, The second argument places conditions on that bound variable. The last argument is the expression that is asserted to be true. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>boolean</default> </MMLattribute> <signature> (element,set) ->boolean </signature> </MMLdefinition>
abs
<MMLdefinition> A unary operator which represents the absolute value of its argument. In the complex case this is often referred to as the modulus. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> any MathML Type </values> <default>real</default> </MMLattribute> <signature>(real)->real</signature> <signature>(complex)->real</signature> <property>for all x and y, abs(x) + abs(y) >= abs(x+y) </property> <example><apply><abs/><ci>x</ci></apply></example> </MMLdefinition>
conjugate
<MMLdefinition> The "conjugate" arithmetic operator is used to represent the complex conjugate of its argument. In particular, conjugate( ImaginaryI ) classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <attname> type </attname> <attvalue> anything </attvalue> <attdefault> complex </attdefault> </MMLattribute> <signature> (algebraic) -> algebraic </signature> <signature>(complex)->complex</signature> </MMLdefinition>
arg
<MMLdefinition> The "arg" operator is used to construct an expression which represents the "argument" of a complex number. classification=function <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <MMLattribute> <name>type</name> <values> any MathML Type </values> <default>real</default> </MMLattribute> <signature>(compex)->real</signature> <property>???</property> <ci>a</cn> <ci>&epsilon</cn> <ci><mrow><msup><mi>a</mi><mi>b</mi><mrow></cn> <ci>v</ci> </MMLdefinition>
real
<MMLdefinition> An operator used to construct an expression representing the "real" part of a complex number. classification=unary <MMLattribute> <name>type</name> <values> Any MathML type </values> <default>real</default> </MMLattribute> <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <signature>(complex)->real</signature> <ci>a</cn> <ci>&epsilon</cn> <ci><mrow><msup><mi>a</mi><mi>b</mi><mrow></cn> <ci>v</ci> </MMLdefinition>
imaginary
<MMLdefinition> A name used as a symbolic identifier. classification=constant <MMLattribute> <attname>definitionURL</attname> <attvalue> CDATA </attvalue> <attdefault> none </attdefault> </MMLattribute> <signature>(complex)->real</signature> <example><cn type="constant">&Imaginary;</cn></example> </MMLdefinition>
eq
<MMLdefinition> <Name> eq </Name> <description> The equality operator. </description> <functorclass> Nary, relation </functorclass> <property> Commutative </property> <signature> (symbolic symbolic) -> boolean </signature> </MMLdefinition>
neq
<MMLdefinition> <Name> neq </Name> <description> The notequals operator. </description> <functorclass> Nary, relation </functorclass> <property> Commutative </property> <signature> (symbolic symbolic) -> boolean </signature> </MMLdefinition>
gt
<MMLdefinition> <Name> gt </Name> <description> The equality operator. </description> <functorclass> binary, relation </functorclass> <property> Commutative </property> <signature> (symbolic symbolic) -> boolean </signature> </MMLdefinition>
lt
<MMLdefinition> <Name> lt </Name> <description> The inequality equality operator "<" </description> <functorclass> binary, relation </functorclass> <property> Commutative </property> <signature> (symbolic, symbolic*) -> boolean </signature> </MMLdefinition>
geq
<MMLdefinition> <Name> geq </Name> <description> The inequality operator. >= </description> <functorclass> Nary, relation </functorclass> <signature> (symbolic, symbolic*) -> boolean </signature> <property> ... Commutative ? ... </property> </MMLdefinition>
leq
<MMLdefinition> <Name> leq </Name> <description> The inequality operator </description> <functorclass> Nary, relation </functorclass> <property> Commutative </property> <signature> (symbolic symbolic) -> boolean </signature> </MMLdefinition>
ln
<MMLdefinition>
<name>ln</name>
<description>
The logarithmic function. Also called the natural logarithm. The inverse
of the exponential function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.1]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<property>
Error( "logarithm has a singularity at 0" )
</property>
<signature> Intersect(real,positive) -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> ln(1) = 0 </property>
<property> ln(exp(x)) = x, "for real x" </property>
<property> exp(ln(x)) = x, always </property>
</MMLdefinition>
log
<MMLdefinition>
<Name> log </Name>
<description> The logarithmic function (base 10), or any
any other user specified base. Also called
the natural logarithm.
The inverse of the exponential function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.1]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> (real,logbase) -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>
Error( "logarithm has a singularity at 0" )
</property>
</MMLdefinition>
int
<MMLdefinition>
<Name> int </Name>
<description>
The definite or indefinite integral of a function or algebraic
expression.
There are several forms of calling sequences depending on
the nature of the areguments, and whether or not it is a
definite integral.
</description>
<functorclass> Binary , Function </functorclass>
<signature> (function) -> function </signature>
<signature> (algebraic,bvar) -> algebraic </signature>
<signature> (algebraic,bvar,interval) -> algebraic </signature>
<signature> (algebraic,bvar,condition) -> algebraic </signature>
</MMLdefinition>
diff
<MMLdefinition>
<Name> diff </Name>
<description>
For expressions, this represents the derivative of
its first argument evaluated at the second argument.
For Unary functions (only one argument) it represents
f'.
</description>
<functorclass> (Unary | Binary) , Function </functorclass>
<signature> (algebraic,bvar) -> algebraic </signature>
<property>Forall(x,diff( sin(x) , x ) = cos(x)) </property>
<property>Forall(x,diff( x , x ) = 1 ) </property>
<property>Forall(x,diff( x^2 , x ) = 2x) </property>
<property>identity( diff(sin) , cos ) </property>
</MMLdefinition>
partialdiff
<MMLdefinition>
<Name> partialdiff </Name>
<description>
For expressions, this represents the derivative of
its first argument evaluated at the second argument.
For Unary functions (only one argument) it represents
f'.
</description>
<functorclass> (Binary) , Function </functorclass>
<signature> (algebraic,bvar) -> algebraic </signature>
<property>Forall(x,diff( sin(x*y) , x ) = cos(x)) </property>
<property>Forall(x,y,diff( x*y , x ) = diff(x,x)*y + diff(y,x)*x ) </property>
<property>Forall(x,a,b,diff( a + b , x ) = diff(a,x) + diff(b,x) ) </property>
<property>identity( diff(sin) , cos ) </property>
</MMLdefinition>
lowlimit
<MMLdefinition>
<Name> lowlimit </Name>
<description> Construct a lower limit. Limits
are used in some integrals as alternative way
of describing the region over which an integral
is computed. (i.e. a connected component of the
real line.)
</description>
<functorclass> Constructor </functorclass>
<signature> (anything*) -> list </signature>
</MMLdefinition>
uplimit
<MMLdefinition>
<Name> uplimit </Name>
<description> Construct a an upper limit. Limits
are used in some integrals as alternative way
of describing the region over which an integral
is computed. (i.e. a connected component of the
real line.)
</description>
<functorclass> Constructor </functorclass>
<signature> (anything*) -> list </signature>
</MMLdefinition>
bvar
<MMLdefinition>
<Name> bvar </Name>
<description>
The bvar element is the container element
for the "bound variable" of an operation.
For example, in an integral it specifies the
variable of integration. In a derivative, it
indicates which variable with respect to
which a function is being differentiated.
When the bvar element is used to quantifiy a derivative,
the bvar element may contain a child degree element that
specifies the order of the derivative with respect to that
variable. The bvar element is also used for the internal
variable in sums and products.
</description>
<functorclass> Constructor </functorclass>
<signature> (symbol) -> symbol </signature>
<example> <bvar><ci>x</ci></bvar></example>
</MMLdefinition>
degree
<MMLdefinition>
<Name> degree </Name>
<description> A parameter used by some
MathML data-types to specify that, for example,
a bound variable is repeated several times.
</description>
<functorclass> Constructor </functorclass>
<signature> (algebraic) -> algebraic </signature>
<example> <degree><ci>x</ci></degree></example>
<property> ... </property>
</MMLdefinition>
set
<MMLdefinition>
<Name> set </Name>
<description> Construct a set. </description>
<functorclass> Nary, Constructor </functorclass>
<signature> (anything*) -> set </signature>
</MMLdefinition>
list
<MMLdefinition>
<Name> list </Name>
<description> Construct a list. </description>
<functorclass> Nary, Constructor </functorclass>
<signature> (anything*) -> list </signature>
</MMLdefinition>
union
<MMLdefinition>
<Name> union </Name>
<description> The union of two sets. </description>
<functorclass> Binary, Function </functorclass>
<signature> (set*) -> set </signature>
</MMLdefinition>
intersect
<MMLdefinition>
<Name> intersection </Name>
<description> The intersection of two sets. </description>
<functorclass> Binary, Function </functorclass>
<signature> (set set) -> set </signature>
</MMLdefinition>
in
<MMLdefinition>
<Name> in </Name>
<description>
The membership testing operation (also commonly
called "in" or "including"). Returns true if the first
argument is part of the second argument. The second
argument must be a set.
</description>
<functorclass> Binary, Function </functorclass>
<signature> (anything, set) -> boolean </signature>
</MMLdefinition>
notin
<MMLdefinition>
<Name> notin </Name>
<description>
The membership exclusion operation (also commonly
called "notin" or "including").
It is defined as "not in".
</description>
<functorclass> Binary, Function </functorclass>
<signature> (anything set) -> boolean </signature>
</MMLdefinition>
subset
<MMLdefinition>
<Name> subset </Name>
<description>
Boolean function whose value is determined by
whether or not one set is a subset of another.
</description>
<functorclass> Binary, Function </functorclass>
<signature> (set*) -> boolean </signature>
</MMLdefinition>
prsubset
<MMLdefinition>
<Name> prsubset </Name>
<description>
Boolean function whose value is determined by
whether or not one set is a proper subset of another.
</description>
<functorclass> Binary, Function </functorclass>
<signature> (set, set) -> boolean </signature>
<property>...</property>
</MMLdefinition>
notsubset
<MMLdefinition>
<Name> notsubset </Name>
<description>
Boolean function whose value is the complement
of "subset".
</description>
<functorclass> Binary, Function </functorclass>
<signature> (set, set) -> boolean </signature>
<property>...</property>
</MMLdefinition>
notprsubset
<MMLdefinition>
<Name> notprsubset </Name>
<description>
Boolean function whose value is the complement
of "proper subset".
</description>
<functorclass> Binary, Function </functorclass>
<signature> (set, set) -> boolean </signature>
<property>...</property>
</MMLdefinition>
setdiff
<MMLdefinition>
<Name> setdiff </Name>
<description>
Function indicating the difference of two sets.
</description>
<functorclass> Binary, Function </functorclass>
<signature> (set, set) -> set </signature>
<property>...</property>
</MMLdefinition>
sum
<MMLdefinition> <Name> sum </Name> <description> The sum element denotes the summation operator. Upper and lower limits for the sum, and more generally a domains for the bound variables are specified using uplimit, lowlimit or a condition on the bound variables. The index for the summation is specified by a bvar element. The sum element takes the attribute definition that can be used to override the default semantics. </description> <functorclass> Unary, Function </functorclass> <signature> (bvar*,((lowlimit,uplimit)|condition),algebraic) -> sum </signature> <signature> ... </signature> </MMLdefinition>
product
<MMLdefinition> <Name> product </Name> <description> The product element denotes the product operator. Upper and lower limits for the product, and more generally a domains for the bound variables are specified using uplimit, lowlimit or a condition on the bound variables. The index for the product is specified by a bvar element. The product element takes the attribute definition that can be used to override the default semantics. </description> <functorclass> Unary, Function </functorclass> <signature> (bvar*,((lowlimit,uplimit)|condition),algebraic) -> product </signature> <signature> ... </signature> <signature> ... </signature> </MMLdefinition>
limit
<MMLdefinition> <Name> limit </Name> <description> The sum element denotes the summation operator. Upper and lower limits for the sum, and more generally a domains for the bound variables are specified using uplimit, lowlimit or a condition on the bound variables. The index for the summation is specified by a bvar element. </description> <functorclass> Nary, Function </functorclass> <signature> (bvar*,(lowlimit | condition*),algebraic) -> limit </signature> </MMLdefinition>
tendsto
<MMLdefinition> <Name> tendsto </Name> <description> tendsto is used to specify how a limit is computed. It accepts a type attribute that determines the manner in which it tends to a value. </description> <functorclass> binary, Function </functorclass> <signature> (symbol,anything) -> condition(limit) </signature> <signature> [type=direction](symbol,anything) -> condition(limit) </signature> </MMLdefinition>
sin
<MMLdefinition>
<Name> sin </Name>
<description> The circular trigonometric function sine
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> sin(0) = 0 </property>
<property> sin(integer*Pi) = 0 </property>
<property> sin((Z+1/2)*Pi) = (-1)^Z, "for integer Z" </property>
<property> -1 <= sin(real) </property>
<property> sin(real) <= 1 </property>
<property> sin(3*x)=-4*sin(x)^3+3*sin(x), "triple angle formula"
<Reference> ditto, [4.3.27] </Reference>
</property>
</MMLdefinition>
cos
<MMLdefinition>
<Name> cos </Name>
<description> The cosine function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> cos(0) = 1 </property>
<property> cos(integer*Pi+Pi/2) = 0 </property>
<property> cos(Z*Pi) = (-1)^Z, "for integer Z" </property>
<property> -1 <= cos(real) </property>
<property> cos(real) <= 1 </property>
</MMLdefinition>
tan
<MMLdefinition>
<Name> tan </Name>
<description> The tangent function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> tan(integer*Pi) = 0 </property>
<property> tan(x) = sin(x)/cos(x) </property>
</MMLdefinition>
sec
<MMLdefinition>
<Name> sec </Name>
<description> The secant function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> sec(x) = 1/cos(x) </property>
</MMLdefinition>
csc
<MMLdefinition>
<Name> csc </Name>
<description> The cosecant function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> csc(x) = 1/sin(x) </property>
</MMLdefinition>
cot
<MMLdefinition>
<Name> cot </Name>
<description> The cotangent function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> cot(integer*Pi+Pi/2) = 0 </property>
<property> cot(x) = cos(x)/sin(x) </property>
</MMLdefinition>
sinh
<MMLdefinition>
<Name> sinh </Name>
<description> The hyperbolic sine function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>...</property>
</MMLdefinition>
cosh
<MMLdefinition>
<Name> sinh </Name>
<description> The hyperbolic sine function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>...</property>
</MMLdefinition>
tanh
<MMLdefinition>
<Name> tanh </Name>
<description> The hyperbolic tangent function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>...</property>
</MMLdefinition>
sech
<MMLdefinition>
<Name> sech </Name>
<description> The hyperbolic secant function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>...</property>
</MMLdefinition>
csch
<MMLdefinition>
<Name> csch </Name>
<description> The hyperbolic cosecant function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>...</property>
</MMLdefinition>
coth
<MMLdefinition>
<Name> coth </Name>
<description> The hyperbolic cotangent function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.3]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property>...</property>
</MMLdefinition>
arcsin
<MMLdefinition>
<Name> arcsin </Name>
<description> The inverse of the sine function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.4]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> sin(arcsin(x)) = x </property>
<property> arcsin(sin(x)) = x, "for x between -Pi/2 and Pi/2" </property>
</MMLdefinition>
arccos
<MMLdefinition>
<Name> arccos </Name>
<description> The inverse of the cosine function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.4]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> cos(arccos(x)) = x </property>
<property> arccos(cos(x)) = x, "for x between 0 and Pi" </property>
</MMLdefinition>
arctan
<MMLdefinition>
<Name> arctan </Name>
<description> The inverse of the tangent function.
<Reference> M. Abramowitz and I. Stegun, Handbook of
Mathematical Functions, [4.4]
</Reference>
</description>
<functorclass> Unary, Function </functorclass>
<signature> real -> real </signature>
<signature> symbolic -> symbolic </signature>
<property> tan(arctan(x)) = x </property>
<property> arctan(tan(x)) = x, "for x between -Pi/2 and Pi/2" </property>
</MMLdefinition>
mean
<MMLdefinition>
<Name> mean </Name>
<description>
Given k unspecified scalar arguments they are treated as equiprobable
values of a random variable and the mean is computed as:
mean( a1, a2, ... an) Sum( ai, i=1... n )/ n.
(see section 7.7 in CRC's Standard Mathematical tables and Formulae).
More generally, if the first argument is a symbol X of type
"discrete_random_variable", this is the 1st moment of the
random variable X and is defined as
E[ X ] = Sum( x*f(x), x in S )
where the probability that x = x_i is P( x = x_i) = f(x_i) .
The arguments are either all data, all discrete random variables,
or all continuous random variables.
The generalizes to continuous distributions and
k dimenions following the definitions provided in the reference:
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [7.1.2] and [7.7]
</Reference>
</description>
<MMLattribute>
<name>type</name>
<values> random_variable | continuous_random_variable | data </value>
<default> data </default>
</MMLattribute>
<functorclass>Nary , Operator </functorclass>
<signature>(scalar*) -> scalar</signature>
<signature>(scalar(type=data)*) -> scalar</signature>
<signature>(symbol(type=random_variable)*) -> scalar</signature>
<signature>(symbol(type=continuous_random_variable)*) -> scalar</signature>
<property> </property>
</MMLdefinition>
sdev
<MMLdefinition>
<Name> sdev </Name>
<description>
This represents the standard deviation.
Given k unspecified scalar arguments they are treated as equiprobable
values of a random variable and the "standard deviation" is
computed as the square root of the second moment about the mean U.
sdev( a1, a2, ... an)^2 = E( (X - U)^2 ).
If the first argument is a symbol X of type
"discrete_random_variable", then all arguments are treated as
discrete random variables, instead of data and the second moment
about the mean is computed as
Sum( ( x_i - U )^2 * f(x_i) , x_i in S )
as
where the probability that x = x_i is P( x = x_i) = f(x_i) .
The arguments are either all data, all discrete random variables,
or all continuous random variables.
The generalizes to continuous distributions and to
k dimenions following the definitions found in:
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [7.1.2] and [7.7]
</Reference>
</description>
<MMLattribute>
<name>type</name>
<values> random_variable | continuous_random_variable | data </value>
<default> data </default>
</MMLattribute>
<functorclass>Nary , Operator </functorclass>
<signature>(scalar*) -> scalar</signature>
<signature>(scalar(type=data)*) -> scalar</signature>
<signature>(symbol(type=discrete_random_variable)*) -> scalar</signature>
<signature>(symbol(type=continuous_random_variable)*) -> scalar</signature>
<property> </property>
</MMLdefinition>
variance
<MMLdefinition>
<Name> variance </Name>
<description>
This computes the second centered moment, also known as the variance.
Given k unspecified scalar arguments they are treated as equiprobable
values of a random variable and the "variance" is
computed as the second moment about the mean U.
variance( a1, a2, ... an) = E( (X - U)^2 ).
If the first argument is a symbol X of type
"discrete_random_variable", then all arguments are treated as
discrete random variables, instead of data and the second moment
about the mean is computed as in section [7.7] (see reference below.)
Sum( ( x_i - U )^2 * f(x_i) , x_i in S )
as
where the probability that x = x_i is P( x = x_i) = f(x_i) .
The arguments are either all data, all discrete random variables,
or all continuous random variables.
The generalizes to continuous distributions and to
k dimenions following the definitions found in:
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [7.1.2] and [7.7]
</Reference>
</description>
<MMLattribute>
<name>type</name>
<values> random_variable | continuous_random_variable | data </value>
<default> data </default>
</MMLattribute>
<functorclass>Nary , Operator </functorclass>
<signature>(scalar*) -> scalar</signature>
<signature>(scalar(type=data)*) -> scalar</signature>
<signature>(symbol(type=discrete_random_variable)*) -> scalar</signature>
<signature>(symbol(type=continuous_random_variable)*) -> scalar</signature>
</MMLdefinition>
median
<MMLdefinition>
<Name> median </Name>
<description>
This represents the median of n data values.
If n =2k + 1 then the mode is x_k.
If n = 2k then the median is (x_k + x_(k+1)/2).
(Note this discription assumes that the data has been
sorted into ascending order.)
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [7.7]
</Reference>
</description>
<functorclass>Nary , Operator</functorclass>
<signature>(scalar*) -> scalar</signature>
</MMLdefinition>
mode
<MMLdefinition>
<Name> mode </Name>
<description>
This represents the mode of n data values.
The mode is the data value that occurs with the
greatest frequency.
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [7.7]
</Reference>
</description>
<functorclass>Nary , Operator</functorclass>
<signature>(scalar*) -> scalar</signature>
</MMLdefinition>
moment
<MMLdefinition>
<Name> moment </Name>
<description>
This computes the ith moment of a set of data, or a random variable..
Given k scalar arguments of unspecified type, they are treated
as equiprobable values of a random variable. and the "moments" are
computed as the second moment about the mean U.
moment( degree=i, scalar*)= E( X^i ).
If the first data argument x1 is a symbol X of type
"discrete_random_variable", then all arguments are treated as
discrete random variables, instead of data and the ith moment
about the mean is computed as
Sum( (x)^i * f(x) , x in S )
where the probability that x = x_i is P( x = x_i) = f(x_i) .
The arguments are either all data, all discrete random variables,
or all continuous random variables.
The generalizes to continuous distributions and to
k dimenions following the definitions found in:
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [7.1.2]
</Reference>
</description>
<MMLattribute>
<name>type</name>
<values> random_variable | continuous_random_variable | data </value>
<default> data </default>
</MMLattribute>
<functorclass>Nary , Operator </functorclass>
<signature>(degree,scalar*) -> scalar</signature>
<signature>(degree,scalar(type=data)*) -> scalar</signature>
<signature>(degree,symbol(type=discrete_random_variable)*) -> scalar</signature>
<signature>(degree, symbol(type=continuous_random_variable)*) -> scalar</signature>
</MMLdefinition>
vector
<MMLdefinition>
<Name> vector </Name>
<description>
A vector is an ordered n-tuple of values
representing an element of an n-dimensional
vector space. The "values" are all from the
same ring, typically real or complex. They may
be numbers, symbols, or general algebraic expressions.
The type attribute can be used to specify the type of
vector that is represented.
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [2.4]
</Reference>
</description>
<MMLattribute>
<name> type </name>
<value> real | complex | symbolic | anything </value>
<default> real </default>
</MMLattribute>
<MMLattribute>
<name> other </name>
<value> row | column </value>
<default> row </default>
</MMLattribute>
<functorclass> constructor , N-ary </functorclass>
<signature>
((cn|ci|apply)*) -> vector(type=real)
</signature>
<signature>
[type=vectortype]((cn|ci|apply)*) -> vector(type=vectortype)
</signature>
<!-- Note that there is a notational need for expressing a sequence
v1, v2, ... vn with an in-explicit value of n . Also, in the
following property, it should be clarified that b,v1, and v2 are all
elements of the same ring. -->
<property> <!-- scalar multiplication-->
<apply><forall/>
<bvar><ci>b</ci></bvar>
<bvar><ci>v1</ci></bvar>
<bvar><ci>v2</ci></bvar>
<reln>
<apply><times/>
<ci>ci>b</ci>
<vector><ci>ci>v1</ci><ci>ci>v2</ci></vector>
</apply>
<vector>
<apply><ci>b</ci><ci>v1</ci></apply>
<apply><ci>b</ci><ci>v2</ci></apply>
</vector>
</reln>
</apply>
</property>
<property> vector addition </property>
<property> distributive over scalars</property>
<property> associativity.</property>
<property> Matrix * column vector </property>
<property> row vector * Matrix </property>
</property>
</MMLdefinition>
matrix
<MMLdefinition>
<Name> matrix </Name>
<description>
This is the constructor for a matrix. The matrix is
constructed from matrix rows. The type and properties
spell out the normal interaction with vectors and
scalars.
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [2.5.1]
</Reference>
</description>
<MMLattribute>
<name>type</name>
<value>real | complex | integer | symbolic | anything </value>
<default> real </default>
</MMLattribute>
<functorclass>constructor , N-ary </functorclass>
<signature>(matrixrow*) -> matrix</signature>
<signature>
[type=matrixtype](matrixrow*) ->
matrix(type=matrixtype)</signature>
<property>scalar multiplication </property>
<property>Matrix*column vector</property>
<property>Addition</property>
<property>Matrix*Matrix</property>
</MMLdefinition>
matrixrow
<MMLdefinition>
<Name> matrixrow </Name>
<description>
This is a constructor for describing the rows of a matrix.
This only occurs inside a matrix. Its "type" is determined
from the containing matrix element.
</description>
<functorclass>constructor , N-ary</functorclass>
<signature>(cn|ci|apply)->matrixrow </signature>
</MMLdefinition>
determinant
<MMLdefinition>
<Name>determinant</Name>
<description>The "determinant" of a matrix.
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [2.5.4]
</Reference>
</description>
<functorclass>Unary, operator</functorclass>
<signature>(matrix)-> scalar </signature>
</MMLdefinition>
transpose
<MMLdefinition>
<Name> transpose </Name>
<description>The transpose of a matrix or vector.
<Reference> CRC Standard Mathematical Tables and Formulae,
editor: Dan Zwillinger, CRC Press Inc., 1996, [2.4] and [2.5.1]
</Reference>
</description>
<functorclass>Unary, Operator</functorclass>
<signature>(vector)->vector(other=row)</signature>
<signature>[other=column](vector)->vector(other=row)</signature>
<signature>[other=row](vector)->vector(other=column)</signature>
<signature>(matrix)->matrix</signature>
<property>transpose(transpose(A))= A</property>
<property>transpose(transpose(V))= V</property>
</MMLdefinition>
selector
<MMLdefinition>
<Name> selector </Name>
<description>
The operator used to extract sub-objects from vectors, matrices
matrix rows and lists.
Elements are accessed by providing one index element for each
dimension. For Matrices, sub-matrices 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 ith row of A.
select( i , V ) is the ith 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 ith element of a list.
select(L) is the sequence of elements of a list.
</description>
<functorclass>N-ary, operator)</functorclass>
<signature>(scalar,scalar,matrix)->scalar</signature>
<signature>(scalar,matrix)->matrixrow</signature>
<signature>(matrix)->scalar* </property>
<signature>(scalar,(vector|list|matrixrow))->scalar</signature>
<signature>(vector|list|matrixrow)->scalar*</signature>
<property>
Forall(
bvar(A(type=matrix)),bvar(V(type=vector)),
select(A) = select(V)
)
</property>
<property>For all vectors V, V = vector(select(V))</property>
</MMLdefinition>
Overview: Mathematical Markup Language (MathML) Version 2.0
Previous: B Content Markup Validation Grammar
Next: D Operator Dictionary (Non-normative)