MathML Element Reference

This section provides an element-by-element reference for how to create MathML expressions in Zed, editing conventions for each element, and support notes for how you will create each element type using the editor.


Token Elements
Basic Content Elements
Arithmetic: Part I
Arithmetic: Part II
Algebra
Logic
Relations
Calculus
Sets
Sequences and Series
Exponential Functions
Trigonometric Functions
Hyperbolic Functions
Statistics
Linear Algebra
Semantic Elements
Constant Elements

The following subsections explain how Zed supports each of the MathML content elements. The subsections are arranged in roughly the same order as those in Section 4.4 of the MathML 2.0 Recommendation.

Many of the descriptions of the content elements include links to one or more examples that were created using the editor. Clicking on these links will allow you to view the example in your web browser while reading this Users Guide, so you can try out the instructions for the editor as you read them.


Token Elements

<cn>
<ci>
<csymbol>

<cn> (#PCDATA | <sep> | presentation)* [C]
the content number token element
Example: cn.mml
See also:  <sep>

A <cn> element is created whenever a numeric character is typed into a placeholder element. So there are no templates, menu items, or palette entries for creating <cn> elements in isolation.

Special care must be taken in handling <cn> elements using the base or type attribute. The values of these attributes may be supplied using the general attribute entry support, however, many values for the type attribute depend on the <sep> element to divide the character data for the <cn> element into separate parts. To enter such an element, first enter the character data for each of the separated parts all run together into one <cn> element, then go back and insert the necessary <sep> elements using the # key, from back to front. The character data after the <sep> element will seem to disappear, but supply the desired value of the type attribute and the character data will reappear in its proper position.


<ci> (#PCDATA | presentation)* [C]
the content identifier token element

A <ci> element is created whenever an alphabetic character is typed into a placeholder element. So there are no templates, menu items, or palette entries for creating <ci> elements in isolation.

The general attribute entry support may be used to supply the value for the type attribute. The default configuration provides a special layout transformation for <ci> elements with type="vector"; others may be supplied using the layout rules configuration dialog.


<csymbol> (#PCDATA | presentation)* [2.0] [C]
the content symbol token element

Zed does not support editing <csymbol> elements, although they may be entered as MathML source.


Basic Content Elements

<apply>
<reln>
<fn>
<interval>
<inverse>
<sep>
<condition>
<declare>
<lambda>
<compose>
<ident>
<domain>
<codomain>
<image>
<domainofapplication>
<piecewise>
<piece>
<otherwise>

<apply> (op, (arg)*) [C]
the function application constructor element
Menu:  Basic→Function→apply
Palette:  Basic (1 1)
Template:  apply
Template:  [[]
Template:  []]
Example: apply.mml

Most instances of the <apply> constructor element are constructed as needed upon the application of operators and other templates that use them. However, the apply template, palette, and menu items may be used to construct references to general functions, particularly those not predefined as being represented by other elements. In addition, after entering the name of a function, the [ key may be used as an accelerator for the apply template. The apply template encloses the current expression in a new instance of an <apply> element, placing the expression as the function being applied, and creates a new placeholder for entering a first argument to the new function. After entering the argument list for the new function, the ] key may be used to navigate out to the newly created function expression to continue input.

The <apply> element is treated as an nary operator requiring at least two arguments, the function and an argument. In the absence of other presentation rules associated with the function being applied, the function is presented as a prefix argument, and the arguments to the function are presented in parenthesis, separated by commas.

In a postfix input context, the [ key invokes the <apply> template. The ] key navigates out to the next enclosing instance of the <apply> element used to construct a reference to a general function.


<reln> (op, (arg)*) [1.01] [C]
the relation application constructor element
See also:  <apply>

The <reln> constructor element has been superceded by the <apply> element. Zed does not support editing <reln> elements.


<fn> (expr) [1.01] [C]
the general function constructor element
Menu:  Basic→Function→fn
Template:  fn
Example: fn.mml
See also:  <apply>

The fn palette and menu items each enclose the current expression with a new instance of the <fn> constructor element.

The <fn> element has been deprecated as obsolete. Zed supports creating <fn> elements, which are presented by the presentation of their single child element. Files containing <fn> elements can be saved to a file or to the clipboard, but when these files are read in, the <fn> elements are removed on input.


<interval> ((left, right) | <condition>) [C]
the numeric interval constructor element
Menu:  Basic→Interval→(...)
Menu:  Basic→Interval→[...]
Menu:  Basic→Interval→(...]
Menu:  Basic→Interval→[...)
Menu:  Basic→Interval→interval
Menu:  Basic→Interval→no closure
Palette:  Basic (2 1)
Template:  interval
Template:  open
Template:  closed
Template:  open-closed
Template:  closed-open
Template:  noclosure
Example: interval.mml
See also:  <condition><int>

The interval template, palette, and menu item each enclose the current expression with a new instance of the <interval> constructor element. The enclosed expression becomes the left endpoint of the interval, and a placeholder provides a place for entering the right endpoint.

Additional templates and menu items are provided for specifying the value of the closure attribute, or for removing the attribute altogether. The general attribute entry support may also be used to supply the value for the closure attribute.

The <interval> element may appear as a child element of the <int> element. In this case, the <interval> element should appear as the lower limit of integration of a three argument <int> element.

The <interval> element is a binary operator, and is presented as a comma separated list of its arguments, enclosed in parentheses or square brackets as required by the closure attribute.

Zed does not support editing <interval> elements involving <condition> elements.


<inverse/> () [C]
the functional inverse operator
Menu:  Basic→Function→inverse
Palette:  Basic (2 2)
Template:  inverse
Example: inverse.mml
See also:  <ident><compose>

The inverse template, palette, and menu item each enclose the current expression with a new application of the <inverse> operator. The enclosed expression becomes the function being inverted.

The <inverse> element is a unary operator, and is presented as a postfix application of a superscript of -1.


<sep/> () [C]
the content number component separator empty element
Template:  [#]
See also:  <cn>

The <sep> element only appears as a child element of the <cn> element. There are no templates, menu items, or palette entries for creating <sep> elements in isolation; the keyboard accelerator # can be used to insert a <sep> element within a <cn> element.


<condition> (<apply> | <reln>) [C]
the general propositional qualifier element
Menu:  Basic→Other→condition
Template:  condition
Example: condition.mml
See also:   <interval> <list> <set> <exists> <forall> <int> <limit> <max> <min> <product> <sum>

The <condition> element is usually found as a qualifier element on other elements, providing a range for an associated bound variable.

Zed supports creating <condition> elements, which are presented by the presentation of their single child element. However, Zed does not support editing <condition> elements as qualifier elements on other elements.


<declare> (<ci>, (value)?) [C]
the symbol type/value declaration element

Zed does not support editing <declare> elements, although they may be entered as MathML source. Zed does not present <declare> elements in a visible way.


<lambda> ((<bvar>)*, body) [C]
the lambda expression function constructor element
Menu:  Basic→Function→lambda
Palette:  Basic (3 1)
Template:  lambda
Template:  lambda2
Example: lambda.mml
See also:  <bvar>

The lambda template, palette, and menu item each enclose the current expression with a new application of the <lambda> constructor. The enclosed expression becomes the body of the expression.

An additional template is provided to create <lambda> elements with additional qualifiers. The bound variables can be created by starting with the lambda2 named template.

The <lambda> element accepts from one to two arguments. The one argument version is presented as a lambda expression with no bound variables. The two argument version presents the lambda expression with its second argument as a list of bound variables, enclosed in parentheses.

Special input conventions are needed to enter the bound variables to the lambda expression. These conventions are borrowed from those used to create and remove elements of other nary operators.

The usual operations on nary operators can be used to insert or remove arguments of the <lambda> element. Creating the first argument follows the usual conventions for nary operators, but the second argument, containing the list of bound variables, requires special treatment.

When entering the list of bound variables, the list of variables can be viewed as its own element containing a list of arguments. So at this level of the expression, the usual operations on nary operators can be used to insert and remove additional bound variables.

In the content MathML generated by the <lambda> element, the second argument produces <bvar> qualifier elements for each of bound variable. These elements are generated as needed by the means used to create the <lambda> element.


<compose/> () [C]
the functional composition operator
Menu:  Basic→Function→compose
Palette:  Basic (3 2)
Template:  compose
Example: compose.mml
See also:  <ident><inverse>

The compose template, palette, and menu items each enclose the current expression with a new application of the <compose> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <compose> element is an nary operator and an associative operator requiring at least two arguments, and is presented as an infix operator. A small circle symbol is used to present the operator.


<ident/> () [C]
the functional identity constant symbol
Menu:  Basic→Function→ident
Palette:  Basic (1 2)
Template:  ident
Example: ident.mml
See also:  <inverse><compose>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented by the number "1".


<domain/> () [2.0] [C]
the functional domain operator
Menu:  Basic→Function→domain
Palette:  Basic (1 3)
Template:  domain
Example: domain.mml
See also:  <codomain><image>

The domain template, palette, and menu item each enclose the current expression with a new application of the <domain> operator. The enclosed expression becomes the argument of the function.

The <domain> element is a unary operator, and is presented as a prefix application of the string "domain".


<codomain/> () [2.0] [C]
the functional codomain (range) operator
Menu:  Basic→Function→codomain
Palette:  Basic (2 3)
Template:  codomain
Example: codomain.mml
See also:  <domain><image>

The codomain template, palette, and menu item each enclose the current expression with a new application of the <codomain> operator. The enclosed expression becomes the argument of the function.

The <codomain> element is a unary operator, and is presented as a prefix application of the string "codomain".


<image/> () [2.0] [C]
the functional image operator
Menu:  Basic→Function→image
Palette:  Basic (3 3)
Template:  image
Example: image.mml
See also:  <domain><codomain>

The image template, palette, and menu item each enclose the current expression with a new application of the <image> operator. The enclosed expression becomes the argument of the function.

The <image> element is a unary operator, and is presented as a prefix application of the string "image".


<domainofapplication> (expr) [2.0] [C]
the domain of application qualifier element
Menu:  Basic→Other→domain of application
Template:  domainofapplication
Example: domainofapplication.mml
See also:  <int>

The <domainofapplication> element typically appears as a child element of the <int> element. The domainofapplication template and menu item each act to wrap the current expression with a new <domainofapplication> element, which should appear as the lower limit of integration of a three argument <int> element.

To create an integral having only the integrand and the domain of integration as arguments, use the int3 template to create a three argument <int> element, create the lower limit of integration, and use the domainofapplication template to enclose the lower limit with a <domainofapplication> element. The presentation of the domain of integration will change to reflect the fact that the integration variable is left unspecified.


<piecewise> ((<piece>)*, (<otherwise>)?) [2.0] [C]
the piecewise function constructor element
Menu:  Basic→Piecewise→piecewise
Palette:  Basic (1 4)
Template:  piecewise
Example: piecewise.mml
See also:  <piece><otherwise>

The piecewise template, palette, and menu item each enclose the current expression with a new <piecewise> constructor element. The enclosed expression becomes the first piece.

The <piecewise> element is an nary operator, and is presented as a vertical list of its pieces, preceded by a curly brace. The various child elements of each piece of the <piecewise> element are left aligned using <maligngroup> elements in the presentation MathML.


<piece> (value, condition) [2.0] [C]
the piecewise component function constructor element
Menu:  Basic→Piecewise→piece
Palette:  Basic (2 4)
Template:  piece
Example: piece.mml
See also:  <piecewise><otherwise>

The piece template, palette, and menu item each enclose the current expression with a new <piece> constructor element. The enclosed expression becomes the value conditionally supplied by the piece, and a new placeholder is created to hold the condition.

The <piece> element takes two child elements, and is presented as an infix application of the string "if".


<otherwise> (value) [2.0] [C]
the piecewise default function constructor element
Menu:  Basic→Piecewise→otherwise
Palette:  Basic (3 4)
Template:  otherwise
Example: otherwise.mml
See also:  <piecewise><piece>

The otherwise template, palette, and menu item each enclose the current expression with a new <otherwise> constructor element. The enclosed expression becomes the value used when no other piece applies.

The <otherwise> element takes one child element, and is presented as a postfix application of the string "otherwise".


Arithmetic: Part I

<plus>
<minus>
<times>
<divide>
<power>
<root>

<plus/> () [C]
the arithmetic addition operator
Menu:  Arithmetic→Plus→+ x
Menu:  Arithmetic→Plus→x + y
Palette:  Arithmetic (1 1)
Palette:  Arithmetic (1 2)
Template:  [+]
Template:  [Ctrl++]
Example: plus.mml
See also:  <minus><times><divide>

The plus templates, palette, and menu items each enclose the current expression with a new application of the <plus> operator. The enclosed expression becomes the first argument of the operator. The palette and menu items for binary plus create an additional placeholder for entering a second argument.

The <plus> element is an nary operator and an associative operator, and is presented as an infix application of the "+" operator.

On input, the <plus> template is treated as a binary operator. Using the Ctrl key allows the user to create the <plus> element as a unary operator.


<minus/> () [C]
the arithmetic subtraction (negation) operator
Menu:  Arithmetic→Plus→- x
Menu:  Arithmetic→Plus→x - y
Palette:  Arithmetic (2 1)
Palette:  Arithmetic (2 2)
Template:  [-]
Template:  [Ctrl+-]
Example: minus.mml
See also:  <plus><times><divide>

The minus templates, palette, and menu items each enclose the current expression with a new application of the <minus> operator. The enclosed expression becomes the first argument of the operator. The palette and menu items for binary minus create an additional placeholder for entering a second argument.

The <minus> element is overloaded: as a unary operator it is presented in prefix form, and with two or more arguments it is presented in infix form as an nary operator.

The <minus> element is also overloaded on input: in a prefix input context, it is treated as a unary operator, while in a postfix input context, it is treated as a binary operator. Using the Ctrl key reverses the assignment so that one can obtain either template in any input context.


<times/> () [C]
the arithmetic multiplication operator
Menu:  Arithmetic→Times→x * y
Palette:  Arithmetic (3 1)
Template:  [*]
Template:  [.]
Example: times.mml
See also:  <plus><minus><divide>

The times template, palette, and menu items each enclose the current expression with a new application of the <times> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <times> element is an nary operator and an associative operator requiring at least two arguments, and is presented as an infix operator. An invisible times symbol is used to present the operator.


<divide/> () [C]
the arithmetic division operator
Menu:  Arithmetic→Times→x / y
Palette:  Arithmetic (4 1)
Template:  [/]
Example: divide.mml
See also:  <plus><minus><times>

The divide template, palette, and menu items each enclose the current expression with a new application of the <divide> operator. The enclosed expression becomes the numerator of the fraction, and a placeholder provides a place for entering the denominator.

The <divide> element is presented as an upright fraction.


<power/> () [C]
the elementary general exponentiation function
Menu:  Arithmetic→Power→x ^ y
Palette:  Arithmetic (5 2)
Template:  [^]
Example: power.mml
See also:  <root>

The power template, palette, and menu items each enclose the current expression with a new application of the <power> operator. The enclosed expression becomes the base of the expression, and a placeholder provides a place for entering the exponent.

The <power> element is presented by placing the exponent as a superscript of the base.


<root/> () [C]
the general algebraic root function
Menu:  Arithmetic→Power→sqrt
Menu:  Arithmetic→Power→root
Palette:  Arithmetic (3 2)
Palette:  Arithmetic (4 2)
Template:  [Ctrl+`]
Template:  [`]
Example: sqrt.mml
Example: root.mml
See also:  <power><degree>

The sqrt template, palette, and menu items each enclose the current expression with a new application of the <root> operator. The enclosed expression becomes the argument of the expression.

The <root> template, palette, and menu items each enclose the current expression with a new application of the <root> operator. The enclosed expression becomes the argument of the expression, and and a placeholder provides a place for entering the degree of the root.

The <root> element accepts one or two arguments. The usual operations on nary operators can be used to insert or remove arguments of the <root> element. The one argument version is presented with the radical sign enclosing the argument. The two argument version is presented as the one argument version, but with the second argument presented as the degree of the root as a preceding superscript of the operator.

In the content MathML generated by the <root> element, the second argument produces a <degree> qualifier element, generated as needed by the means used to create the <root> element.


Arithmetic: Part II

<factorial>
<quotient>
<rem>
<gcd>
<lcm>
<max>
<min>
<floor>
<ceiling>

<factorial/> () [C]
the arithmetic factorial function
Menu:  Arithmetic→Other→factorial
Palette:  Arithmetic[2] (1 1)
Template:  [!]
Template:  factorial
Example: factorial.mml

The factorial template, palette, and menu item each enclose the current expression with a new application of the <factorial> operator. The enclosed expression becomes the argument of the function.

The <factorial> element is a unary operator, and is presented as a postfix application of the "!" operator.


<quotient/> () [C]
the integer quotient function
Menu:  Arithmetic→Other→quotient
Palette:  Arithmetic[2] (2 2)
Template:  quotient
Example: quotient.mml
See also:  <rem>

The quotient template, palette, and menu item each enclose the current expression with a new application of the <quotient> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <quotient> element is a binary operator, and is presented as a comma separated list of its arguments, enclosed in parentheses, preceded by the string "quo" as a prefix operator.


<rem/> () [C]
the integer remainder function
Menu:  Arithmetic→Other→rem
Palette:  Arithmetic[2] (3 2)
Template:  rem
Example: rem.mml
See also:  <quotient>

The rem template, palette, and menu item each enclose the current expression with a new application of the <rem> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <rem> element is a binary operator, and is presented as a comma separated list of its arguments, enclosed in parentheses, preceded by the string "rem" as a prefix operator.


<gcd/> () [C]
the arithmetic greatest common divisor function
Menu:  Arithmetic→Other→gcd
Palette:  Arithmetic[2] (2 1)
Template:  gcd
Example: gcd.mml
See also:  <lcm>

The gcd template, palette, and menu item each enclose the current expression with a new application of the <gcd> element. The enclosed expression becomes the first element of the set.

The <gcd> element is an nary operator, and is presented as a comma separated list of its child elements, enclosed in parentheses, preceded by the string "gcd" as a prefix operator.


<lcm/> () [2.0] [C]
the arithmetic least common multiple function
Menu:  Arithmetic→Other→lcm
Palette:  Arithmetic[2] (3 1)
Template:  lcm
Example: lcm.mml
See also:  <gcd>

The lcm template, palette, and menu item each enclose the current expression with a new application of the <lcm> element. The enclosed expression becomes the first element of the set.

The <lcm> element is an nary operator, and is presented as a comma separated list of its child elements, enclosed in parentheses, preceded by the string "lcm" as a prefix operator.


<max/> () [C]
the arithmetic maximum function
Menu:  Arithmetic→Other→max
Palette:  Arithmetic[2] (4 1)
Template:  max
Example: max.mml
See also:  <min><condition>

The max template, palette, and menu item each enclose the current expression with a new application of the <max> element. The enclosed expression becomes the first element of the set.

The <max> element is an nary operator, and is presented as a comma separated list of its child elements, enclosed in curly braces, preceded by the string "max" as a prefix operator.

Zed does not support editing <max> elements involving <condition> elements.


<min/> () [C]
the arithmetic minimum function
Menu:  Arithmetic→Other→min
Palette:  Arithmetic[2] (5 1)
Template:  min
Example: min.mml
See also:  <max><condition>

The min template, palette, and menu item each enclose the current expression with a new application of the <min> element. The enclosed expression becomes the first element of the set.

The <min> element is an nary operator, and is presented as a comma separated list of its child elements, enclosed in curly braces, preceded by the string "min" as a prefix operator.

Zed does not support editing <min> elements involving <condition> elements.


<floor/> () [2.0] [C]
the arithmetic integer floor function
Menu:  Arithmetic→Other→floor
Palette:  Arithmetic[2] (4 2)
Template:  floor
Example: floor.mml
See also:  <ceiling>

The floor template, palette, and menu item each enclose the current expression with a new application of the <floor> operator. The enclosed expression becomes the argument of the function.

The <floor> element is a unary operator, and is presented by enclosing its argument in floor fences.


<ceiling/> () [2.0] [C]
the arithmetic integer ceiling function
Menu:  Arithmetic→Other→ceiling
Palette:  Arithmetic[2] (5 2)
Template:  ceiling
Example: ceiling.mml
See also:  <floor>

The ceiling template, palette, and menu item each enclose the current expression with a new application of the <ceiling> operator. The enclosed expression becomes the argument of the function.

The <ceiling> element is a unary operator, and is presented by enclosing its argument in ceiling fences.


Algebra

<abs>
<arg>
<real>
<imaginary>
<conjugate>

<abs/> () [C]
the absolute value function
Menu:  Algebra→abs
Palette:  Algebra (1 1)
Palette:  Arithmetic[2] (1 2)
Template:  abs
Example: abs.mml
See also:  <arg>

The abs template, palette, and menu item each enclose the current expression with a new application of the <abs> operator. The enclosed expression becomes the argument of the function.

The <abs> element is a unary operator, and is presented by enclosing its argument in vertical bars.


<arg/> () [2.0] [C]
the complex argument function
Menu:  Algebra→arg
Palette:  Algebra (1 2)
Template:  arg
Example: arg.mml
See also:  <abs>

The arg template, palette, and menu item each enclose the current expression with a new application of the <arg> operator. The enclosed expression becomes the argument of the function.

The <arg> element is a unary operator, and is presented as a prefix application of the string "arg".


<real/> () [2.0] [C]
the complex real part function
Menu:  Algebra→real
Palette:  Algebra (1 3)
Template:  real
Example: real.mml
See also:  <imaginary>

The real template, palette, and menu item each enclose the current expression with a new application of the <real> operator. The enclosed expression becomes the argument of the function.

The <real> element is a unary operator, and is presented as a prefix application of the Fraktur capital "R".


<imaginary/> () [2.0] [C]
the complex imaginary part function
Menu:  Algebra→imaginary
Palette:  Algebra (1 4)
Template:  imaginary
Example: imaginary.mml
See also:  <real>

The imaginary template, palette, and menu item each enclose the current expression with a new application of the <imaginary> operator. The enclosed expression becomes the argument of the function.

The <imaginary> element is a unary operator, and is presented as a prefix application of the Fraktur capital "I".


<conjugate/> () [C]
the complex conjugate function
Menu:  Algebra→conjugate
Palette:  Algebra (1 5)
Template:  conjugate
Example: conjugate.mml

The conjugate template, palette, and menu item each enclose the current expression with a new application of the <conjugate> operator. The enclosed expression becomes the argument of the function.

The <conjugate> element is a unary operator, and is presented by a horizontal bar over the argument.


Logic

<and>
<or>
<xor>
<not>
<implies>
<forall>
<exists>

<and/> () [C]
the logical conjunction operator
Menu:  Logic→and
Palette:  Logic (1 1)
Template:  and
Template:  [&]
Example: and.mml
See also:  <or><xor><not>

The and template, palette, and menu item each enclose the current expression with a new application of the <and> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <and> element is an nary operator and an associative operator requiring at least two arguments, and is presented as an infix operator. The upwards "V" symbol is used to present the operator.


<or/> () [C]
the logical disjunction operator
Menu:  Logic→or
Palette:  Logic (1 2)
Template:  or
Template:  [|]
Example: or.mml
See also:  <and><xor><not>

The or template, palette, and menu item each enclose the current expression with a new application of the <or> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <or> element is an nary operator and an associative operator requiring at least two arguments, and is presented as an infix operator. The downwards "V" symbol is used to present the operator.


<xor/> () [C]
the logical exclusive or operator
Menu:  Logic→xor
Palette:  Logic (1 3)
Template:  xor
Example: xor.mml
See also:  <and><or><not>

The xor template, palette, and menu item each enclose the current expression with a new application of the <xor> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <xor> element is an nary operator and an associative operator requiring at least two arguments, and is presented as an infix operator. The circled plus symbol is used to present the operator.


<not/> () [C]
the logical negation operator
Menu:  Logic→not
Palette:  Logic (1 4)
Template:  not
Template:  [!]
Example: not.mml
See also:  <and><or><xor><not>

The not template, palette, and menu item each enclose the current expression with a new application of the <xor> operator. The enclosed expression becomes the argument of the operator.

The <not> element is a unary operator, and is presented as an prefix operator. The negation symbol is used to present the operator.


<implies/> () [C]
the logical implication relation
Menu:  Logic→implies
Palette:  Logic (1 5)
Template:  implies
Example: implies.mml

The implies template, palette, and menu item each enclose the current expression with a new application of the <implies> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <implies> element is a binary operator, and is presented as an infix operator. The double right arrow symbol is used to present the operator.


<forall/> () [C]
the logical universal quantifier
Menu:  Logic→forall
Palette:  Logic (1 6)
Template:  forall
Template:  forall2
Example: forall.mml
See also:  <exists><condition>

The forall template, palette, and menu item each enclose the current expression with a new application of the <forall> operator. The enclosed expression becomes the body of the expression.

An additional template is provided to create <forall> elements with additional qualifiers. The bound variables can be created by starting with the forall2 named template.

The <forall> element accepts from one to two arguments. The one argument version is presented as a quantified expression with no bound variables. The two argument version presents the quantified expression with its second argument as a list of bound variables, enclosed in parentheses.

Special input conventions are needed to enter the bound variables to the quantified expression. These conventions are borrowed from those used to create and remove elements of other nary operators.

The usual operations on nary operators can be used to insert or remove arguments of the <forall> element. Creating the first argument follows the usual conventions for nary operators, but the second argument, containing the list of bound variables, requires special treatment.

When entering the list of bound variables, the list of variables can be viewed as its own element containing a list of arguments. So at this level of the expression, the usual operations on nary operators can be used to insert and remove additional bound variables.

In the content MathML generated by the <forall> element, the second argument produces <bvar> qualifier elements for each of bound variable. These elements are generated as needed by the means used to create the <forall> element.

Zed does not support editing <forall> elements involving <condition> elements.


<exists/> () [C]
the logical existential quantifier
Menu:  Logic→exists
Palette:  Logic (1 7)
Template:  exists
Template:  exists2
Example: exists.mml
See also:  <forall><condition>

The exists template, palette, and menu item each enclose the current expression with a new application of the <exists> operator. The enclosed expression becomes the body of the expression.

An additional template is provided to create <exists> elements with additional qualifiers. The bound variables can be created by starting with the exists2 named template.

The <exists> element accepts from one to two arguments. The one argument version is presented as a quantified expression with no bound variables. The two argument version presents the quantified expression with its second argument as a list of bound variables, enclosed in parentheses.

Special input conventions are needed to enter the bound variables to the quantified expression. These conventions are borrowed from those used to create and remove elements of other nary operators.

The usual operations on nary operators can be used to insert or remove arguments of the <exists> element. Creating the first argument follows the usual conventions for nary operators, but the second argument, containing the list of bound variables, requires special treatment.

When entering the list of bound variables, the list of variables can be viewed as its own element containing a list of arguments. So at this level of the expression, the usual operations on nary operators can be used to insert and remove additional bound variables.

In the content MathML generated by the <exists> element, the second argument produces <bvar> qualifier elements for each of bound variable. These elements are generated as needed by the means used to create the <exists> element.

Zed does not support editing <exists> elements involving <condition> elements.


Relations

<eq>
<neq>
<gt>
<lt>
<geq>
<leq>
<equivalent>
<approx>
<factorof>

<eq/> () [C]
the equality relation
Menu:  Relations→=
Palette:  Relations (1 1)
Template:  eq
Template:  [=]
Example: eq.mml
See also:  <eq><neq><gt><lt><geq><leq>

The eq template, palette, and menu item each enclose the current expression with a new application of the <eq> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <eq> element is an nary operator and an infix operator that takes two or more arguments. The equal sign is used to present the operator.


<neq/> () [C]
the negated equality relation
Menu:  Relations→<>
Palette:  Relations (1 2)
Template:  neq
Template:  [Ctrl+=]
Example: neq.mml
See also:  <eq><neq><gt><lt><geq><leq>

The neq template, palette, and menu item each enclose the current expression with a new application of the <neq> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <neq> element is presented as an infix operator. It is also a binary operator. The negated equal sign is used to present the operator.


<gt/> () [C]
the greater-than relation
Menu:  Relations→>
Palette:  Relations (3 1)
Template:  gt
Template:  [>]
Example: gt.mml
See also:  <eq><neq><gt><lt><geq><leq>

The gt template, palette, and menu item each enclose the current expression with a new application of the <gt> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <gt> element is an nary operator and an infix operator that takes two or more arguments. The greater than sign is used to present the operator.


<lt/> () [C]
the less-than relation
Menu:  Relations→<
Palette:  Relations (2 1)
Template:  lt
Template:  [<]
Example: lt.mml
See also:  <eq><neq><gt><lt><geq><leq>

The lt template, palette, and menu item each enclose the current expression with a new application of the <lt> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <lt> element is an nary operator and an infix operator that takes two or more arguments. The less than sign is used to present the operator.


<geq/> () [C]
the greater-than or equal to relation
Menu:  Relations→>=
Palette:  Relations (3 2)
Template:  geq
Template:  [Ctrl+>]
Example: geq.mml
See also:  <eq><neq><gt><lt><geq><leq>

The geq template, palette, and menu item each enclose the current expression with a new application of the <geq> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <geq> element is an nary operator and an infix operator that takes two or more arguments. The greater than or equal sign is used to present the operator.


<leq/> () [C]
the less-than or equal to relation
Menu:  Relations→<=
Palette:  Relations (2 2)
Template:  leq
Template:  [Ctrl+<]
Example: leq.mml
See also:  <eq><neq><gt><lt><geq><leq>

The leq template, palette, and menu item each enclose the current expression with a new application of the <leq> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <leq> element is an nary operator and an infix operator that takes two or more arguments. The less than or equal sign is used to present the operator.


<equivalent/> () [2.0] [C]
the logical equivalence relation
Menu:  Relations→==
Palette:  Relations (1 3)
Template:  equivalent
Example: equivalent.mml

The equivalent template, palette, and menu item each enclose the current expression with a new application of the <equivalent> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <equivalent> element is an nary operator and an infix operator that takes two or more arguments. The equivalent sign is used to present the operator.


<approx/> () [2.0] [C]
the approximately equal to relation
Menu:  Relations→~~
Palette:  Relations (2 3)
Template:  approx
Example: approx.mml

The approx template, palette, and menu item each enclose the current expression with a new application of the <approx> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <approx> element is presented as an infix operator. It is also a binary operator. The approximately equal sign is used to present the operator.


<factorof/> () [2.0] [C]
the integer divisibility relation
Menu:  Relations→|
Palette:  Relations (3 3)
Template:  factorof
Example: factorof.mml

The factorof template, palette, and menu item each enclose the current expression with a new application of the <factorof> operator. The enclosed expression becomes the first argument of the function, and a placeholder provides a place for entering a second argument.

The <factorof> element is presented as an infix operator. It is also a binary operator. A vertical bar is used to present the operator.


Calculus

<int>
<diff>
<partialdiff>
<lowlimit>
<uplimit>
<bvar>
<degree>
<divergence>
<grad>
<curl>
<laplacian>

<int/> () [C]
the elementary integration operator
Menu:  Calculus→Integral→int
Menu:  Calculus→Integral→int2
Menu:  Calculus→Integral→int3
Menu:  Calculus→Integral→int4
Palette:  Calculus (1 1)
Palette:  Calculus (2 1)
Palette:  Calculus (3 1)
Palette:  Calculus (4 1)
Template:  int
Template:  int2
Template:  int3
Template:  int4
Example: int.mml
See also:   <bvar><lowlimit><uplimit> <condition> <interval> <domainofapplication>

The int template, palette, and menu item each enclose the current expression with a new application of the <int> operator. The enclosed expression becomes the first element of the operator.

Additional templates, palette, and menu items are provided to create <int> elements with additional qualifiers. Indefinite integrals are created with the int2 named template. The lower limit of integration is given as the third argument, and the upper limit of integration is given with the fourth. The templates int3 and int4 act as shortcuts for creating these forms. Each of the four integration creating templates have a corresponding entry on the Calculus palette.

The <int> element accepts from one to four arguments. The usual operations on nary operators can be used to insert or remove arguments of the <int> element. The one argument version is presented using the integral sign as a prefix operator, where the argument is presented as the integrand. The two argument version presents the second argument as the integration variable, separated from the integrand by a differential "d" operator. The three and four argument versions present the third and fourth arguments as lower and upper integration limits presented above and below the integral sign, respectively.

In the content MathML generated by the <int> element, the second argument produces a <bvar> qualifier element, and the third and fourth arguments produce <lowlimit> and <uplimit> qualifier elements. These elements are generated as needed by the means used to create the <int> element.

Zed does not support editing <int> elements involving <condition> elements. Other qualifier elements are supported, see the description of these qualifiers for information on how to create integrals using these forms.


<diff/> () [C]
the elementary differentiation operator
Menu:  Calculus→Derivative→diff
Menu:  Calculus→Derivative→diff2
Menu:  Calculus→Derivative→diff3
Palette:  Calculus (1 2)
Palette:  Calculus (2 2)
Palette:  Calculus (3 2)
Template:  diff
Template:  diff2
Template:  diff3
Example: diff.mml
See also:  <bvar><degree>

The diff template, palette, and menu item each enclose the current expression with a new application of the <diff> operator. The enclosed expression becomes the first element of the operator.

Additional templates, palette, and menu items are provided to create <diff> elements with additional qualifiers. The differentiation variable can be created with the diff2 named template, and repeated derivatives can be created with the diff3 named template. Each of the three derivative creating templates have a corresponding entry on the Calculus palette.

The <diff> element accepts from one to three arguments. The usual operations on nary operators can be used to insert or remove arguments of the <diff> element. The one argument version is presented using the differential "d" as a prefix operator, where the argument is the expression being differentiated. The two argument version is presented using the fraction form of the differential operator as a prefix operator, with the second argument in the denominator as the differentiation variable. The three argument version presents the third argument as the degree of differentiation, as a superscript of the differential "d" operator in the numerator, and as a superscript of the differentiation variable in the denominator.

In the content MathML generated by the <diff> element, the second argument produces a <bvar> qualifier element, and the third argument produces a <degree> qualifier within the <bvar> element. These elements are generated as needed by the means used to create the <diff> element.


<partialdiff/> () [C]
the elementary partial differentiation operator
Menu:  Calculus→Partial Derivative→partialdiff
Menu:  Calculus→Partial Derivative→partialdiff2
Menu:  Calculus→Partial Derivative→partialdiff3
Palette:  Calculus (1 3)
Palette:  Calculus (2 3)
Palette:  Calculus (3 3)
Template:  partialdiff
Template:  partialdiff2
Template:  partialdiff3
Example: partialdiff.mml
See also:  <bvar><degree>

The partialdiff template, palette, and menu item each enclose the current expression with a new application of the <partialdiff> operator. The enclosed expression becomes the first element of the operator.

Additional templates, palette, and menu items are provided to create <partialdiff> elements with additional qualifiers. The differentiation variables can be created by starting with the partialdiff2 named template, and the total degree of differentiation can be supplied with the partialdiff3 named template. Each of the three partial derivative creating templates have a corresponding entry on the Calculus palette.

The <partialdiff> element accepts from one to three arguments. The one argument version is presented using the partial differential "d" as a prefix operator, where the argument is the expression being differentiated. The two argument version presents the derivative in the fraction form, by presenting the differentiation variables found within the second argument in the denominator of the fraction. The three argument version presents the third argument as the total degree of differentiation, as a superscript of the partial differential "d" operator in the numerator. Each of the differentiation variables in the denominator is expected to have its own degree of differentiation, displayed as a superscript of the variable.

The <partialdiff> element is the only element that accepts a list of <bvar> elements, each of which is allowed to have its own separate <degree> element. As such, special input conventions are needed to enter the differentiation variables and their degrees. These conventions are borrowed from those used to create and remove elements of other nary operators.

The usual operations on nary operators can be used to insert or remove arguments of the <partialdiff> element. Creating the first and third arguments follow the usual conventions for nary operators, but the second argument, containing the list of differentiation variables, requires special treatment.

When entering the list of differentiation variables, the denominator of the partial derivative operator can be viewed as its own element containing a list of arguments. So at this level of the expression, the usual operations on nary operators can be used to insert and remove additional differentiation variables.

Each differentiation variable may itself be viewed as its own element, similar in form to the <bvar> element it will ultimately generate. Each variable may have one or two arguments, the first argument being the differentiation variable, and the second the differentiation degree. So within this third level of the <partialdiff> expression, templates for nary operators allow for the insertion or removal of the degree of differentiation for this particular variable.

In the content MathML generated by the <partialdiff> element, the second argument produces <bvar> qualifier elements, with <degree> elements included as needed to supply the degree of differentiation for each differentiation variable. The third argument produces a total <degree> qualifier for the <partialdiff> element. These elements are generated as needed by the means used to create the <partialdiff> element.

Zed does not support editing <partialdiff> elements involving <list> elements as the indices of differentiation.


<lowlimit> (expr) [C]
the lower limit of integration qualifier element
See also:  <sum><product><limit><int>

The <lowlimit> element only appears as a child element of the other elements listed above. The facilities for inserting and deleting child elements of these other elements are used to create the <lowlimit> qualifiers as they are needed. So there are no templates, menu items, or palette entries for creating <lowlimit> elements in isolation.


<uplimit> (expr) [C]
the upper limit of integration qualifier element
See also:  <sum><product><int>

The <uplimit> element only appears as a child element of the other elements listed above. The facilities for inserting and deleting child elements of these other elements are used to create the <uplimit> qualifiers as they are needed. So there are no templates, menu items, or palette entries for creating <uplimit> elements in isolation.


<bvar> (<ci>, (<degree>)?) [C]
the bound variable qualifier element
See also:   <degree> <root> <int> <diff> <partialdiff> <sum> <product> <limit>

The <bvar> element only appears as a child element of the other elements listed above. The facilities for inserting and deleting child elements of these other elements are used to create the <bvar> qualifiers as they are needed. So there are no templates, menu items, or palette entries for creating <bvar> elements in isolation.

The <bvar> element is the only qualifier element that itself accepts another element (<degree>) as a qualifier element. When <bvar> elements are generated as a result of structure needed for other elements, <degree> elements are also generated as needed.


<degree> (expr) [C]
the degree of differentiation qualifier element
See also:  <bvar><root><moment>

The <degree> element only appears as a child element of the other elements listed above. The facilities for inserting and deleting child elements of these elements are used to create the <degree> qualifier if one is required. So there are no templates, menu items, or palette entries for creating <degree> elements in isolation.


<divergence/> () [2.0] [C]
the vector calculus divergence operator
Menu:  Calculus→div
Palette:  Calculus (5 1)
Template:  divergence
Example: divergence.mml
See also:  <grad><curl><laplacian>

The divergence template, palette, and menu item each enclose the current expression with a new application of the <divergence> operator. The enclosed expression becomes the argument of the function.

The <divergence> element is a unary operator, and is presented as a prefix application of the string "div".


<grad/> () [2.0] [C]
the vector calculus gradient operator
Menu:  Calculus→grad
Palette:  Calculus (5 2)
Template:  grad
Example: grad.mml
See also:  <divergence><curl><laplacian>

The grad template, palette, and menu item each enclose the current expression with a new application of the <grad> operator. The enclosed expression becomes the argument of the function.

The <grad> element is a unary operator, and is presented as a prefix application of the string "grad".


<curl/> () [2.0] [C]
the vector calculus curl operator
Menu:  Calculus→curl
Palette:  Calculus (5 3)
Template:  curl
Example: curl.mml
See also:  <divergence><grad><laplacian>

The curl template, palette, and menu item each enclose the current expression with a new application of the <curl> operator. The enclosed expression becomes the argument of the function.

The <curl> element is a unary operator, and is presented as a prefix application of the string "curl".


<laplacian/> () [2.0] [C]
the vector calculus laplacian operator
Menu:  Calculus→laplacian
Palette:  Calculus (4 2)
Template:  laplacian
Example: laplacian.mml
See also:  <grad><grad><curl>

The laplacian template, palette, and menu item each enclose the current expression with a new application of the <laplacian> operator. The enclosed expression becomes the argument of the function.

The <laplacian> element is a unary operator, and is presented as a prefix application of the nabla symbol with exponent "2".


Sets

<set>
<list>
<union>
<intersect>
<in>
<notin>
<subset>
<prsubset>
<notsubset>
<notprsubset>
<setdiff>
<card>
<cartesianproduct>

<set> (((<bvar>)*, <condition>, expr) | (expr)*) [C]
the set constructor element
Menu:  Sets→set
Palette:  Sets (1 1)
Template:  set
Example: set.mml
See also:  <list><condition>

The set template, palette, and menu item each enclose the current expression with a new <set> constructor element. The enclosed expression becomes the first element of the set.

The <set> element is an nary constructor, and is presented as a comma separated list of its child elements, enclosed in curly braces.

Zed does not support editing <set> elements involving <condition> elements.


<list> (((<bvar>)*, <condition>, expr) | (expr)*) [C]
the list constructor element
Menu:  Sets→list
Palette:  Sets (1 2)
Template:  list
Example: list.mml
See also:  <set><condition>

The list template, palette, and menu item each enclose the current expression with a new <list> constructor element. The enclosed expression becomes the first element of the list.

The <list> element is an nary constructor, and is presented as a comma separated list of its child elements, enclosed in square brackets.

Zed does not support editing <list> elements involving <condition> elements.


<union/> () [C]
the set union function
Menu:  Sets→union
Palette:  Sets (2 1)
Template:  union
Example: union.mml
See also:  <intersect>

The union template, palette, and menu item each enclose the current expression with a new application of the <union> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <union> element is an nary operator requiring at least two arguments, and is presented as an infix operator. The upwards "U" union symbol is used to present the operator.


<intersect/> () [C]
the set intersection function
Menu:  Sets→intersection
Palette:  Sets (2 2)
Template:  intersect
Example: intersect.mml
See also:  <union>

The intersect template, palette, and menu item each enclose the current expression with a new application of the <intersect> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <intersect> element is an nary operator requiring at least two arguments, and is presented as an infix operator. The downwards "U" intersection symbol is used to present the operator.


<in/> () [C]
the set membership relation
Menu:  Sets→in
Palette:  Sets (3 1)
Template:  in
Example: in.mml
See also:  <notin>

The in template, palette, and menu item each enclose the current expression with a new <in> element. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering the second argument.

The <in> element is presented as an infix operator. It is also a binary operator. The mathematical "element of" symbol is used to present the operator.


<notin/> () [C]
the negated set membership relation
Menu:  Sets→not in
Palette:  Sets (3 2)
Template:  notin
Example: notin.mml
See also:  <in>

The notin template, palette, and menu item each enclose the current expression with a new <notin> element. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering the second argument.

The <notin> element is presented as an infix operator. It is also a binary operator. The negated "element of" symbol is used to present the operator.


<subset/> () [C]
the is contained in or equal to relation
Menu:  Sets→subset
Palette:  Sets (4 1)
Template:  subset
Example: subset.mml
See also:  <prsubset><notsubset><notprsubset>

The subset template, palette, and menu item each enclose the current expression with a new application of the <subset> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <subset> element is an nary operator requiring at least two arguments, and is presented as an infix operator. The underlined rightwards "U" subset symbol is used to present the operator.


<prsubset/> () [C]
the is properly contained in relation
Menu:  Sets→proper subset
Palette:  Sets (4 2)
Template:  prsubset
Example: prsubset.mml
See also:  <subset><notprsubset><notsubset>

The prsubset template, palette, and menu item each enclose the current expression with a new application of the <prsubset> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering a second argument.

The <prsubset> element is an nary operator requiring at least two arguments, and is presented as an infix operator. The rightwards "U" subset symbol is used to present the operator.


<notsubset/> () [C]
the negated is contained in or equal to relation
Menu:  Sets→not subset
Palette:  Sets (5 1)
Template:  notsubset
Example: notsubset.mml
See also:  <notprsubset><subset><prsubset>

The notsubset template, palette, and menu item each enclose the current expression with a new application of the <notsubset> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering the second argument.

The <notsubset> element is a binary operator, and is presented as an infix operator. The negated underlined rightwards "U" subset symbol is used to present the operator.


<notprsubset/> () [C]
the negated is properly contained in relation
Menu:  Sets→not proper subset
Palette:  Sets (5 2)
Template:  notprsubset
Example: notprsubset.mml
See also:  <notsubset><prsubset><subset>

The notprsubset template, palette, and menu item each enclose the current expression with a new application of the <notprsubset> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering the second argument.

The <notprsubset> element is a binary operator, and is presented as an infix operator. The negated rightwards "U" subset symbol is used to present the operator.


<setdiff/> () [C]
the set difference function
Menu:  Sets→set difference
Palette:  Sets (6 1)
Example: setdiff.mml
Template:  setdiff

The setdiff template, palette, and menu item each enclose the current expression with a new application of the <setdiff> operator. The enclosed expression becomes the first argument of the operator, and a placeholder provides a place for entering the second argument.

The <setdiff> element is a binary operator, and is presented as an infix operator. The backwards slash set difference symbol is used to present the operator.


<card/> () [2.0] [C]
the set cardinality function
Menu:  Sets→cardinality
Palette:  Sets (6 2)
Example: card.mml
Template:  card

The card template, palette, and menu item each enclose the current expression with a new application of the <card> operator. The enclosed expression becomes the argument of the operator.

The <card> element is a unary operator, and is presented by enclosing its argument in vertical bars.


<cartesianproduct/> () [2.0] [C]
the set Cartesian product function
Menu:  Sets→Cartesian product
Palette:  Sets (7 1)
Example: cartesianproduct.mml
Template:  cartesianproduct

The cartesianproduct template, palette, and menu item each enclose the current expression with a new <cartesianproduct> element. The enclosed expression becomes the first argument of the product, and a placeholder provides a place for entering a second argument.

The <cartesianproduct> element is an nary operator requiring at least two arguments, and is presented as an infix operator. The times symbol is used to present the operator.


Sequences and Series

<sum>
<product>
<limit>
<tendsto>

<sum/> () [C]
the general indexed summation operator
Menu:  Sequences→sum
Menu:  Sequences→sum2
Menu:  Sequences→sum3
Menu:  Sequences→sum4
Palette:  Sequences (1 1)
Palette:  Sequences (2 1)
Palette:  Sequences (3 1)
Palette:  Sequences (4 1)
Template:  sum
Template:  sum2
Template:  sum3
Template:  sum4
Example: sum.mml
See also:  <product><bvar><lowlimit><uplimit><condition>

The sum template, palette, and menu item each enclose the current expression with a new application of the <sum> operator. The enclosed expression becomes the first element of the operator.

Additional templates, palette, and menu items are provided to create <sum> elements with additional qualifiers. Summations with an unbounded index variable are created with the sum2 named template. The lower bound of the summation is given as the third argument, and the upper bound of the summation is given with the fourth. The templates sum3 and sum4 act as shortcuts for creating these forms. Each of the four summation creating templates have a corresponding entry on the Sequences palette.

The <sum> element accepts from one to four arguments. The usual operations on nary operators can be used to insert or remove arguments of the <sum> element. The one argument version is presented using the Greek capital letter sigma as a prefix operator, where the argument is the expression being collected in the sum. The two argument version presents the second argument, the index over which the expression is being collected, as an underscript of the operator. The three and four argument versions present the third and fourth arguments as lower and upper limits of the summation index, presented above and below the operator, respectively.

In the content MathML generated by the <sum> element, the second argument produces a <bvar> qualifier element, and the third and fourth arguments produce <lowlimit> and <uplimit> qualifier elements. These elements are generated as needed by the means used to create the <sum> element.

Zed does not support editing <sum> elements involving <condition> elements.


<product/> () [C]
the general indexed product operator
Menu:  Sequences→product
Menu:  Sequences→product2
Menu:  Sequences→product3
Menu:  Sequences→product4
Palette:  Sequences (1 2)
Palette:  Sequences (2 2)
Palette:  Sequences (3 2)
Palette:  Sequences (4 2)
Template:  product
Template:  product2
Template:  product3
Template:  product4
Example: product.mml
See also:  <sum><bvar><lowlimit><uplimit><condition>

The product template, palette, and menu item each enclose the current expression with a new application of the <product> operator. The enclosed expression becomes the first element of the operator.

Additional templates, palette, and menu items are provided to create <product> elements with additional qualifiers. Products with an unbounded index variable are created with the product2 named template. The lower bound of the product is given as the third argument, and the upper bound of the product is given with the fourth. The templates product3 and product4 act as shortcuts for creating these forms. Each of the four product creating templates have a corresponding entry on the Sequences palette.

The <product> element accepts from one to four arguments. The usual operations on nary operators can be used to insert or remove arguments of the <product> element. The one argument version is presented using the Greek capital letter pi as a prefix operator, where the argument is the expression being collected in the product. The two argument version presents the second argument, the index over which the expression is being collected, as an underscript of the operator. The three and four argument versions present the third and fourth arguments as lower and upper limits of the product index, presented above and below the operator, respectively.

In the content MathML generated by the <product> element, the second argument produces a <bvar> qualifier element, and the third and fourth arguments produce <lowlimit> and <uplimit> qualifier elements. These elements are generated as needed by the means used to create the <product> element.

Zed does not support editing <product> elements involving <condition> elements.


<limit/> () [C]
the elementary functional limit operator
Menu:  Sequences→limit
Palette:  Sequences (1 3)
Template:  limit
Example: limit.mml
See also:  <bvar><lowlimit><condition><tendsto>

The limit template, palette, and menu item each enclose the current expression with a new application of the <limit> operator. The enclosed expression then becomes the limit expression, and placeholders are created for creating the bound variable and the limit point.

The <limit> element accepts three arguments: the expression being evaluated, the bound variable over which the limit is being considered, and the limit point for the bound variable. The <limit> operator is presented as a prefix application of the string "lim" in an upright font, with an underscript displaying the bound variable and the limit point with an infix right arrow operator.

In the content MathML generated by the <limit> element, the second argument produces a <bvar> qualifier element, and the third argument produces a <lowlimit> qualifier element. These elements are generated as needed by the means used to create the <limit> element.

Zed does not support editing <limit> elements involving <condition> elements.


<tendsto/> () [C]
the limit reference point qualifier element
Menu:  Sequences→tendsto
Menu:  Sequences→two-sided
Menu:  Sequences→above
Menu:  Sequences→below
Menu:  Sequences→none
Palette:  Sequences (2 3)
Template:  tendsto
Template:  two-sided
Template:  above
Template:  below
Template:  none
Example: tendsto.mml
See also:  <limit>

The tendsto template, palette, and menu item each enclose the current expression with a new application of the <tendsto> operator. The enclosed expression then becomes the first argument of the <tendsto> operator, representing the subject of the relation, and a placeholder is supplied for creating the destination of the relation.

The <tendsto> element may accept the type attribute to specify the direction from which the subject approaches its destination. Valid values for the attribute include type="two-sided", type="above", and type="below". These values may be supplied using the corresponding named templates and menu items, and they may be removed using the none template and menu item. The general attribute entry support may also be used to supply the value for the type attribute.

The <tendsto> element is presented using an infix right arrow operator separating the subject from its destination. The directionality specified by the type attribute is displayed as a superscript on the destination, either as a plus sign (above) or a minus sign (below).


Exponential Functions

<exp>
<ln>
<log>
<logbase>

<exp/> () [C]
the elementary natural exponentiation function
Menu:  Exponential→exp
Palette:  Exponential (1 1)
Template:  exp
Example: exp.mml
See also:  <ln><log>

The exp template, palette, and menu item each enclose the current expression with a new application of the <exp> operator. The enclosed expression becomes the argument of the function.

The <exp> element is a unary operator, and is presented as an italic lowercase "e" with the argument as an exponent.


<ln/> () [C]
the elementary natural logarithm function
Menu:  Exponential→ln
Palette:  Exponential (2 1)
Template:  ln
Example: ln.mml
See also:  <exp><log>

The ln template, palette, and menu item each enclose the current expression with a new application of the <ln> operator. The enclosed expression becomes the argument of the function.

The <ln> element is a unary operator, and is presented as a prefix application of the string "ln".


<log/> () [C]
the elementary general logarithm function
Menu:  Exponential→log 10
Menu:  Exponential→log n
Palette:  Exponential (1 2)
Palette:  Exponential (2 2)
Template:  log
Template:  log2
Example: log.mml
Example: log2.mml
See also:  <exp><ln><logbase>

The log template and palette item, and the log 10 menu item each enclose the current expression with a new application of the <log> operator. The enclosed expression becomes the argument of the function.

Additionally, the log2 template and palette item, and the log n menu item each enclose the current expression with a new application of the <log> operator, and provide an extra placeholder for the input of the base of the logarithm.

The <log> element accepts one or two arguments. The usual operations on nary operators can be used to insert or remove arguments of the <log> element. The one argument version is presented as a prefix application of the string "log". The two argument version is presented as the one argument version, but with the second argument presented as the base of the logarithm as a subscript of the operator.

In the content MathML generated by the <log> element, the second argument produces a <logbase> qualifier element, generated as needed by the means used to create the <log> element.


<logbase> (expr) [C]
the logarithmic base qualifier element
See also:  <log>

The <logbase> element only appears as a child element of the <log> element. The facilities for inserting and deleting child elements of the <log> element are used to create the <logbase> qualifier if one is required. So there are no templates, menu items, or palette entries for creating <logbase> elements in isolation.


Trigonometric Functions

<sin>
<cos>
<tan>
<sec>
<csc>
<cot>
<arcsin>
<arccos>
<arctan>
<arcsec>
<arccsc>
<arccot>

<sin/> () [C]
the trigonometric sine function
Menu:  Trigonometric→Function→sin
Palette:  Trigonometric (1 1)
Template:  sin
Example: sin.mml
See also:  <arcsin><sinh><arcsinh>

The sin template, palette, and menu item each enclose the current expression with a new application of the <sin> operator. The enclosed expression becomes the argument of the function.

The <sin> element is a unary operator, and is presented as a prefix application of the string "sin".


<cos/> () [C]
the trigonometric cosine function
Menu:  Trigonometric→Function→cos
Palette:  Trigonometric (2 1)
Template:  cos
Example: cos.mml
See also:  <arccos><cosh><arccosh>

The cos template, palette, and menu item each enclose the current expression with a new application of the <cos> operator. The enclosed expression becomes the argument of the function.

The <cos> element is a unary operator, and is presented as a prefix application of the string "cos".


<tan/> () [C]
the trigonometric tangent function
Menu:  Trigonometric→Function→tan
Palette:  Trigonometric (3 1)
Template:  tan
Example: tan.mml
See also:  <arctan><tanh><arctanh>

The tan template, palette, and menu item each enclose the current expression with a new application of the <tan> operator. The enclosed expression becomes the argument of the function.

The <tan> element is a unary operator, and is presented as a prefix application of the string "tan".


<sec/> () [C]
the trigonometric secant function
Menu:  Trigonometric→Function→sec
Palette:  Trigonometric (4 1)
Template:  sec
Example: sec.mml
See also:  <arcsec><sech><arcsech>

The sec template, palette, and menu item each enclose the current expression with a new application of the <sec> operator. The enclosed expression becomes the argument of the function.

The <sec> element is a unary operator, and is presented as a prefix application of the string "sec".


<csc/> () [C]
the trigonometric cosecant function
Menu:  Trigonometric→Function→csc
Palette:  Trigonometric (5 1)
Template:  csc
Example: csc.mml
See also:  <arccsc><csch><arccsch>

The csc template, palette, and menu item each enclose the current expression with a new application of the <csc> operator. The enclosed expression becomes the argument of the function.

The <csc> element is a unary operator, and is presented as a prefix application of the string "csc".


<cot/> () [C]
the trigonometric cotangent function
Menu:  Trigonometric→Function→cot
Palette:  Trigonometric (6 1)
Template:  cot
Example: cot.mml
See also:  <arccot><coth><arccoth>

The cot template, palette, and menu item each enclose the current expression with a new application of the <cot> operator. The enclosed expression becomes the argument of the function.

The <cot> element is a unary operator, and is presented as a prefix application of the string "cot".


<arcsin/> () [C]
the inverse trigonometric sine function
Menu:  Trigonometric→Inverse→sin
Palette:  Trigonometric (1 2)
Template:  arcsin
Example: arcsin.mml
See also:  <sin><arcsinh><sinh>

The arcsin template, palette, and menu item each enclose the current expression with a new application of the <arcsin> operator. The enclosed expression becomes the argument of the function.

The <arcsin> element is a unary operator, and is presented as a prefix application of the string "sin", with a superscript of -1.


<arccos/> () [C]
the inverse trigonometric cosine function
Menu:  Trigonometric→Inverse→cos
Palette:  Trigonometric (2 2)
Template:  arccos
Example: arccos.mml
See also:  <cos><arccosh><cosh>

The arccos template, palette, and menu item each enclose the current expression with a new application of the <arccos> operator. The enclosed expression becomes the argument of the function.

The <arccos> element is a unary operator, and is presented as a prefix application of the string "cos", with a superscript of -1.


<arctan/> () [C]
the inverse trigonometric tangent function
Menu:  Trigonometric→Inverse→tan
Palette:  Trigonometric (3 2)
Template:  arctan
Example: arctan.mml
See also:  <tan><arctanh><tanh>

The arctan template, palette, and menu item each enclose the current expression with a new application of the <arctan> operator. The enclosed expression becomes the argument of the function.

The <arctan> element is a unary operator, and is presented as a prefix application of the string "tan", with a superscript of -1.


<arcsec/> () [2.0] [C]
the inverse trigonometric secant function
Menu:  Trigonometric→Inverse→sec
Palette:  Trigonometric (4 2)
Template:  arcsec
Example: arcsec.mml
See also:  <sec><arcsech><sech>

The arcsec template, palette, and menu item each enclose the current expression with a new application of the <arcsec> operator. The enclosed expression becomes the argument of the function.

The <arcsec> element is a unary operator, and is presented as a prefix application of the string "sec", with a superscript of -1.


<arccsc/> () [2.0] [C]
the inverse trigonometric cosecant function
Menu:  Trigonometric→Inverse→csc
Palette:  Trigonometric (5 2)
Template:  arccsc
Example: arccsc.mml
See also:  <csc><arccsch><csch>

The arccsc template, palette, and menu item each enclose the current expression with a new application of the <arccsc> operator. The enclosed expression becomes the argument of the function.

The <arccsc> element is a unary operator, and is presented as a prefix application of the string "csc", with a superscript of -1.


<arccot/> () [2.0] [C]
the inverse trigonometric cotangent function
Menu:  Trigonometric→Inverse→cot
Palette:  Trigonometric (6 2)
Template:  arccot
Example: arccot.mml
See also:  <cot><arccoth><coth>

The arccot template, palette, and menu item each enclose the current expression with a new application of the <arccot> operator. The enclosed expression becomes the argument of the function.

The <arccot> element is a unary operator, and is presented as a prefix application of the string "cot", with a superscript of -1.


Hyperbolic Functions

<sinh>
<cosh>
<tanh>
<sech>
<csch>
<coth>
<arcsinh>
<arccosh>
<arctanh>
<arcsech>
<arccsch>
<arccoth>

<sinh/> () [C]
the hyperbolic sine function
Menu:  Hyperbolic→Function→sin
Palette:  Hyperbolic (1 1)
Template:  sinh
Example: sinh.mml
See also:  <arcsinh><sin><arcsin>

The sinh template, palette, and menu item each enclose the current expression with a new application of the <sinh> operator. The enclosed expression becomes the argument of the function.

The <sinh> element is a unary operator, and is presented as a prefix application of the string "sinh".


<cosh/> () [C]
the hyperbolic cosine function
Menu:  Hyperbolic→Function→cos
Palette:  Hyperbolic (2 1)
Template:  cosh
Example: cosh.mml
See also:  <arccosh><cos><arccos>

The cosh template, palette, and menu item each enclose the current expression with a new application of the <cosh> operator. The enclosed expression becomes the argument of the function.

The <cosh> element is a unary operator, and is presented as a prefix application of the string "cosh".


<tanh/> () [C]
the hyperbolic tangent function
Menu:  Hyperbolic→Function→tan
Palette:  Hyperbolic (3 1)
Template:  tanh
Example: tanh.mml
See also:  <arctanh><tan><arctan>

The tanh template, palette, and menu item each enclose the current expression with a new application of the <tanh> operator. The enclosed expression becomes the argument of the function.

The <tanh> element is a unary operator, and is presented as a prefix application of the string "tanh".


<sech/> () [C]
the hyperbolic secant function
Menu:  Hyperbolic→Function→sec
Palette:  Hyperbolic (4 1)
Template:  sech
Example: sech.mml
See also:  <arcsech><sec><arcsec>

The sech template, palette, and menu item each enclose the current expression with a new application of the <sech> operator. The enclosed expression becomes the argument of the function.

The <sech> element is a unary operator, and is presented as a prefix application of the string "sech".


<csch/> () [C]
the hyperbolic cosecant function
Menu:  Hyperbolic→Function→csc
Palette:  Hyperbolic (5 1)
Template:  csch
Example: csch.mml
See also:  <arccsch><csc><arccsc>

The csch template, palette, and menu item each enclose the current expression with a new application of the <csch> operator. The enclosed expression becomes the argument of the function.

The <csch> element is a unary operator, and is presented as a prefix application of the string "csch".


<coth/> () [C]
the hyperbolic cotangent function
Menu:  Hyperbolic→Function→cot
Palette:  Hyperbolic (6 1)
Template:  coth
Example: coth.mml
See also:  <arccoth><cot><arccot>

The coth template, palette, and menu item each enclose the current expression with a new application of the <coth> operator. The enclosed expression becomes the argument of the function.

The <coth> element is a unary operator, and is presented as a prefix application of the string "coth".


<arcsinh/> () [2.0] [C]
the inverse hyperbolic sine function
Menu:  Hyperbolic→Inverse→sin
Palette:  Hyperbolic (1 2)
Template:  arcsinh
Example: arcsinh.mml
See also:  <sinh><arcsin><sin>

The arcsinh template, palette, and menu item each enclose the current expression with a new application of the <arcsinh> operator. The enclosed expression becomes the argument of the function.

The <arcsinh> element is a unary operator, and is presented as a prefix application of the string "sinh", with a superscript of -1.


<arccosh/> () [2.0] [C]
the inverse hyperbolic cosine function
Menu:  Hyperbolic→Inverse→cos
Palette:  Hyperbolic (2 2)
Template:  arccosh
Example: arccosh.mml
See also:  <cosh><arccos><cos>

The arccosh template, palette, and menu item each enclose the current expression with a new application of the <arccosh> operator. The enclosed expression becomes the argument of the function.

The <arccosh> element is a unary operator, and is presented as a prefix application of the string "cosh", with a superscript of -1.


<arctanh/> () [2.0] [C]
the inverse hyperbolic tangent function
Menu:  Hyperbolic→Inverse→tan
Palette:  Hyperbolic (3 2)
Template:  arctanh
Example: arctanh.mml
See also:  <tanh><arctan><tan>

The arctanh template, palette, and menu item each enclose the current expression with a new application of the <arctanh> operator. The enclosed expression becomes the argument of the function.

The <arctanh> element is a unary operator, and is presented as a prefix application of the string "tanh", with a superscript of -1.


<arcsech/> () [2.0] [C]
the inverse hyperbolic secant function
Menu:  Hyperbolic→Inverse→sec
Palette:  Hyperbolic (4 2)
Template:  arcsech
Example: arcsech.mml
See also:  <sech><arcsec><sec>

The arcsech template, palette, and menu item each enclose the current expression with a new application of the <arcsech> operator. The enclosed expression becomes the argument of the function.

The <arcsech> element is a unary operator, and is presented as a prefix application of the string "sech", with a superscript of -1.


<arccsch/> () [2.0] [C]
the inverse hyperbolic cosecant function
Menu:  Hyperbolic→Inverse→csc
Palette:  Hyperbolic (5 2)
Template:  arccsch
Example: arccsch.mml
See also:  <csch><arccsc><csc>

The arccsch template, palette, and menu item each enclose the current expression with a new application of the <arccsch> operator. The enclosed expression becomes the argument of the function.

The <arccsch> element is a unary operator, and is presented as a prefix application of the string "csch", with a superscript of -1.


<arccoth/> () [2.0] [C]
the inverse hyperbolic cotangent function
Menu:  Hyperbolic→Inverse→cot
Palette:  Hyperbolic (6 2)
Template:  arccoth
Example: arccoth.mml
See also:  <coth><arccot><cot>

The arccoth template, palette, and menu item each enclose the current expression with a new application of the <arccoth> operator. The enclosed expression becomes the argument of the function.

The <arccoth> element is a unary operator, and is presented as a prefix application of the string "coth", with a superscript of -1.


Statistics

<mean>
<sdev>
<var>
<variance>
<median>
<mode>
<moment>
<momentabout>

<mean/> () [C]
the arithmetic mean (average) operator
Menu:  Statistics→mean
Palette:  Statistics (1 1)
Template:  mean
Example: mean.mml
See also:   <sdev> <variance> <median> <mode>

The mean template, palette, and menu item each enclose the current expression with a new application of the <mean> operator. The enclosed expression becomes the first element of the operator.

The <mean> element is an nary operator, and is presented as a comma-separated list of its arguments, enclosed in angle brackets.


<sdev/> () [C]
the statistical standard deviation operator
Menu:  Statistics→sdev
Palette:  Statistics (2 1)
Template:  sdev
Example: sdev.mml
See also:   <mean> <variance>

The sdev template, palette, and menu item each enclose the current expression with a new application of the <sdev> operator. The enclosed expression becomes the first element of the operator.

The <sdev> element is an nary operator, and is presented as a comma-separated list of its arguments, enclosed in a prefix application of the Greek lowercase letter sigma.


<var/> () [1.0] [C]
the statistical variance operator
See also:  <variance>

The <var> element is an nary operator, and is presented as a comma-separated list of its arguments, enclosed in a prefix application of the Greek lowercase letter sigma, with a postfix exponent of 2.

The <var> element has been superceded by the <variance> element.


<variance/> () [1.01] [C]
the statistical variance operator
Menu:  Statistics→variance
Palette:  Statistics (3 1)
Template:  variance
Example: variance.mml
See also:   <mean> <sdev>

The variance template, palette, and menu item each enclose the current expression with a new application of the <variance> operator. The enclosed expression becomes the first element of the operator.

The <variance> element is an nary operator, and is presented as a comma-separated list of its arguments, enclosed in a prefix application of the Greek lowercase letter sigma, with a postfix exponent of 2.


<median/> () [C]
the statistical median operator
Menu:  Statistics→median
Palette:  Statistics (1 2)
Template:  median
Example: median.mml
See also:   <mean> <mode>

The median template, palette, and menu item each enclose the current expression with a new application of the <median> operator. The enclosed expression becomes the first element of the operator.

The <median> element is an nary operator, and is presented as a comma-separated list of its arguments, enclosed in a prefix application of the word "median" in an upright font.


<mode/> () [C]
the statistical mode operator
Menu:  Statistics→mode
Palette:  Statistics (2 2)
Template:  mode
Example: mode.mml
See also:   <mean> <median>

The mode template, palette, and menu item each enclose the current expression with a new application of the <mode> operator. The enclosed expression becomes the first element of the operator.

The <mode> element is an nary operator, and is presented as a comma-separated list of its arguments, enclosed in a prefix application of the word "mode" in an upright font.


<moment/> () [C]
the statistical moment operator
Menu:  Statistics→moment
Menu:  Statistics→nth moment
Menu:  Statistics→moment about
Palette:  Statistics (4 1)
Palette:  Statistics (3 2)
Palette:  Statistics (4 2)
Template:  moment
Template:  moment2
Template:  moment3
Example: moment.mml
Example: moment2.mml
Example: moment3.mml
See also:  <degree><momentabout>

The moment template, palette, and menu item each enclose the current expression with a new application of the <moment> operator. The enclosed expression becomes the first element of the operator.

Additional templates, palette, and menu items are provided to create <moment> elements with additional qualifiers. Nth moments are created with the nth moment menu item and the moment2 named template. Nth moments around a particular point are created with the moment about menu item and the moment3 named template. Each of the three moment creating templates have a corresponding entry on the Statistics palette.

The <moment> element accepts one, two, or three arguments. The usual operations on nary operators can be used to insert or remove arguments of the <moment> element. The one argument version is presented with its argument in angle brackets, and the first argument is assumed to be a set. The two argument version is presented much as the one argument version, but with the second argument presented as an exponent of the first argument to denote the nth moment. The three argument version is presented much as the two argument version, but with the third argument presented as the point around which the moment is being computed.

In the content MathML generated by the <moment> element, the second argument produces a <degree> qualifier element, and the third argument produces a <momentabout> qualifier element. These elements are generated as needed by the means used to create the <moment> element.


<momentabout> (expr) [2.0] [C]
the statistical moment reference point qualifier element
See also:  <moment>

The <momentabout> element only appears as a child element of the <moment> element. The facilities for inserting and deleting child elements of the <moment> element are used to create the <momentabout> qualifier if one is required. So there are no templates, menu items, or palette entries for creating <momentabout> elements in isolation.


Linear Algebra

<vector>
<matrix>
<matrixrow>
<determinant>
<transpose>
<select>
<selector>
<vectorproduct>
<scalarproduct>
<outerproduct>

<vector> (expr)* [C]
the linear algebra vector constructor element
Menu:  Linear Algebra→vector
Palette:  Linear Algebra (1 1)
Template:  vector
Example: vector.mml
See also:  <matrix>

The vector template, palette, and menu item each enclose the current expression with a new <vector> constructor element. The enclosed expression becomes the first element of the vector.

The <vector> element is an nary operator, and is presented as a column vector of its child elements, enclosed in square brackets.


<matrix> (<matrixrow>)* [C]
the linear algebra matrix constructor element
Menu:  Linear Algebra→matrix
Palette:  Linear Algebra (1 2)
Template:  matrix
Example: matrix.mml
See also:  <vector><matrixrow>

The matrix template, palette, and menu item each enclose the current expression with a new <matrix> constructor element. The enclosed expression becomes the first element of the first row of the new matrix.

The <matrix> element is an array operator that is presented as a two-dimensional table of its child elements, enclosed in parentheses.


<matrixrow> (expr)* [C]
the linear algebra matrix row constructor element
See also:  <matrix>

The <matrixrow> constructor element only appears as a child element of the <matrix> element. The facilities for inserting and deleting child elements of a matrix are used to create the matrix rows and elements, without manipulating the <matrixrow> elements directly. So there are no templates, menu items, or palette entries for creating <matrixrow> elements in isolation.

The <matrixrow> element is an nary operator, and is presented as a row vector of its child elements, without any enclosing fences.


<determinant/> () [C]
the matrix determinant function
Menu:  Linear Algebra→determinant
Palette:  Linear Algebra (2 1)
Template:  determinant
Example: determinant.mml
See also:  <transpose>

The determinant template, palette, and menu item each enclose the current expression with a new application of the <determinant> operator. The enclosed expression becomes the argument of the determinant.

The <determinant> element is a unary operator, and is presented as a prefix application of the string "det".


<transpose/> () [C]
the matrix transpose function
Menu:  Linear Algebra→transpose
Palette:  Linear Algebra (3 1)
Template:  transpose
Example: transpose.mml
See also:  <determinant>

The transpose template, palette, and menu item each enclose the current expression with a new application of the <transpose> operator. The enclosed expression becomes the argument of the transpose operator.

The <transpose> element is a unary operator, and is presented as a postfix application of a superscript "T".


<select/> () [1.0] [C]
the matrix row/element indexing operator
See also:  <selector>

The <select> element is an nary operator that takes two or more arguments. It is presented by placing a comma separated list of the indices as a subscript of the first argument.

The <select> element has been superceded by the <selector> element.


<selector/> () [1.01] [C]
the matrix row/element indexing operator
Menu:  Linear Algebra→selector
Palette:  Linear Algebra (4 1)
Template:  selector
Example: selector.mml
See also:  <vector><matrix>

The selector template, palette, and menu item each enclose the current expression with a new application of the <selector> operator. The enclosed expression becomes the first argument of the selector operator, and a new placeholder is created that allows for the creation of the indices of the selection.

The <selector> element is an nary operator that takes two or more arguments. It is presented by placing a comma separated list of the indices as a subscript of the first argument.


<vectorproduct/> () [2.0] [C]
the vector product function
Menu:  Linear Algebra→vectorproduct
Palette:  Linear Algebra (2 2)
Template:  vectorproduct
Example: vectorproduct.mml
See also:   <scalarproduct> <outerproduct>

The vectorproduct template, palette, and menu item each enclose the current expression with a new <vectorproduct> element. The enclosed expression becomes the first argument of the product, and a placeholder provides a place for entering the second argument.

The <vectorproduct> element is presented as an infix operator. It is also a binary operator. The times symbol is used to present the operator.


<scalarproduct/> () [2.0] [C]
the vector scalar product function
Menu:  Linear Algebra→scalarproduct
Palette:  Linear Algebra (3 2)
Template:  scalarproduct
Example: scalarproduct.mml
See also:   <vectorproduct> <outerproduct>

The scalarproduct template, palette, and menu item each enclose the current expression with a new <scalarproduct> element. The enclosed expression becomes the first argument of the product, and a placeholder provides a place for entering the second argument.

The <scalarproduct> element is presented as an infix operator. It is also a binary operator. A centered dot is used to present the operator.


<outerproduct/> () [2.0] [C]
the vector outer product function
Menu:  Linear Algebra→outerproduct
Palette:  Linear Algebra (4 2)
Template:  outerproduct
Example: outerproduct.mml
See also:   <vectorproduct> <scalarproduct>

The outerproduct template, palette, and menu item each enclose the current expression with a new <outerproduct> element. The enclosed expression becomes the first argument of the product, and a placeholder provides a place for entering the second argument.

The <outerproduct> element is presented as an infix operator. It is also a binary operator. A circled times symbol is used to present the operator.


Semantic Elements

<semantics>
<annotation>
<annotation-xml>

<semantics> (expr, (<annotation> | <annotation-xml>)+) [C]
the external annotation interface element
Menu:  Semantics→semantics
Menu:  Semantics→edit
Menu:  Semantics→show
Palette:  Semantics (1 1)
Template:  semantics
Template:  edit
Template:  show
Example: semantics.mml
See also:   <annotation> <annotation-xml>

The semantics template, palette, and menu item each enclose the current expression with a new <semantics> element. The enclosed expression becomes the first argument of the new element that will be annotated by <annotation> and/or <annotation-xml> elements. The comma key creates additional child expressions where the annotations can be created.

The <semantics> element in Zed uses the other attribute to provide two ways of presenting the element. If the attribute other="edit" is specified, each child element of the <semantics> element is presented, separated by commas, and enclosed in parentheses. This mode allows you to view and edit the content and each of the annotations of the element. If the other attribute is absent and one of the annotations is an <annotation-xml> element with encoding="MathML-Presentation", then the MathML presentation annotation is used to present the element, hiding the other annotations.

The edit template and menu item add the attribute other="edit" to a <semantics> element, while the show template and menu item remove it. These two templates allow you to toggle between the two presentation modes for a <semantics> element. The general attribute entry support may also be used to supply the value for the other attribute.

The <semantics> element is an nary operator.


<annotation> (#PCDATA | any)* [C]
the general annotation interface element
Menu:  Semantics→annotation
Palette:  Semantics (1 2)
Template:  annotation
Example: annotation.mml
See also:   <semantics> <annotation-xml>

The annotation template, palette, and menu item each enclose the current expression with a new <annotation> element. The enclosed expression becomes the content of the annotation.

In principle, this element may be used to hold annotations in any general input format. In practice, Zed allows any MathML expression to be entered as the annotation, which will appear in its usual XML encoding.

The <annotation> element may accept the encoding attribute to specify the encoding for the element. The general attribute entry support may also be used to supply the value for the encoding attribute.

The <annotation> element is presented by enclosing its annotation in curly braces. If an encoding attribute is present, it is displayed as a subscript of the annotation.


<annotation-xml> (#PCDATA | any)* [C]
the XML annotation interface element
Menu:  Semantics→annotation-xml
Menu:  Semantics→content
Menu:  Semantics→present
Menu:  Semantics→other
Palette:  Semantics (1 3)
Template:  annotation-xml
Template:  content
Template:  present
Template:  remove
Example: annotation-xml.mml
See also:   <semantics> <annotation>

The annotation-xml template, palette, and menu item each enclose the current expression with a new <annotation-xml> element. The enclosed expression becomes the content of the annotation.

In principle, this element may be used to hold annotations containing any XML elements from any vocabulary. In practice, Zed allows any MathML expression to be entered as the annotation.

The <annotation-xml> element may accept the encoding attribute to specify the encoding for the element. Conventional values for the attribute include encoding="MathML-Presentation" and encoding="MathML-Content". The value of the encoding attribute can be set by the content and present templates and menu items, and can be removed by the other menu item and the remove template. The general attribute entry support may also be used to supply the value for the encoding attribute.

The <annotation-xml> element is presented by enclosing its annotation in square brackets. If an encoding attribute is present, it is displayed as a subscript of the annotation.


Constant Elements

<integers>
<reals>
<rationals>
<naturalnumbers>
<complexes>
<primes>
<exponentiale>
<imaginaryi>
<notanumber>
<true>
<false>
<emptyset>
<pi>
<eulergamma>
<infinity>

<integers/> () [2.0] [C]
the set of all integer numbers
Menu:  Constants→integers
Palette:  Constants (1 1)
Template:  integers
Example: integers.mml
See also:   <reals> <rationals> <naturalnumbers> <complexes> <primes>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as a double-struck capital "Z".


<reals/> () [2.0] [C]
the set of all real numbers
Menu:  Constants→reals
Palette:  Constants (1 2)
Template:  reals
Example: reals.mml
See also:   <integers> <rationals> <naturalnumbers> <complexes> <primes>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as a double-struck capital "R".


<rationals/> () [2.0] [C]
the set of all rational numbers
Menu:  Constants→rationals
Palette:  Constants (1 3)
Template:  rationals
Example: rationals.mml
See also:   <integers> <reals> <naturalnumbers> <complexes> <primes>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as a double-struck capital "Q".


<naturalnumbers/> () [2.0] [C]
the set of all non-negative integer numbers
Menu:  Constants→naturalnumbers
Palette:  Constants (2 1)
Template:  naturalnumbers
Example: naturalnumbers.mml
See also:   <integers> <reals> <rationals> <complexes> <primes>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as a double-struck capital "N".


<complexes/> () [2.0] [C]
the set of all complex numbers
Menu:  Constants→complexes
Palette:  Constants (2 2)
Template:  complexes
Example: complexes.mml
See also:   <integers> <reals> <rationals> <naturalnumbers> <primes>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as a double-struck capital "C".


<primes/> () [2.0] [C]
the set of all prime numbers
Menu:  Constants→primes
Palette:  Constants (2 3)
Template:  primes
Example: primes.mml
See also:   <integers> <reals> <rationals> <naturalnumbers> <complexes>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as a double-struck capital "P".


<exponentiale/> () [2.0] [C]
the real constant denoting the base of the natural logarithm
Menu:  Constants→exponentiale
Palette:  Constants (3 1)
Template:  exponentiale
Example: exponentiale.mml
See also:  <imaginaryi>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as an italic lowercase "e".


<imaginaryi/> () [2.0] [C]
the complex constant denoting the square root of -1
Menu:  Constants→imaginaryi
Palette:  Constants (3 2)
Template:  imaginaryi
Example: imaginaryi.mml
See also:  <exponentiale>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented as an italic lowercase "i".


<notanumber/> () [2.0] [C]
the constant symbol denoting an undefined floating-point value
Menu:  Constants→notanumber
Palette:  Constants (3 3)
Template:  notanumber
Example: notanumber.mml
See also:  <infinity>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented with the string "NaN" in upright font.


<true/> () [2.0] [C]
the positive logical constant
Menu:  Constants→true
Palette:  Constants (4 1)
Template:  true
Example: true.mml
See also:  <false>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented with the string "true" in upright font.


<false/> () [2.0] [C]
the negative logical constant
Menu:  Constants→false
Palette:  Constants (4 2)
Template:  false
Example: false.mml
See also:  <true>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented with the string "false" in upright font.


<emptyset/> () [2.0] [C]
the distinguished set with no members
Menu:  Constants→emptyset
Palette:  Constants (4 3)
Template:  emptyset
Example: emptyset.mml

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented by the special symbol that appears as a zero with a forward slash through it.


<pi/> () [2.0] [C]
the real constant denoting the ratio between the circumference and diameter of a circle
Menu:  Constants→pi
Palette:  Constants (5 1)
Template:  pi
Example: pi.mml

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented by the lowercase Greek letter pi.


<eulergamma/> () [2.0] [C]
the real constant denoting Euler's constant
Menu:  Constants→eulergamma
Palette:  Constants (5 2)
Template:  eulergamma
Example: eulergamma.mml

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented by the lowercase Greek letter gamma.


<infinity/> () [2.0] [C]
the constant symbol denoting an unbounded or innumerable quantity
Menu:  Constants→infinity
Palette:  Constants (5 3)
Template:  infinity
Example: infinity.mml
See also:  <notanumber>

The template, palette, and menu item each insert the empty constant element at the current cursor position.

The element is presented by the standard "lazy eight" infinity symbol.