cn
The cn element is used to encode numerical constants. The mathematical type of number is given as an attribute. The default type is "real". Numbers such as e-notation, rational and complex, require two parts for a complete specification. The parts of such a number are separated by an empty sep element.
Many of the commonly occurring numeric constants such as π have their own elements.
See also 4.4.1.1 Number (cn).
[type=integer](numstring) -> constant(integer)
[base=base-value](numstring) -> constant(integer)
[type=rational](numstring,numstring) -> constant(rational)
[type=complex-cartesian](numstring,numstring) -> constant(complex)
[type=e-notation](numstring,numstring) -> constant(e-notation)
[type=complex-polar](numstring,numstring) -> constant(rational)
[definitionURL=definition](numstring*) -> constant(user-defined)
<apply><eq/><cn base="16"> A </cn><cn> 10 </cn></apply>
<apply><eq/><cn base="16"> B </cn><cn> 11 </cn></apply>
<apply><eq/><cn base="16"> C </cn><cn> 12 </cn></apply>
<apply><eq/><cn base="16"> D </cn><cn> 13 </cn></apply>
<apply><eq/><cn base="16"> E </cn><cn> 14 </cn></apply>
<apply><eq/><cn base="16"> F </cn><cn> 15 </cn></apply>
<cn> 245 </cn>
<cn type="integer"> 245 </cn>
<cn type="integer" base="16"> A </cn>
<cn type="rational"> 245 <sep/> 351 </cn>
<cn type="complex-cartesian"> 1 <sep/> 2 </cn>
<cn> 245 </cn>
<apply><eq/> <cn type="e-notation"> 2 <sep/> 5 </cn> <apply><times/><cn>2</cn><apply><power/><cn>10</cn><cn>5</cn></apply></apply> </apply>
ci
This element constructs an identifier (symbolic name). The type attribute is used to indicate the type of object being specified. By default, the type is real.
See also 4.4.1.2 Identifier (ci).
({string|mmlpresentation}) -> symbol
[type=typename]({string|mmlpresentation}) -> symbol(typename)
<ci> xyz </ci>
<ci type="vector"> v </ci>
csymbol
The csymbol element allows a writer to introduce new objects into MathML. The objects are linked to external definitions by means of the definitionURL attribute and encoding attribute. The csymbol element becomes the "name" of the new object. The new objects are typically either constants or functions.
[definitionURL=definition]({string|mmlpresentation}) -> defined_symbol
[type=typename]({string|mmlpresentation}) -> defined_symbol(typename)
<csymbol definitionURL=".../mydefinitionofPi">π</csymbol>
apply
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.)
See also 4.4.2.1 Apply (apply).
(function,anything*) -> apply
<apply><plus/> <ci>x</ci> <cn>1</cn> </apply>
<apply><sin/> <ci>x</ci> </apply>
reln
This constructor has been deprecated. All uses of reln are replaced by apply.
This is the MathML 1.0 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.
See also 4.4.2.2 Relation (reln).
(function,anything*) -> apply
No examples of deprecated constructions are provided.
fn
This constructor has been deprecated.
This was the MathML 1.0 constructor for building new functions. Its role was to identify a general MathML content object as a function in such a way that it could have a definition and be used in a function context such as in apply and declare. This is now accomplished through the use of definitionURL and the fact that declare and apply allow any content element as their first argument.
See also 4.4.2.3 Function (fn).
(anything) -> function
[definitionURL=functiondef](anything) ->function
No examples of deprecated constructions are provided.
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.
See also 4.4.2.4 Interval (interval).
[type=interval-type](algebraic,algebraic) -> interval(interval-type)
<interval closure="open"> <ci>x</ci> <cn>1</cn> </interval>
<interval closure="open-closed"> <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 one-sided.
See also 4.4.2.5 Inverse (inverse).
(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>
sep
This is the MathML infix constructor used to sub-divide PCDATA into separate components. This is used in the description of a multi-part number such as a rational or a complex number.
See also 4.4.2.6 Separator (sep).
<cn type="complex-polar">123<sep/>456</cn>
<cn>123</cn>
condition
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 conditions on bound variables.
You can build compound conditions by applying operators such as "and" or "or" .
See also 4.4.2.7 Condition (condition).
(apply) -> predicate
(boolean) -> predicate
<condition>
<apply><lt/>
<apply><power/><ci>x</ci><cn>5</cn></apply>
<cn>3</cn>
</apply>
</condition>
<apply><int/> <bvar><ci>x</ci></bvar> <condition><apply><in/><ci>x</ci><ci type="set">C</ci></apply></condition> <apply><ci type="function">f</ci><ci>x</ci></apply> </apply>
declare
This is the MathML constructor for associating default attribute values and values with mathematical objects. For example V may be an identifier declared to be a vector (has the attribute of being a vector), or V may be a name that stands for a particular vector.
The attribute values of the declare statement itself become the default attribute values of the first argument of the declare.
If there is a second argument, the first argument becomes an alias for the second argument and it also assumes all the properties of the second argument . For example, a ci identifier v, declared to be the vector (1,2,3) would appear in the type style of a vector, and would have a norm which is the norm of (1,2,3)
See also 4.4.2.8 Declare (declare).
[(attributename=attributevalue)*](anything) -> [(attributename=attributevalue)*](anything)
[(attributename=attributevalue)*](anything,anything) -> [(attributename=attributevalue)*](anything)
(anything,anything) -> (anything)
<declare> <ci>y</ci> <apply><plus/><ci>x</ci><cn>3</cn></apply> </declare>
<declare type="vector"> <ci> V </ci> </declare>
<declare type="vector"> <ci> V </ci> <vector><cn> 1 </cn><cn> 2 </cn><cn> 3 </cn></vector> </declare>
lambda
This is the operation of lambda calculus that constructs a function from an expression and a variable. Lambda is an n-ary 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.
See also 4.4.2.9 Lambda (lambda).
(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>
<lambda> <bvar><ci>x</ci></bvar> <apply><sin/><apply><plus/><ci> x </ci><cn> 3 </cn></apply></apply> </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.
See also 4.4.2.10 Function composition (compose).
(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>
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 range) of the identity function depends on the context in which it is used.
See also 4.4.2.11 Identity function (ident).
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/>
<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.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.2.12 Domain (domain).
(function) -> set
<apply><eq/> <apply><domain/><ci>f</ci></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.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.2.13 codomain (codomain).
(function) -> set
ForAll( y, Exists(x,y =f(x)), member(y,codomain(f)) )
<apply><eq/> <apply><codomain/><ci>f</ci></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.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.2.14 Image (image).
(function) -> set
ForAll( x, x in image(f), ThereExists(y,f(y)=x) )
<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>
domainofapplication
The domainofapplication element is a qualifier used by a number of defined functions. It denotes the domain over which a given function is being applied. Special cases of this qualifier can be abbreviated using one of interval condition or an (lowlimit,uplimit) pair. It is constructed from a set or the name of a set.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.2.15 Domain of Application (domainofapplication).
(set) -> domain
(identifier) -> domain
<apply><int/> <domainofapplication><ci>C</ci></domainofapplication> <ci>f </ci> </apply>
<apply><int/>
<domainofapplication>
<set>
<bvar><ci>t</ci></bvar>
<condition>
<apply><in/>
<ci>t</ci>
<ci type="set">C</ci>
</apply>
</condition>
</set>
</domainofapplication>
<ci>f</ci>
</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.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.2.16 Piecewise declaration (piecewise, piece, otherwise) .
(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.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.8.1 common trigonometric functions .
(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.
To override the default semantics for this element, or to associate a more specific definition, use the definitionURL and encoding attributes
See also 4.4.8.1 common trigonometric functions .
(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 non-negative.
See also 4.4.3.1 Quotient (quotient).
(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>
<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*(n-1)* ... * 1
See also 4.4.3.2 Factorial (factorial).
(algebraic) -> algebraic
(integer) -> integer
ForAll( n, n \gt 0, n! = n*(n-1)! )
<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>
<apply><factorial/> <ci>n</ci> </apply>
divide
This is the binary MathML operator that is used indicate the mathematical operation a "divided by" b.
See also 4.4.3.3 Division (divide).
(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>
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>
<apply><divide/> <ci> a </ci> <ci> b </ci> </apply>
max
This is the n-ary 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.
See also 4.4.8.1 common trigonometric functions .
(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>
min
This is the n-ary 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.
See also 4.4.8.1 common trigonometric functions .
(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>
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.
See also 4.4.3.5 Subtraction (minus).
(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, x-x=0 )
<apply><forall/>
<bvar><ci> x </ci></bvar>
<apply><eq/>
<apply><minus/><ci> x </ci><ci> x </ci></apply>
<cn>0</cn>
</apply>
</apply>
<apply><minus/> <cn>3</cn> <cn>5</cn> </apply>
<apply><minus/> <cn>3</cn> </apply>
plus
This is the n-ary addition operator of an algebraic structure. Ordinarily, the operands are provided explicitly. As an n-ary 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.
See also 4.4.3.6 Addition (plus).
[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>
<apply><plus/> <cn>3</cn> <cn>5</cn> <cn>7</cn> </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.
See also 4.4.3.7 Exponentiation (power).
(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>
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.
See also 4.4.3.8 Remainder (rem).
(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>
<apply><rem/><ci> a </ci><ci> b </ci></apply>
times
This is the n-ary multiplication operator of a ring. Ordinarily, the operands are provided explicitly. As an n-ary 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.
See also 4.4.3.9 Multiplication (times).
(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>
<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)
See also 4.4.3.10 Root (root).
(algebraic) -> root(degree(2),algebraic)
(anything) -> root(degree(2),anything)
(degree,anything) -> root
ForAll( bvars(a,n), root(degree(n),a) = a^(1/n) )
nth root of a
<apply><root/> <degree><ci> n </ci></degree> <ci> a </ci> </apply>
gcd
This is the n-ary 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.
See also 4.4.3.11 Greatest common divisor (gcd).
[type=MathMLtype](MathMLtype*) ->MathMLtype
(integer*) -> integer
(domainofapp,function) -> algebraic
(bvar+,domainofapp,algebraic) -> algebraic
<apply><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>
and
This is the n-ary 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.
See also 4.4.3.12 And (and).
(boolean*) -> boolean
ForAll( p, (true and p = p) )
ForAll( [p,q], (p and q = q and p) )
x and not(x) = false
<apply><and/> <ci>p</ci> <ci>q</ci> </apply>
or
The is the n-ary logical "or" operator. The constructed expression has a truth value of true if at least one of its arguments is true.
See also 4.4.3.13 Or (or).
(boolean*) -> boolean
[type="boolean"](symbolic*) -> boolean
<apply> <or/> <ci> a </ci> <ci> b </ci> </apply>
xor
The is the n-ary logical "xor" operator. The constructed expression has a truth value of true if an odd number of its arguments are true.
See also 4.4.3.14 Exclusive Or (xor).
(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.
See also 4.4.3.15 Not (not).
(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".
See also 4.4.3.16 Implies (implies).
(boolean,boolean) -> boolean
false implies x
<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).
See also 4.4.3.17 Universal quantifier (forall).
(domainofapp,function) -> boolean
(bvar+,domainofapp?,boolean) -> boolean
<apply>
<forall/>
<bvar><ci> x </ci></bvar>
<apply><eq/>
<apply>
<minus/><ci> x </ci><ci> x </ci>
</apply>
<cn>0</cn>
</apply>
</apply>
<apply> <forall/> <bvar><ci> 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.
See also 4.4.3.18 Existential quantifier (exists).
(bvar+,boolean) -> boolean
(bvar+,domainofapp,anything) -> boolean
<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.
See also 4.4.3.19 Absolute Value (abs).
(algebraic) -> algebraic
(real) -> real
(complex) -> real
for all x and y, abs(x) + abs(y) >= abs(x+y)
<apply><abs/><ci>x</ci></apply>
conjugate
The unary "conjugate" arithmetic operator is used to represent the complex conjugate of its argument.
See also 4.4.3.20 Complex conjugate (conjugate).
(algebraic) -> algebraic
(complex) -> complex
<apply><conjugate/>
<apply><plus/>
<ci> x </ci>
<apply><times/>
<imaginaryi/>
<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.
See also 4.4.3.21 Argument (arg).
(complex) -> real
<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.
See also 4.4.3.22 Real part (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>
<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.
See also 4.4.3.23 Imaginary part (imaginary).
(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>
<apply><imaginary/>
<apply><plus/>
<ci> x </ci>
<apply><times/><imaginaryi/><ci>y</ci></apply>
</apply>
</apply>
lcm
This n-ary 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.
See also 4.4.3.24 Lowest common multiple (lcm).
[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>
floor
The floor element is used to denote the round-down (towards -infinity) operator.
See also 4.4.3.25 Floor (floor).
(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>
<apply> <floor/> <ci> a </ci> </apply>
ceiling
The ceiling element is used to denote the round-up (towards +infinity) operator.
See also 4.4.3.26 Ceiling (ceiling).
(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>
<apply> <ceiling/> <ci> a </ci> </apply>
eq
This n-ary function is used to indicate that two or more quantities are equal. There must be at least two arguments.
See also 4.4.4.1 Equals (eq).
(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>
neq
This binary function represents the relation "not equal to" which returns true unless the two arguments are equal.
See also 4.4.4.2 Not Equals (neq).
(real,real) -> boolean
(boolean,boolean) -> boolean
(set,set) -> set
(multiset,multiset) -> multiset
Symmetric
<apply><neq/><cn>3</cn><cn>4</cn></apply>
gt
This n-ary 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.
See also 4.4.4.3 Greater than (gt).
(real,real+) -> boolean
(domainofapp,function) -> boolean
(bvar+,domainofapp,algebraic) -> boolean
Transitive
<apply><gt/><cn>3</cn><cn>2</cn></apply>
lt
This n-ary 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.
See also 4.4.4.4 Less Than (lt).
(real,real+) -> boolean
( domainofapp , function ) -> boolean
( bvar+ , domainofapp , algebraic) -> boolean
Transitive
<apply><lt/><cn>2</cn><cn>3</cn><cn>4</cn></apply>
geq
This element represents the n-ary 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.
See also 4.4.4.5 Greater Than or Equal (geq).
(real,real+) -> boolean
( domainofapp , function ) -> boolean
( bvar+ , domainofapp , algebraic ) -> boolean
Transitive
Reflexive
<apply><geq/><cn>4</cn><cn>3</cn><cn>3</cn></apply>
leq
This n-ary 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.
See also 4.4.4.6 Less Than or Equal (leq).
(real,real+) -> boolean
( domainofapp , function ) -> boolean
( bvar+ , domainofapp , arithmetic ) -> boolean
Transitive
Reflexive
<apply><leq/><cn>3</cn><cn>3</cn><cn>4</cn></apply>
equivalent
This element represents the n-ary 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.
See also 4.4.4.7 Equivalent (equivalent).
(boolean,boolean+) -> boolean
(domainofapp,function) -> boolean
(bvar+,domainofapp,boolean) -> boolean
Symmetric
Transitive
Reflexive
<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..
See also 4.4.4.8 Approximately (approx).
(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
See also 4.4.4.9 Factor Of (factorof).
(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 definite or indefinite integral of a function or algebraic expression. The definite integral involves the specification of some sort of domain of application. There are several forms of calling sequences depending on the nature of the arguments, and whether or not it is a definite integral. Those forms using interval, condition, lowlimit, or uplimit, provide convenient shorthand notations for an appropriate domainofapplication.
See also 4.4.5.1 Integral (int).
(function) -> function
(bvar,algebraic) -> algebraic
(domainofapp,function) -> function
(bvar+,domainofapp,algebraic) -> algebraic
<apply><int/> <bvar><ci> x </ci></bvar> <lowlimit><cn> 0 </cn></lowlimit> <uplimit><ci> a </ci></uplimit> <apply><ci> f </ci><ci> x </ci></apply> </apply>
<apply><int/> <bvar><ci> x </ci></bvar> <interval><ci> a </ci><ci> b </ci></interval> <apply><cos/><ci> x </ci></apply> </apply>
<apply><int/>
<bvar><ci> x </ci></bvar>
<condition>
<apply><in/><ci> x </ci><ci type="set"> D </ci></apply>
</condition>
<apply><ci type="function"> f </ci><ci> x </ci></apply>
</apply>
<apply><int/>
<domainofapplication>
<ci type="set"> D </ci>
</domainofapplication>
<ci type="function"> f </ci>
</apply>
<apply><int/>
<bvar><ci>x</ci></bvar>
<domainofapplication>
<ci type="set"> D </ci>
</domainofapplication>
<apply>
<ci type="function"> f </ci>
<bvar><ci>x</ci></bvar>
</apply>
</apply>
diff
This occurs in two forms, one for functions and one for expressions involving a bound variable.
For expressions in the bound variable x, the expression to be differentiated follows the bound variable.
If there is only one argument, a function, the result of applying diff to that function is a new function, the derivative of f, often written as f' .
See also 4.4.5.2 Differentiation (diff).
(bvar,algebraic) -> algebraic
(function) -> function
ForAll( [x,n], n!=0, diff( x^n , x ) = n*x^(n-1) )
diff( sin(x) , x ) = cos(x)
<apply><eq/>
<apply><diff/>
<bvar><ci>x</ci></bvar>
<apply><sin/><ci>x</ci></apply>
</apply>
<apply><cos/><ci>x</ci></apply>
</apply>
diff(x^2,x)
<apply><diff/> <bvar><ci>x</ci></bvar> <apply><power/><ci>x</ci><cn>2</cn></apply> </apply>
diff(f(x),x)
<apply><diff/><bvar><ci> x </ci></bvar> <apply><ci type="function"> f </ci><ci> x </ci></apply> </apply>
diff(sin) = cos
<apply><eq/><apply><diff/><sin/></apply><cos/></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.
(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>
lowlimit
This is a qualifier. It is typically used to construct a lower limit on a bound variable. Upper and lower limits are used in some integrals and sums as alternative way of describing the interval. It can also be used with user defined functions created using csymbol. Use a vector argument to convey limits on more than one bound variable.
See also 4.4.5.4 Lower limit (lowlimit).
(algebraic) -> lowlimit
See int
uplimit
This is a qualifier. It is typically used to construct a upper limit on a bound variable. Upper and lower limits are used in some integrals and sums as alternative way of describing the interval. It can also be used with user defined functions created using csymbol. Use a vector argument to convey limits on more than one bound variable.
See also 4.4.5.5 Upper limit (uplimit).
(algebraic) -> uplimit
See int
bvar
The bvar element is a special qualifier element that is used to denote the "bound variable" of an operation. A variable that is to be bound is placed in this container. 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 qualify 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 and may be used with user defined functions.
See also 4.4.5.6 Bound variable (bvar).
(symbol,degree?) -> bvar
<apply><forall/><bvar><ci>x</ci></bvar> <condition><apply><in/><ci>x</ci><reals/></apply></condition> <apply><eq/><apply><minus/><ci>x</ci><ci>x</ci></apply><cn>0</cn></apply> </apply>
<apply><diff/> <bvar><ci>x</ci><degree><cn>2</cn></degree></bvar> <apply><power/><ci>x</ci><cn>5</cn></apply> </apply>
degree
The degree element is a qualifer used by some MathML schemata to specify that, for example, a bound variable is repeated several times.
See also 4.4.5.7 Degree (degree).
(algebraic) -> degree
<apply><diff/> <bvar><ci>x</ci><degree><cn>2</cn></degree></bvar> <apply><power/><ci>x</ci><cn>5</cn></apply> </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.
See also 4.4.5.8 Divergence (divergence).
(vector(function)) -> function
(bvar+,vector(algebraic)) -> algebraic
<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 )
See also 4.4.5.9 Gradient (grad).
(function) -> vector(function)
(bvar+,algebraic) -> vector(algebraic)
<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 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.
See also 4.4.5.10 Curl (curl).
(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)
<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
See also 4.4.5.11 Laplacian (laplacian).
(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>
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.
See also 4.4.6.1 Set (set).
(anything*) -> set
(domainofapp,function) -> set
(bvar+,domainofapp,anything) -> set
<set> <ci> a </ci> <ci> b </ci> <ci> c </ci> </set>
<set>
<bvar><ci> x </ci></bvar>
<condition>
<apply><lt/>
<ci> x </ci>
<cn> 5 </cn>
</apply>
</condition>
<ci>x</ci>
</set>
<set> <domainofapplication> <ci type="set">C</ci> </domainofapplication> <ci type="function">f</ci> </set>
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.
See also 4.4.6.2 List (list).
(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 set-theoretic operation of union of sets. This n-ary operator generalizes to operations on multisets by tracking the frequency of occurrence of each element in the union. As an n-ary 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.
See also 4.4.6.3 Union (union).
(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>
intersect
This n-ary operator indicates the intersection of 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.
See also 4.4.6.4 Intersect (intersect).
(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>
in
The in element is the relational operator used for a set-theoretic inclusion ('is in' or 'is a member of').
See also 4.4.6.5 Set inclusion (in).
(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 set-theoretic exclusion ('is not in' or 'is not a member of').
See also 4.4.6.6 Set exclusion (notin).
(anything,set) -> boolean
(anything,multiset) -> boolean
<apply><notin/> <ci> a </ci> <ci type="set"> A </ci> </apply>
subset
The subset element is the n-ary relational operator element for a set-theoretic containment ('is a subset of').
See also 4.4.6.7 Subset (subset).
(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 n-ary relational operator element for set-theoretic proper containment ('is a proper subset of').
See also 4.4.6.8 Proper Subset (prsubset).
(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 set-theoretic relation 'is not a subset of'.
See also 4.4.6.9 Not Subset (notsubset).
(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 set-theoretic relation 'is not a proper subset of'.
See also 4.4.6.10 Not Proper Subset (notprsubset).
(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 set-theoretic difference of two sets.
See also 4.4.6.11 Set Difference (setdiff).
(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.
See also 4.4.6.12 Cardinality (card).
(set) -> scalar
(multiset) -> scalar
<apply><eq/> <apply><card/><ci> A </ci></apply> <ci> 5 </ci> </apply>
cartesianproduct
The cartesianproduct element is the operator for a set-theoretic cartesian product of two (or more) sets. The cartesian product of multisets produces a multiset since n-tuples may be repeated if elements in the base sets are repeated.
(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.
See also 4.4.7.1 Sum (sum).
(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>
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.
See also 4.4.7.2 Product (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.
See also 4.4.7.3 Limit (limit).
(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>
tendsto
The tendsto element is used to express the relation that a quantity is tending to a specified value.
See also 4.4.7.4 Tends To (tendsto).
(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>
<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>
exp
This element represents the exponentiation function as described in Abramowitz and Stegun, section 4.2. It takes one argument.
See also 4.4.8.2 Exponential (exp).
(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.
See also 4.4.8.3 Natural Logarithm (ln).
(real) -> real
(complex) -> complex
-pi lt Im ln x leq pi
<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.
See also 4.4.8.4 Logarithm (log).
(logbase,real) -> real
(logbase,complex) -> complex
(real) -> real
(complex) -> complex
a^b = c implies log_a c = b
<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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
sin(0) = 0
sin(integer*Pi) = 0
sin(x) = (exp(ix)-exp(-ix))/2i
<apply><sin/><ci> x </ci></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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arcsin(z) = -i ln (sqrt(1-z^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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arccos(z) = -i ln(z+i \sqrt(1-z^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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arctan(z) = (ln(1+iz)-ln(1-iz))/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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arccosh(z) = 2*ln(\sqrt((z+1)/2) + \sqrt((z-1)/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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arccoth(z) = (ln(-1-z)-ln(1-z))/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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arcsec(z) = -i ln(1/z + i \sqrt(1-1/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.
See also 4.4.8.1 common trigonometric functions .
(real) -> real
(complex) -> complex
arcsech(z) = 2 ln(\sqrt((1+z)/(2z)) + \sqrt((1-z)/(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.
See also 4.4.8.1 common trigonometric functions .
(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.
See also 4.4.8.1 common trigonometric functions .
(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
See also 4.4.9.1 Mean (mean).
(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.
See also 4.4.9.2 Standard Deviation (sdev).
(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>
<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].
See also 4.4.9.3 Variance (variance).
(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>
<apply><variance/> <ci type="discrete_random_variable"> X </ci> </apply>
median
This symbol represents an n-ary 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
See also 4.4.9.4 Median (median).
(scalar+) -> scalar
<apply><median/><cn>3</cn><cn>4</cn><cn>2</cn><cn>2</cn></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
See also 4.4.9.5 Mode (mode).
(scalar+) -> scalar
<apply><mode/><cn>3</cn><cn>4</cn><cn>2</cn><cn>2</cn></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
See also 4.4.9.6 Moment (moment).
(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
<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.
See also 4.4.9.7 Point of Moment (momentabout).
(function) -> method
(scalar) -> point
The third moment about the point p of a discrete random variable
<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 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. 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]
See also 4.4.10.1 Vector (vector).
(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> <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].
See also 4.4.10.2 Matrix (matrix).
(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> <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 n-ary constructor used to represent rows of matrices. Its arguments should be members of a ring.
See also 4.4.10.3 Matrix row (matrixrow).
(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].
See also 4.4.10.4 Determinant (determinant).
(matrix)-> scalar
<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].
See also 4.4.10.5 Transpose (transpose).
(vector)->vector(type=row)
(matrix)->matrix
(vector[type=row])->vector
transpose(transpose(A))= A
transpose(transpose(V))= V
<apply><transpose/> <ci type="matrix"> A </ci> </apply>
<apply><transpose/> <ci type="vector"> V </ci> </apply>
selector
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 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.
See also 4.4.10.6 Selector (selector).
(matrix,scalar,scalar)->scalar
(matrix,scalar)->matrixrow
(matrix)->scalar*
((vector|list|matrixrow),scalar )->scalar
(vector|list|matrixrow)->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 three-dimensional 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]
See also 4.4.10.7 Vector product (vectorproduct).
(vector,vector)->vector
if v1 and v2 are parallel then their vector product is 0
<apply><vectorproduct/><ci>u</ci><ci>v</ci></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.
See also 4.4.10.8 Scalar product (scalarproduct).
(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>
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.
See also 4.4.10.9 Outer product (outerproduct).
(vector,vector) -> matrix
<apply><outerproduct/><ci>u</ci><ci>v</ci></apply>
integers
integers represents the set of all integers.
See also 4.4.12.1 integers (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.
See also 4.4.12.2 reals (reals).
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.
See also 4.4.12.3 Rational Numbers (rationals).
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>
<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.. non-negative 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 n-1 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.
See also 4.4.12.5 complexes (complexes).
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.
See also 4.4.12.6 primes (primes).
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..
See also 4.4.12.7 Exponential e (exponentiale).
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
See also 4.4.12.8 Imaginary i (imaginaryi).
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 ill-defined floating point operation, sometimes also called NaN.
See also 4.4.12.9 Not A Number (notanumber).
undefined
<apply><eq/> <apply><divide/><cn>0</cn><cn>0</cn></apply> <notanumber/> </apply>
true
true represents the logical constant for truth.
See also 4.4.12.10 True (true).
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.
See also 4.4.12.11 False (false).
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.
See also 4.4.12.12 Empty Set (emptyset).
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.
See also 4.4.12.13 pi (pi).
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.
See also 4.4.12.14 Euler gamma (eulergamma).
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)
<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.
See also 4.4.12.15 infinity (infinity).
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>
<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>
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.5