File: chapter4-d.html

package info (click to toggle)
w3-recs 20110107-1
links: PTS, VCS
area: non-free
in suites: bullseye, buster, jessie, jessie-kfreebsd, stretch, wheezy
size: 195,972 kB
ctags: 48,964
sloc: xml: 67,284; makefile: 115; perl: 31
file content (10276 lines) | stat: -rw-r--r-- 627,311 bytes
<!DOCTYPE html
  PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
   <head>
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      <title>Content Markup</title><style type="text/css">

.egmeta {
color:#5555AA;font-style:italic;font-family:serif;font-weight:bold;
}

table.syntax {
font-size: 75%;
background-color: #DDDDDD;
border: thin  solid;
}
table.syntax td {
border: solid thin;
}
table.syntax th {
text-align: left;
}

table.attributes td { padding-left:0.5em; padding-right:0.5em; }
table.attributes td.attname { white-space:nowrap; vertical-align:top;}
table.attributes td.attdesc { background-color:#F0F0FF; padding-left:2em; padding-right:2em}

th.uname {font-size: 50%; text-align:left;}
code           { font-family: monospace; }

div.constraint,
div.issue,
div.note,
div.notice     { margin-left: 2em; }

li p           { margin-top: 0.3em;
                 margin-bottom: 0.3em; }

div.exampleInner pre { margin-left: 1em;
                       margin-top: 0em; margin-bottom: 0em}
div.exampleOuter {border: 4px double gray;
                  margin: 0em; padding: 0em}
div.exampleInner { background-color: #d5dee3;
                   border-top-width: 4px;
                   border-top-style: double;
                   border-top-color: #d3d3d3;
                   border-bottom-width: 4px;
                   border-bottom-style: double;
                   border-bottom-color: #d3d3d3;
                   padding: 4px; margin: 0em }
div.exampleWrapper { margin: 4px }
div.exampleHeader { font-weight: bold;
                    margin: 4px}
a.mainindex {font-weight: bold;}
li.sitem {list-style-type: none;}

  .error { color: red }

  div.mathml-example {border:solid thin black;
              padding: 0.5em;
              margin: 0.5em 0 0.5em 0;
             }
  div.strict-mathml-example {border:solid thin black;
              padding: 0.5em;
              margin: 0.5em 0 0.5em 0;
             }
  div.strict-mathml-example h5 {
  margin-top: -0.3em;
  margin-bottom: -0.5em;}
  var.meta {background-color:green}
  var.transmeta {background-color:red}
  pre.mathml {padding: 0.5em;
              background-color: #FFFFDD;}
  pre.mathml-fragment {padding: 0.5em;
              background-color: #FFFFDD;}
  pre.strict-mathml {padding: 0.5em;
              background-color: #FFFFDD;}
  .minitoc { border-style: solid;
             border-color: #0050B2; 
             border-width: 1px ;
             padding: 0.3em;}
  .attention { border-style: solid; 
               border-width: 1px ; 
               color: #5D0091;
               background: #F9F5DE; 
               border-color: red;
               margin-left: 1em;
               margin-right: 1em;
               margin-top: 0.25em;
               margin-bottom: 0.25em; }

  .attribute-Name { background: #F9F5C0; }
  .method-Name { background: #C0C0F9; }
  .IDL-definition { border-style: solid; 
               border-width: 1px ; 
               color: #001000;
               background: #E0FFE0; 
               border-color: #206020;
               margin-left: 1em;
               margin-right: 1em;
               margin-top: 0.25em;
               margin-bottom: 0.25em; }
  .baseline {vertical-align: baseline}

  #eqnoc1 {width: 10%}
  #eqnoc2 {width: 80%; text-align: center; }
  #eqnoc3 {width: 10%; text-align: right; }

div.div1 {margin-bottom: 1em;}
          
.h3style {
  text-align: left;
  font-family: sans-serif;
  font-weight: normal;
  color: #0050B2; 
  font-size: 125%;
}

  h4 { text-align: left;
       font-family: sans-serif;
       font-weight: normal;
       color: #0050B2; }
  h5 { text-align: left;
       font-family: sans-serif;
       font-weight: bold;
       color: #0050B2; } 

  th {background:  #E0FFE0;}

  p, blockquote, h4 { font-family: sans-serif; }
  dt, dd, dl, ul, li { font-family: sans-serif; }
  pre, code { font-family: monospace }

  a.termref {
  text-decoration: none;
  color: black;
  }

sub.diff-link {background-color: black; color: white; font-family:
sans-serif; font-weight: bold;}

.diff-add  { background-color: #FFFF99}
.diff-del  { background-color: #FF9999; text-decoration: line-through }
.diff-chg  { background-color: #99FF99 }
.diff-off  {  }


.mathml-render {
font-family: serif;
font-size: 130%;
border: solid 4px green;
padding-left: 1em;
padding-right: 1em;
}
</style><link rel="stylesheet" type="text/css" href="../../../StyleSheets/TR/W3C-REC.css">
   </head>
   <body>
      
      <h1><a name="contm" id="contm"></a>4 Content Markup
      </h1>
      <!-- TOP NAVIGATION BAR -->
      <div class="minitoc">
         
         Overview: <a href="Overview-d.html">Mathematical Markup Language (MathML) Version 3.0</a><br>
         Previous: 3 <a href="chapter3-d.html">Presentation Markup</a><br>
         Next: 5 <a href="chapter5-d.html">Mixing Markup Languages for Mathematical Expressions</a><br><br>4 <a href="chapter4-d.html">Content Markup</a><br>&nbsp;&nbsp;&nbsp;&nbsp;4.1 <a href="chapter4-d.html#contm.intro">Introduction</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.1.1 <a href="chapter4-d.html#id.4.1.1">The Intent of Content Markup</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.1.2 <a href="chapter4-d.html#contm.rendering">The Structure and Scope of Content MathML Expressions</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.1.3 <a href="chapter4-d.html#contm.strict">Strict Content MathML</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.1.4 <a href="chapter4-d.html#contm.cds">Content Dictionaries</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.1.5 <a href="chapter4-d.html#id.4.1.5">Content MathML Concepts</a><br>&nbsp;&nbsp;&nbsp;&nbsp;4.2 <a href="chapter4-d.html#contm.core">Content MathML Elements Encoding Expression Structure</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.1 <a href="chapter4-d.html#contm.cn">Numbers <code>&lt;cn&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.1.1 <a href="chapter4-d.html#contm.rendering.numbers">Rendering <code>&lt;cn&gt;</code>-Represented Numbers </a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.1.2 <a href="chapter4-d.html#contm.cn.strict">Strict uses of <code>&lt;cn&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.1.3 <a href="chapter4-d.html#contm.cn.extended">Non-Strict uses of <code>&lt;cn&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.2 <a href="chapter4-d.html#contm.ci">Content Identifiers <code>&lt;ci&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.2.1 <a href="chapter4-d.html#contm.ci.strict">Strict uses of <code>&lt;ci&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.2.2 <a href="chapter4-d.html#contm.ci.extended">Non-Strict uses of <code>&lt;ci&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.2.3 <a href="chapter4-d.html#contm.rendering.ci">Rendering Content Identifiers</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.3 <a href="chapter4-d.html#contm.csymbol">Content Symbols <code>&lt;csymbol&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.3.1 <a href="chapter4-d.html#contm.csymbol.strict">Strict uses of  <code>&lt;csymbol&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.3.2 <a href="chapter4-d.html#contm.csymbol.extended">Non-Strict uses of <code>&lt;csymbol&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.3.3 <a href="chapter4-d.html#contm.rendering.csymbol">Rendering Symbols</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.4 <a href="chapter4-d.html#contm.cs">String Literals <code>&lt;cs&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.5 <a href="chapter4-d.html#contm.apply">Function Application <code>&lt;apply&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.5.1 <a href="chapter4-d.html#contm.applications.strict">Strict Content MathML</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.5.2 <a href="chapter4-d.html#contm.rendering.applications">Rendering Applications</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.6 <a href="chapter4-d.html#contm.binding">Bindings and Bound Variables <code>&lt;bind&gt;</code>
            and <code>&lt;bvar&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.6.1 <a href="chapter4-d.html#contm.bind">Bindings</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.6.2 <a href="chapter4-d.html#contm.bvar">Bound Variables</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.6.3 <a href="chapter4-d.html#contm.alpharenmaing">Renaming Bound Variables</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.6.4 <a href="chapter4-d.html#contm.rendering.binders">Rendering Binding Constructions</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.7 <a href="chapter4-d.html#contm.sharing">Structure Sharing <code>&lt;share&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.7.1 <a href="chapter4-d.html#contm.share">The <code>share</code> element</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.7.2 <a href="chapter4-d.html#contm.acyclicity">An Acyclicity Constraint</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.7.3 <a href="chapter4-d.html#contm.share.binding">Structure Sharing and Binding</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.7.4 <a href="chapter4-d.html#contm.rendering.share">Rendering Expressions with Structure Sharing</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.8 <a href="chapter4-d.html#contm.semantics">Attribution via <code>semantics</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.9 <a href="chapter4-d.html#contm.cerror">Error Markup <code>&lt;cerror&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.2.10 <a href="chapter4-d.html#contm.cbytes">Encoded Bytes <code>&lt;cbytes&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;4.3 <a href="chapter4-d.html#contm.structure.extended">Content MathML for Specific Structures</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.1 <a href="chapter4-d.html#contm.container">Container Markup</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.1.1 <a href="chapter4-d.html#contm.container.constructor">Container Markup for Constructor Symbols</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.1.2 <a href="chapter4-d.html#contm.lambda.container">Container Markup for Binding Constructors</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.2 <a href="chapter4-d.html#contm.bind.apply">Bindings with <code>&lt;apply&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.3 <a href="chapter4-d.html#contm.qualifiers">Qualifiers</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.3.1 <a href="chapter4-d.html#contm.domainofapplication.qualifier">Uses of 
            <code>&lt;domainofapplication&gt;</code>,
            <code>&lt;interval&gt;</code>,
            <code>&lt;condition&gt;</code>,
            <code>&lt;lowlimit&gt;</code> and
            <code>&lt;uplimit&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.3.2 <a href="chapter4-d.html#contm.degree">Uses of <code>&lt;degree&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.3.3 <a href="chapter4-d.html#contm.otherqualifiers">Uses of <code>&lt;momentabout&gt;</code> and <code>&lt;logbase&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4 <a href="chapter4-d.html#contm.opclasses">Operator Classes</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.1 <a href="chapter4-d.html#contm.nary">N-ary Operators (classes nary-arith, nary-functional, nary-logical,
            nary-linalg, nary-set, nary-constructor)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.2 <a href="chapter4-d.html#contm.nary.setlist">N-ary Constructors for set and list (class nary-setlist-constructor)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.3 <a href="chapter4-d.html#contm.nary.reln">N-ary Relations (classes nary-reln, nary-set-reln)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.4 <a href="chapter4-d.html#contm.nary.unary">N-ary/Unary Operators (classes nary-minmax, nary-stats)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.5 <a href="chapter4-d.html#contm.binary">Binary Operators (classes binary-arith, binary-logical, binary-reln, binary-linalg, binary-set)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.6 <a href="chapter4-d.html#contm.unary">Unary Operators (classes unary-arith, unary-linalg, unary-functional, unary-set, unary-elementary, unary-veccalc)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.7 <a href="chapter4-d.html#contm.constant">Constants (classes constant-arith, constant-set)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.8 <a href="chapter4-d.html#contm.quantifier">Quantifiers (class quantifier)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.4.9 <a href="chapter4-d.html#contm.otherclass">Other Operators (classes lambda, interval, int, diff partialdiff, sum, product, limit)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.3.5 <a href="chapter4-d.html#id.4.3.5">Non-strict Attributes</a><br>&nbsp;&nbsp;&nbsp;&nbsp;4.4 <a href="chapter4-d.html#contm.opel">Content MathML for Specific Operators and Constants</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1 <a href="chapter4-d.html#contm.basicfun">Functions and Inverses</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.1 <a href="chapter4-d.html#contm.interval">Interval <code>&lt;interval&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.2 <a href="chapter4-d.html#contm.inverse">Inverse <code>&lt;inverse&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.3 <a href="chapter4-d.html#contm.lambda">Lambda <code>&lt;lambda&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.4 <a href="chapter4-d.html#contm.compose">Function composition <code>&lt;compose/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.5 <a href="chapter4-d.html#contm.ident">Identity function <code>&lt;ident/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.6 <a href="chapter4-d.html#contm.domain">Domain <code>&lt;domain/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.7 <a href="chapter4-d.html#contm.codomain">codomain <code>&lt;codomain/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.8 <a href="chapter4-d.html#contm.image">Image <code>&lt;image/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.1.9 <a href="chapter4-d.html#contm.piecewise">Piecewise declaration (<code>&lt;piecewise&gt;</code>, <code>&lt;piece&gt;</code>, <code>&lt;otherwise&gt;</code>)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2 <a href="chapter4-d.html#id.4.4.2">Arithmetic, Algebra and Logic</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.1 <a href="chapter4-d.html#contm.quotient">Quotient <code>&lt;quotient/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.2 <a href="chapter4-d.html#contm.factorial">Factorial <code>&lt;factorial/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.3 <a href="chapter4-d.html#contm.divide">Division <code>&lt;divide/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.4 <a href="chapter4-d.html#contm.max">Maximum <code>&lt;max/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.5 <a href="chapter4-d.html#contm.min">Minimum <code>&lt;min/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.6 <a href="chapter4-d.html#contm.minus">Subtraction <code>&lt;minus/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.7 <a href="chapter4-d.html#contm.plus">Addition <code>&lt;plus/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.8 <a href="chapter4-d.html#contm.power">Exponentiation <code>&lt;power/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.9 <a href="chapter4-d.html#contm.rem">Remainder <code>&lt;rem/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.10 <a href="chapter4-d.html#contm.times">Multiplication <code>&lt;times/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.11 <a href="chapter4-d.html#contm.root">Root <code>&lt;root/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.12 <a href="chapter4-d.html#contm.gcd">Greatest common divisor <code>&lt;gcd/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.13 <a href="chapter4-d.html#contm.and">And <code>&lt;and/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.14 <a href="chapter4-d.html#contm.or">Or <code>&lt;or/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.15 <a href="chapter4-d.html#contm.xor">Exclusive Or <code>&lt;xor/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.16 <a href="chapter4-d.html#contm.not">Not <code>&lt;not/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.17 <a href="chapter4-d.html#contm.implies">Implies <code>&lt;implies/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.18 <a href="chapter4-d.html#contm.forall">Universal quantifier <code>&lt;forall/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.19 <a href="chapter4-d.html#contm.exists">Existential quantifier <code>&lt;exists/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.20 <a href="chapter4-d.html#contm.abs">Absolute Value <code>&lt;abs/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.21 <a href="chapter4-d.html#contm.conjugate">Complex conjugate <code>&lt;conjugate/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.22 <a href="chapter4-d.html#contm.arg">Argument <code>&lt;arg/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.23 <a href="chapter4-d.html#contm.real">Real part <code>&lt;real/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.24 <a href="chapter4-d.html#contm.imaginary">Imaginary part <code>&lt;imaginary/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.25 <a href="chapter4-d.html#contm.lcm">Lowest common multiple <code>&lt;lcm/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.26 <a href="chapter4-d.html#contm.floor">Floor <code>&lt;floor/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.2.27 <a href="chapter4-d.html#contm.ceiling">Ceiling <code>&lt;ceiling/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3 <a href="chapter4-d.html#id.4.4.3">Relations</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.1 <a href="chapter4-d.html#contm.eq">Equals <code>&lt;eq/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.2 <a href="chapter4-d.html#contm.neq">Not Equals <code>&lt;neq/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.3 <a href="chapter4-d.html#contm.gt">Greater than <code>&lt;gt/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.4 <a href="chapter4-d.html#contm.lt">Less Than <code>&lt;lt/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.5 <a href="chapter4-d.html#contm.geq">Greater Than or Equal <code>&lt;geq/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.6 <a href="chapter4-d.html#contm.leq">Less Than or Equal <code>&lt;leq/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.7 <a href="chapter4-d.html#contm.equivalent">Equivalent <code>&lt;equivalent/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.8 <a href="chapter4-d.html#contm.approx">Approximately <code>&lt;approx/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.3.9 <a href="chapter4-d.html#contm.factorof">Factor Of <code>&lt;factorof/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4 <a href="chapter4-d.html#id.4.4.4">Calculus and Vector Calculus</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.1 <a href="chapter4-d.html#contm.int">Integral <code>&lt;int/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.2 <a href="chapter4-d.html#contm.diff">Differentiation <code>&lt;diff/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.3 <a href="chapter4-d.html#contm.partialdiff">Partial Differentiation <code>&lt;partialdiff/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.4 <a href="chapter4-d.html#contm.divergence">Divergence <code>&lt;divergence/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.5 <a href="chapter4-d.html#contm.grad">Gradient <code>&lt;grad/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.6 <a href="chapter4-d.html#contm.curl">Curl <code>&lt;curl/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.4.7 <a href="chapter4-d.html#contm.laplacian">Laplacian <code>&lt;laplacian/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5 <a href="chapter4-d.html#contm.sets">Theory of Sets</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.1 <a href="chapter4-d.html#contm.set">Set <code>&lt;set&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.2 <a href="chapter4-d.html#contm.list">List <code>&lt;list&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.3 <a href="chapter4-d.html#contm.union">Union <code>&lt;union/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.4 <a href="chapter4-d.html#contm.intersect">Intersect <code>&lt;intersect/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.5 <a href="chapter4-d.html#contm.in">Set inclusion <code>&lt;in/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.6 <a href="chapter4-d.html#contm.notin">Set exclusion <code>&lt;notin/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.7 <a href="chapter4-d.html#contm.subset">Subset <code>&lt;subset/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.8 <a href="chapter4-d.html#contm.prsubset">Proper Subset <code>&lt;prsubset/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.9 <a href="chapter4-d.html#contm.notsubset">Not Subset <code>&lt;notsubset/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.10 <a href="chapter4-d.html#contm.notprsubset">Not Proper Subset <code>&lt;notprsubset/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.11 <a href="chapter4-d.html#contm.setdiff">Set Difference <code>&lt;setdiff/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.12 <a href="chapter4-d.html#contm.card">Cardinality <code>&lt;card/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.5.13 <a href="chapter4-d.html#contm.cartesianproduct">Cartesian product <code>&lt;cartesianproduct/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.6 <a href="chapter4-d.html#id.4.4.6">Sequences and Series</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.6.1 <a href="chapter4-d.html#contm.sum">Sum <code>&lt;sum/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.6.2 <a href="chapter4-d.html#contm.product">Product <code>&lt;product/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.6.3 <a href="chapter4-d.html#contm.limit">Limits <code>&lt;limit/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.6.4 <a href="chapter4-d.html#contm.tendsto">Tends To <code>&lt;tendsto/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.7 <a href="chapter4-d.html#contm.elemclass">Elementary classical functions</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.7.1 <a href="chapter4-d.html#contm.trig">Common trigonometric functions </a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.7.2 <a href="chapter4-d.html#contm.exp">Exponential <code>&lt;exp/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.7.3 <a href="chapter4-d.html#contm.ln">Natural Logarithm <code>&lt;ln/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.7.4 <a href="chapter4-d.html#contm.log">Logarithm <code>&lt;log/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8 <a href="chapter4-d.html#id.4.4.8">Statistics</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8.1 <a href="chapter4-d.html#contm.mean">Mean <code>&lt;mean/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8.2 <a href="chapter4-d.html#contm.sdev">Standard Deviation <code>&lt;sdev/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8.3 <a href="chapter4-d.html#contm.variance">Variance <code>&lt;variance/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8.4 <a href="chapter4-d.html#contm.median">Median <code>&lt;median/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8.5 <a href="chapter4-d.html#contm.mode">Mode <code>&lt;mode/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.8.6 <a href="chapter4-d.html#contm.moment">Moment (<code>&lt;moment/&gt;</code>, <code>&lt;momentabout&gt;</code>)</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9 <a href="chapter4-d.html#id.4.4.9">Linear Algebra</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.1 <a href="chapter4-d.html#contm.vector">Vector <code>&lt;vector&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.2 <a href="chapter4-d.html#contm.matrix">Matrix <code>&lt;matrix&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.3 <a href="chapter4-d.html#contm.matrixrow">Matrix row <code>&lt;matrixrow&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.4 <a href="chapter4-d.html#contm.determinant">Determinant <code>&lt;determinant/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.5 <a href="chapter4-d.html#contm.transpose">Transpose <code>&lt;transpose/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.6 <a href="chapter4-d.html#contm.selector">Selector <code>&lt;selector/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.7 <a href="chapter4-d.html#contm.vectorproduct">Vector product <code>&lt;vectorproduct/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.8 <a href="chapter4-d.html#contm.scalarproduct">Scalar product <code>&lt;scalarproduct/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.9.9 <a href="chapter4-d.html#contm.outerproduct">Outer product <code>&lt;outerproduct/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10 <a href="chapter4-d.html#contm.constantsandsymbols">Constant and Symbol Elements</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.1 <a href="chapter4-d.html#contm.integers">integers <code>&lt;integers/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.2 <a href="chapter4-d.html#contm.reals">reals <code>&lt;reals/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.3 <a href="chapter4-d.html#contm.rationals">Rational Numbers <code>&lt;rationals/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.4 <a href="chapter4-d.html#contm.naturalnumbers">Natural Numbers <code>&lt;naturalnumbers/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.5 <a href="chapter4-d.html#contm.complexes">complexes <code>&lt;complexes/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.6 <a href="chapter4-d.html#contm.primes">primes <code>&lt;primes/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.7 <a href="chapter4-d.html#contm.exponentiale">Exponential e <code>&lt;exponentiale/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.8 <a href="chapter4-d.html#contm.imaginaryi">Imaginary i <code>&lt;imaginaryi/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.9 <a href="chapter4-d.html#contm.notanumber">Not A Number <code>&lt;notanumber/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.10 <a href="chapter4-d.html#contm.true">True <code>&lt;true/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.11 <a href="chapter4-d.html#contm.false">False <code>&lt;false/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.12 <a href="chapter4-d.html#contm.emptyset">Empty Set <code>&lt;emptyset/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.13 <a href="chapter4-d.html#contm.pi">pi <code>&lt;pi/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.14 <a href="chapter4-d.html#contm.eulergamma">Euler gamma <code>&lt;eulergamma/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.4.10.15 <a href="chapter4-d.html#contm.infinity">infinity <code>&lt;infinity/&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;4.5 <a href="chapter4-d.html#contm.deprecated">Deprecated Content Elements</a><br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;4.5.1 <a href="chapter4-d.html#contm.declare">Declare <code>&lt;declare&gt;</code></a><br>&nbsp;&nbsp;&nbsp;&nbsp;4.6 <a href="chapter4-d.html#contm.p2s">The Strict Content MathML Transformation</a><br></div>
      <div class="div1">
         <div class="div2">
            
            <h2><a name="contm.intro" id="contm.intro"></a>4.1 Introduction
            </h2>
            <div class="div3">
               
               <h3><a name="id.4.1.1" id="id.4.1.1"></a>4.1.1 The Intent of Content Markup
               </h3>
               <p>The intent of Content Markup is to provide an explicit encoding of
                  the <em>underlying mathematical meaning</em> of an expression,
                  rather than any particular rendering for the expression.  Mathematics
                  is distinguished both by its use of rigorous formal logic to define
                  and analyze mathematical concepts, and by the use of a (relatively)
                  formal notational system to represent and communicate those concepts.
                  However, mathematics and its presentation should not be viewed as one
                  and the same thing. Mathematical notation, though more rigorous than
                  natural language, is nonetheless at times ambiguous,
                  context-dependent, and varies from community to community.  In some
                  cases, heuristics may adequately infer mathematical semantics from
                  mathematical notation. But in many others cases, it is preferable to
                  work directly with the underlying, formal, mathematical objects.
                  Content Markup provides a rigorous, extensible semantic framework and
                  a markup language for this purpose.
                  
               </p>
               <p>The difficulties in inferring semantics from a presentation stem
                  from the fact that there are many to one mappings from presentation to
                  semantics and vice versa. For example the mathematical construct
                  "<var>H</var> multiplied by <var>e</var>" is often
                  encoded using an explicit operator as in
                  <var>H</var>&nbsp;×&nbsp;<var>e</var>. In different
                  presentational contexts, the multiplication operator might be
                  invisible "<var>H</var>&nbsp;<var>e</var>", or rendered
                  as the spoken word "times". Generally, many different
                  presentations are possible depending on the context and style
                  preferences of the author or reader. Thus, given
                  "<var>H</var>&nbsp;<var>e</var>" out of context it may be
                  impossible to decide if this is the name of a chemical or a
                  mathematical product of two variables <var>H</var> and
                  <var>e</var>. Mathematical presentation also varies across cultures
                  and geographical regions. For example, many notations for long
                  division are in use in different parts of the world today. Notations
                  may lose currency, for example the use of musical sharp and flat
                  symbols to denote maxima and minima <a href="appendixh-d.html#Chaundy1954">[Chaundy1954]</a>. A
                  notation in use in 1644 for the multiplication mentioned above was
                  <img src="image/f4001.gif" alt="\blacksquare" align="middle"><var>H</var><var>e</var> <a href="appendixh-d.html#Cajori1928">[Cajori1928]</a>.
               </p>
               <p>By encoding the underlying mathematical structure explicitly,
                  without regard to how it is presented aurally or visually, it is
                  possible to interchange information more precisely between systems
                  that semantically process mathematical objects. In the trivial example
                  above, such a system could substitute values for the variables
                  <var>H</var> and <var>e</var> and evaluate the result. Important
                  application areas include computer algebra systems, automatic
                  reasoning system, industrial and scientific applications,
                  multi-lingual translation systems, mathematical search, and
                  interactive textbooks.
               </p>
               <p>The organization of this chapter is as follows.  In <a href="chapter4-d.html#contm.core">Section&nbsp;4.2 Content MathML Elements Encoding Expression Structure</a>, a core collection of elements comprising Strict
                  Content Markup are described.  Strict Content Markup is sufficient to
                  encode general expression trees in a semantically rigorous way.  It is
                  in one-to-one correspondence with OpenMath element set. OpenMath is a
                  standard for representing formal mathematical objects and semantics
                  through the use of extensible Content Dictionaries.  Strict Content
                  Markup defines a mechanism for associating precise mathematical
                  semantics with expression trees by referencing OpenMath Content
                  Dictionaries. The next two sections introduce markup that is more
                  convenient than Strict markup for some purposes, somewhat less formal
                  and verbose.  In <a href="chapter4-d.html#contm.structure.extended">Section&nbsp;4.3 Content MathML for Specific Structures</a>, markup is
                  introduced for representing a small number of mathematical idioms,
                  such as limits on integrals, sums and product.  These constructs may
                  all be rewritten as Strict Content Markup expressions, and rules for
                  doing so are given.  In <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>, elements are
                  introduced for many common function, operators and constants. This
                  section contains many examples, including equivalent Strict Content
                  expressions.  In <a href="chapter4-d.html#contm.deprecated">Section&nbsp;4.5 Deprecated Content Elements</a>, elements from
                  MathML 1 and 2 whose use is now discouraged are listed.
                  Finally, <a href="chapter4-d.html#contm.p2s">Section&nbsp;4.6 The Strict Content MathML Transformation</a> summarizes the algorithm for
                  translating arbitrary Content Markup into Strict Content Markup.  It
                  collects together in sequence all the rewrite rules introduced
                  throughout the rest of the chapter.
               </p>
            </div>
            <div class="div3">
               
               <h3><a name="contm.rendering" id="contm.rendering"></a>4.1.2 The Structure and Scope of Content MathML Expressions
               </h3>
               <p>Content MathML represents mathematical objects as <em>expression trees</em>.  The
                  notion of constructing a general expression tree is e.g. that of applying an operator to
                  sub-objects. For example, the sum "<var>x</var>+<var>y</var>" can be
                  thought of as an application of the addition operator to two arguments <var>x</var> and
                  <var>y</var>. And the expression "cos(π)" as the application of the
                  cosine function to the number π.
               </p>
               <p>As a general rule, the terminal nodes in the tree represent basic mathematical
                  objects such as numbers, variables, arithmetic operations and so on. The internal nodes
                  in the tree represent function application or other mathematical constructions that
                  build up a compound objects. Function application provides the most important example;
                  an internal node might represent the application of a function to several arguments,
                  which are themselves represented by the nodes underneath the internal node.
               </p>
               <p>The semantics of general mathematical expressions is not a matter of consensus. It
                  would be an enormous job to systematically codify most of mathematics – a task
                  that can never be complete. Instead, MathML makes explicit a relatively small number of
                  commonplace mathematical constructs, chosen carefully to be sufficient in a large number
                  of applications. In addition, it provides a mechanism for referring
                  to mathematical concepts outside of the base collection, allowing
                  them to be represented, as well.
               </p>
               <p>The base set of content elements is chosen to be adequate for simple coding of most
                  of the formulas used from kindergarten to the end of high school in the United States,
                  and probably beyond through the first two years of college, that is up to A-Level or
                  Baccalaureate level in Europe.
               </p>
               <p>While the primary role of the MathML content element set is to directly encode the
                  mathematical structure of expressions independent of the notation used to present the
                  objects, rendering issues cannot be ignored. There are different approaches for
                  rendering Content MathML formulae, ranging from native implementations of the
                  MathML elements to declarative notation definitions, to XSLT style
                  sheets. Because rendering requirements for Content MathML vary
                  widely, MathML 3 does not provide a normative specification for
                  rendering.  Instead, typical renderings are suggested by way of examples.
               </p>
            </div>
            <div class="div3">
               
               <h3><a name="contm.strict" id="contm.strict"></a>4.1.3 Strict Content MathML
               </h3>
               <p>In MathML 3, a subset, or profile, of Content MathML is defined: <em>Strict Content
                     MathML</em>.  This uses a minimal, but sufficient, set of elements to represent the meaning of a
                  mathematical expression in a uniform structure, while the full Content MathML grammar is
                  backward compatible with MathML 2.0, and generally tries to strike a more pragmatic
                  balance between verbosity and formality.
               </p>
               <p>Content MathML provides a large number of predefined functions
                  encoded as empty elements (e.g. <code>sin</code>, <code>log</code>, etc.)
                  and a variety of constructs for forming compound objects
                  (e.g. <code>set</code>, <code>interval</code>, etc.).  By contrast, Strict
                  Content MathML uses a single element (<code>csymbol</code>) with an
                  attribute pointing to an external definition in extensible content
                  dictionaries to represent all functions, and uses only
                  <code>apply</code> and <code>bind</code> for building up compound
                  objects. The token elements such as <code>ci</code> and <code>cn</code> are
                  also considered part of Strict Content MathML, but with a more
                  restricted set of attributes and with content restricted to
                  text.
               </p>
               <p>Strict Content MathML is designed to be compatible with OpenMath (in
                  fact it is an XML encoding of OpenMath Objects in the sense of <a href="appendixg-d.html#OpenMath2004">[OpenMath2004]</a>).  
                  OpenMath is a standard for representing formal mathematical
                  objects and semantics through the use of extensible Content Dictionaries.  The table below
                  gives an element-by-element correspondence between the OpenMath XML encoding of OpenMath
                  objects and Strict Content MathML.
                  
               </p>
               <table border="1" id="contm.om.correspondence">
                  <thead>
                     <tr>
                        <th>Strict Content MathML</th>
                        <th>OpenMath</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <td><a href="chapter4-d.html#contm.cn"><code>cn</code></a></td>
                        <td><code>OMI</code>, <code>OMF</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.csymbol"><code>csymbol</code></a></td>
                        <td><code>OMS</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.ci"><code>ci</code></a></td>
                        <td><code>OMV</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.cs"><code>cs</code></a></td>
                        <td><code>OMSTR</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.apply"><code>apply</code></a></td>
                        <td><code>OMA</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.binding"><code>bind</code></a></td>
                        <td><code>OMBIND</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.binding"><code>bvar</code></a></td>
                        <td><code>OMBVAR</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.sharing"><code>share</code></a></td>
                        <td><code>OMR</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.semantics"><code>semantics</code></a></td>
                        <td><code>OMATTR</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.semantics"><code>annotation</code></a>,
                           <a href="chapter4-d.html#contm.semantics"><code>annotation-xml</code></a></td>
                        <td><code>OMATP</code>, <code>OMFOREIGN</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.cerror"><code>cerror</code></a></td>
                        <td><code>OME</code></td>
                     </tr>
                     <tr>
                        <td><a href="chapter4-d.html#contm.cbytes"><code>cbytes</code></a></td>
                        <td><code>OMB</code></td>
                     </tr>
                  </tbody>
               </table>
               <p>In MathML 3, formal semantics Content MathML expressions are
                  given by specifying equivalent Strict Content MathML expressions.
                  Since Strict Content MathML expressions all have carefully-defined
                  semantics given in terms of OpenMath Content Dictionaries, all
                  Content MathML expressions inherit well-defined semantics in this
                  way. To make the correspondence exact, an algorithm is
                  given in terms of transformation rules that are applied to
                  rewrite non-Strict MathML constructs into a strict equivalents. The
                  individual rules are introduced in context throughout the chapter.
                  In <a href="chapter4-d.html#contm.p2s">Section&nbsp;4.6 The Strict Content MathML Transformation</a>, the algorithm as a whole is
                  described.
               </p>
               <p>As most transformation rules relate to
                  classes of MathML elements that have similar argument structure,
                  they are introduced in <a href="chapter4-d.html#contm.opclasses">Section&nbsp;4.3.4 Operator Classes</a> where these
                  classes are defined. Some special case rules for specific elements
                  are given in Section <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. Transformations in
                  <a href="chapter4-d.html#contm.core">Section&nbsp;4.2 Content MathML Elements Encoding Expression Structure</a> concern non-Strict usages of the core
                  Content MathML elements, those in <a href="chapter4-d.html#contm.structure.extended">Section&nbsp;4.3 Content MathML for Specific Structures</a> concern the rewriting of some
                  additional structures not directly supported in Strict Content MathML.
               </p>
               <p>The full algorithm described in<a href="chapter4-d.html#contm.p2s">Section&nbsp;4.6 The Strict Content MathML Transformation</a> is
                  complete in the sense that it gives every Content MathML expression a specific
                  meaning in terms of a Strict Content MathML expression.  This means
                  it has to give specific strict interpretations to some expressions
                  whose meaning was insufficiently specified in MathML2. The intention
                  of this algorithm is to be faithful to mathematical intuitions.
                  However edge cases may remain where the normative interpretation of
                  the algorithm may break earlier intuitions.
               </p>
               <p>A conformant MathML processor need
                  not implement this transformation. The existence of these
                  transformation rules does not imply that a system must treat
                  equivalent expressions identically. In particular systems may give
                  different presentation renderings for expressions that the
                  transformation rules imply are mathematically equivalent.
               </p>
            </div>
            <div class="div3">
               
               <h3><a name="contm.cds" id="contm.cds"></a>4.1.4 Content Dictionaries
               </h3>
               <p>Due to the nature of mathematics, any method for formalizing
                  the meaning of the mathematical expressions must be
                  extensible. The key to extensibility is the ability to define
                  new functions and other symbols to expand the terrain of
                  mathematical discourse. To do this, two things are required: a
                  mechanism for representing symbols not already defined by
                  Content MathML, and a means of associating a specific
                  mathematical meaning with them in an unambiguous way.  In MathML
                  3, the <code>csymbol</code> element provides the means to represent
                  new symbols, while <em>Content Dictionaries</em> are the way
                  in which mathematical semantics are described.  The association
                  is accomplished via attributes of the <code>csymbol</code> element
                  that point at a definition in a CD. The syntax and usage of
                  these attributes are described in detail in <a href="chapter4-d.html#contm.csymbol">Section&nbsp;4.2.3 Content Symbols <code>&lt;csymbol&gt;</code></a>.
               </p>
               <p>Content Dictionaries are structured documents for the
                  definition of mathematical concepts; see the OpenMath standard,
                  <a href="appendixg-d.html#OpenMath2004">[OpenMath2004]</a>.
                  To maximize modularity and reuse, a
                  Content Dictionary typically contains a relatively small
                  collection of definitions for closely related concepts.  The
                  OpenMath Society maintains a large set of public Content Dictionaries
                  including the MathML CD group that including contains definitions 
                  for all pre-defined symbols in MathML.
                  There is a process for contributing privately
                  developed CDs to the OpenMath Society repository to facilitate
                  discovery and reuse.  MathML 3 does not require CDs be publicly
                  available, though in most situations the goals of semantic
                  markup will be best served by referencing public CDs available
                  to all user agents.
               </p>
               <p>In the text below, descriptions of semantics for predefined
                  MathML symbols refer to the Content Dictionaries developed by
                  the OpenMath Society in conjunction with the W3C Math Working
                  Group.  It is important to note, however, that this information
                  is informative, and not normative. In general, the precise
                  mathematical semantics of predefined symbols are not not fully
                  specified by the MathML 3 Recommendation, and the only normative
                  statements about symbol semantics are those present in the text
                  of this chapter.  The semantic definitions provided by the
                  OpenMath Content CDs are intended to be sufficient for
                  most applications, and are generally compatible with the
                  semantics specified for analogous constructs in the MathML 2.0
                  Recommendation.  However, in contexts where highly precise
                  semantics are required (e.g. communication between computer
                  algebra systems, within formal systems such as theorem provers,
                  etc.) it is the responsibility of the relevant community of
                  practice to verify, extend or replace definitions provided by
                  OpenMath CDs as appropriate.
               </p>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.1.5" id="id.4.1.5"></a>4.1.5 Content MathML Concepts
               </h3>
               <p>The basic building blocks of Content MathML expressions are
                  numbers, identifiers and symbols.  These building blocks are combined
                  using function applications and binding operators.  It is important to
                  have a basic understanding of these key mathematical concepts, and how
                  they are reflected in the design of Content MathML.  For the
                  convenience of the reader, these concepts are reviewed here.
               </p>
               <p>In the expression "<var>x</var>+<var>y</var>",
                  <var>x</var> is a mathematical variable, meaning an identifier that
                  represents a quantity with no fixed value.  It may have other
                  properties, such as being an integer, but its value is not a fixed
                  property.  By contrast, the plus sign is an identifier that represents a
                  fixed and externally defined object, namely the addition function.
                  Such an identifier is termed a <em>symbol</em>, to distinguish it
                  from a variable.  Common elementary functions and operators all have
                  fixed, external definitions, and are hence symbols.  Content MathML
                  uses the <code>ci</code> element to represent variables, and the
                  <code>csymbol</code> to represent symbols.
               </p>
               <p>The most fundamental way in which symbols and variables are
                  combined is function application.  Content MathML makes a crucial
                  semantic distinction between a function itself (a symbol such as the
                  sine function, or a variable such as <var>f</var>) and the result of
                  applying the function to arguments.  The <a href="chapter4-d.html#contm.apply"><code>apply</code></a> element groups the function
                  with its arguments syntactically, and represents the expression
                  resulting from applying that function to its arguments.
               </p>
               <p>Mathematically, variables are divided into <em>bound</em> and
                  <em>free</em> variables.  Bound variables are variables that are
                  assigned a special role by a binding operator within a certain scope.
                  For example, the index variable within a summation is a bound
                  variable. They can be characterized as variables with the property
                  that they can be renamed consistently throughout the binding scope
                  without changing the underlying meaning of the expression.  Variables
                  that are not bound are termed free variables.
                  Because the logical distinction between bound and free variables is
                  important for well-defined semantics, Content MathML differentiates
                  between the application of a function to a free variable,
                  e.g. <var>f</var>(<var>x</var>) and the operation of binding a
                  variable within a scope.  The <a href="chapter4-d.html#contm.bind"><code>bind</code></a> element is used the delineate
                  the binding scope, and group the binding operator with its bound
                  variables, which are indicated by the <code>bvar</code> element.
               </p>
               <p>In Strict Content markup, the <code>bind</code> element is the only way
                  of performing variable binding.  In non-Strict usage, however, markup
                  is provided that more closely resembles well-known idiomatic
                  notations, such as the "limit" notations for sums and
                  integrals.  These constructs often implicitly bind variables, such as
                  the variable of integration, or the index variable in a sum.  MathML
                  terms the elements used to represent the auxiliary data such as limits
                  required by these constructions <em>qualifier</em> elements.
               </p>
               <p>Expressions involving qualifiers follow one of a small number of
                  idiomatic patterns, each of which applies to class of similar binding
                  operators.  For example, sums and products are in the same class
                  because they use index variables following the same pattern.  The
                  Content MathML operator classes are described in detail in <a href="chapter4-d.html#contm.opclasses">Section&nbsp;4.3.4 Operator Classes</a>.
                  
               </p>
               <p>Each Content MathML element is described in a section below that
                  begins with a table summarizing the key information about the element.
                  For elements that have different Strict and non-Strict
                  usage, these syntax tables are divided to clearly separate the two cases. The element's content
                  model is given in the <b>Content</b> row, linked to the MathML
                  Schema in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>.  The <b>Attributes</b>, and
                  <b>Attribute Values</b> rows similarly link to the schema. Where
                  applicable, the <b>Class</b> row specifies the operator class, which
                  indicate how many arguments the operator represented by this element
                  takes, and also in many cases determines the mapping to Strict Content
                  MathML, as described in <a href="chapter4-d.html#contm.opclasses">Section&nbsp;4.3.4 Operator Classes</a>.  Finally,
                  the <b>Qualifiers</b> row clarifies whether the operator takes
                  qualifiers and if so, which. Both specify how many siblings may follow
                  the operator element in an <code>apply</code>; see <a href="chapter4-d.html#contm.apply">Section&nbsp;4.2.5 Function Application <code>&lt;apply&gt;</code></a> and <a href="chapter4-d.html#contm.qualifiers">Section&nbsp;4.3.3 Qualifiers</a> for
                  details).
               </p>
            </div>
         </div>
         <div class="div2">
            
            <h2><a name="contm.core" id="contm.core"></a>4.2 Content MathML Elements Encoding Expression Structure
            </h2>
            <p>In this section we will present the elements for encoding the structure of content
               MathML expressions. These elements are the only ones used for the Strict Content MathML
               encoding. Concretely, we have 
               
            </p>
            <ul>
               <li>
                  <p>basic expressions, i.e.  <a href="chapter4-d.html#contm.cn">Numbers</a>, <a href="chapter4-d.html#contm.cs">string literals</a>, <a href="chapter4-d.html#contm.cbytes">encoded
                        bytes</a>, <a href="chapter4-d.html#contm.csymbol">Symbols</a>, and <a href="chapter4-d.html#contm.ci">Identifiers</a>.
                  </p>
               </li>
               <li>
                  <p>derived expressions, i.e.
                     <a href="chapter4-d.html#contm.apply">function applications</a> and
                     <a href="chapter4-d.html#contm.binding">binding expressions</a>, and 
                  </p>
               </li>
               <li>
                  <p><a href="chapter4-d.html#contm.semantics">semantic annotations</a></p>
               </li>
               <li>
                  <p><a href="chapter4-d.html#contm.cerror">error markup</a></p>
               </li>
            </ul>
            <p>
               Full Content MathML allows further elements presented in
               <a href="chapter4-d.html#contm.structure.extended">Section&nbsp;4.3 Content MathML for Specific Structures</a> and <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>, and allows a richer
               content model presented in this section. Differences in Strict and non-Strict
               usage of are highlighted in the sections discussing each of the Strict element below.
            </p>
            <div class="div3">
               
               <h3><a name="contm.cn" id="contm.cn"></a>4.2.1 Numbers <code>&lt;cn&gt;</code></h3>
               <table id="contm.cn.syntax" class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th colspan="2">Schema Fragment (Strict)</th>
                        <th colspan="2">Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td colspan="2"><a href="chapter4-d.html#contm.cn">Cn</a></td>
                        <td colspan="2"><a href="chapter4-d.html#contm.cn">Cn</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td colspan="2"><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_type">type</a></td>
                        <td colspan="2"><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>, <a href="appendixa-d.html#parsing_type">type</a>?, <a href="appendixa-d.html#parsing_base">base</a>?
                        </td>
                     </tr>
                     <tr>
                        <th><code>type</code> Attribute Values
                        </th>
                        <td>
                           "integer" |
                           "real" |
                           "double" |
                           "hexdouble"
                           
                        </td>
                        <td>&nbsp;&nbsp;&nbsp;</td>
                        <td>
                           "integer" |
                           "real" |
                           "double" |
                           "hexdouble" |
                           "e-notation" |
                           "rational" |
                           "complex-cartesian" |
                           "complex-polar" |
                           "constant" | text
                           
                        </td>
                        <td>default is real</td>
                     </tr>
                     <tr>
                        <th><code>base</code> Attribute Values
                        </th>
                        <td colspan="2"></td>
                        <td>
                           <a href="appendixa-d.html#parsing_integer">integer</a>
                           
                        </td>
                        <td>default is 10</td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td colspan="2">text</td>
                        <td colspan="2">(text | <a href="appendixa-d.html#parsing_mglyph">mglyph</a> | <a href="appendixa-d.html#parsing_sep">sep</a> | <a href="appendixa-d.html#parsing_PresentationExpression">PresentationExpression</a>)*
                        </td>
                     </tr>
                  </tbody>
               </table>
               <p>The <code>cn</code> element is the Content MathML element used to
                  represent numbers.  Strict Content MathML supports integers, real numbers,
                  and double precision floating point numbers.  In these types of numbers,
                  the content of <code>cn</code> is text. Additionally, <code>cn</code>
                  supports rational numbers and complex numbers in which the different
                  parts are separated by use of the <code>sep</code> element.  Constructs
                  using <code>sep</code> may be rewritten in Strict Content MathML as
                  constructs using <code>apply</code> as described below. 
               </p>
               <p> The <code>type</code> attribute specifies which kind of number is
                  represented in the <code>cn</code> element.  The default value is
                  "real".  Each type implies that the content be of
                  a certain form, as detailed below.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.rendering.numbers" id="contm.rendering.numbers"></a>4.2.1.1 Rendering <code>&lt;cn&gt;</code>-Represented Numbers 
                  </h4>
                  <p>The default rendering of the text content of  <code>cn</code> is the same as that of the Presentation element <code>mn</code>, with suggested variants in the
                     case of attributes or <code>sep</code> being used, as listed below.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.cn.strict" id="contm.cn.strict"></a>4.2.1.2 Strict uses of <code>&lt;cn&gt;</code></h4>
                  <p>In Strict Content MathML, the <code>type</code> attribute is mandatory, and may only take the values
                     "integer", "real", "hexdouble" or
                     "double":
                  </p>
                  <dl>
                     <dt class="label">integer</dt>
                     <dd>An integer is represented by an optional sign followed by a string of
                        one or more decimal "digits".
                     </dd>
                     <dt class="label">real</dt>
                     <dd>A real number is presented in radix notation. Radix notation consists of an
                        optional sign ("+" or "-") followed by a string of
                        digits possibly separated into an integer and a fractional part by a
                        decimal point. Some examples are 0.3, 1, and -31.56.
                     </dd>
                     <dt class="label">double</dt>
                     <dd>This type is used to mark up those double-precision
                        floating point numbers that can be represented in the IEEE 754
                        standard format <a href="appendixh-d.html#IEEE754">[IEEE754]</a>.  This includes a subset of the (mathematical) real
                        numbers, negative zero, positive and negative real infinity
                        and a set of "not a number" values.  The lexical rules for
                        interpreting the text content of a <code>cn</code> as an IEEE
                        double are specified by <a href="http://www.w3.org/TR/xmlschema-2/#double">Section
                           3.1.2.5</a> of XML Schema Part 2: Datatypes Second Edition
                        <a href="appendixh-d.html#XMLSchemaDatatypes">[XMLSchemaDatatypes]</a>.  For example, -1E4, 1267.43233E12, 12.78e-2,
                        12 , -0, 0 and INF are all valid doubles in this format.
                     </dd>
                     <dt class="label">hexdouble</dt>
                     <dd>
                        <p>This type is used to directly represent the 64 bits of an
                           IEEE 754 double-precision floating point number as a 16 digit
                           hexadecimal number.  Thus the number represents mantissa, exponent, and sign
                           from lowest to highest bits using a least significant byte ordering.
                           This   consists of a string of 16 digits 0-9, A-F.
                           The following example 
                           represents a NaN value. Note that certain IEEE doubles, such as the
                           NaN in the example, cannot be represented in the lexical format for
                           the "double" type.
                        </p>
                        <div class="mathml-example" id="contm.cn.hexdouble.ex"><pre class="mathml">
&lt;cn type="hexdouble"&gt;7F800000&lt;/cn&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mn&gt;0x7F800000&lt;/mn&gt;</pre><blockquote>
                              <p><img src="image/contm_cn_hexdouble_ex.gif" alt="{\mn{0x7F800000}}"></p>
                           </blockquote>
                        </div>
                     </dd>
                  </dl>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.cn.extended" id="contm.cn.extended"></a>4.2.1.3 Non-Strict uses of <code>&lt;cn&gt;</code></h4>
                  <p>The <code>base</code> attribute is used to specify how the content is
                     to be parsed.  The attribute value is a base 10 positive integer
                     giving the value of base in which the text content of the <code>cn</code>
                     is to be interpreted.  The <code>base</code> attribute should only be
                     used on elements with type "integer" or
                     "real".  Its use on <code>cn</code> elements of other type
                     is deprecated.  The default value for <code>base</code> is
                     "10".
                  </p>
                  <p>Additional values for the <code>type</code> attribute element for supporting
                     e-notations for real numbers, rational numbers, complex numbers and selected important
                     constants. As with the "integer", "real",
                     "double" and "hexdouble" types, each of these types
                     implies that the content be of a certain form. If the <code>type</code> attribute is
                     omitted, it defaults to "real".
                  </p>
                  <dl>
                     <dt class="label">integer</dt>
                     <dd>
                        <p>Integers can be represented with respect to a base different from
                           10: If <code>base</code> is present, it specifies (in base 10) the base for the digit encoding.
                           Thus <code>base</code>='16' specifies a hexadecimal
                           encoding.  When <code>base</code> &gt; 10, Latin letters (A-Z, a-z) are used in
                           alphabetical order as digits. The case of letters used as digits is not
                           significant.  The following example encodes the base 10 number 32736.
                        </p>
                        <div class="mathml-example" id="cn.base.ex"><pre class="mathml">&lt;cn base="16"&gt;7FE0&lt;/cn&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msub&gt;&lt;mn&gt;7FE0&lt;/mn&gt;&lt;mn&gt;16&lt;/mn&gt;&lt;/msub&gt;</pre><blockquote>
                              <p><img src="image/cn_base_ex.gif" alt="{\mn{7FE0}\sb{16}}"></p>
                           </blockquote>
                        </div>
                        <p>
                           When <code>base</code> &gt; 36, some integers cannot be represented using
                           numbers and letters alone. For example, while 
                           
                        </p><pre class="mathml">&lt;cn base="1000"&gt;10F&lt;/cn&gt;</pre><p>
                           arguably represents the number written in base 10 as 1,000,015, the number
                           written in base 10 as 1,000,037 cannot be represented using letters and
                           numbers alone when <code>base</code> is 1000.  Consequently, support
                           for additional characters (if any) that may be used for digits when <code>base</code> &gt; 36 is application specific.
                           
                        </p>
                     </dd>
                     <dt class="label">real</dt>
                     <dd>Real numbers can be represented with respect to a base
                        different than 10. If a <code>base</code> attribute is present, then the digits are
                        interpreted as being digits computed relative to that base (in the same way as
                        described for type "integer").
                     </dd>
                     <dt class="label">e-notation</dt>
                     <dd>
                        <p>A real number may be presented in scientific notation using this type.  Such
                           numbers have two parts (a significand and an exponent)
                           separated by a <code>&lt;sep/&gt;</code> element. The
                           first part is a real number, while the
                           second part is an integer exponent indicating a power of the base.
                        </p>
                        <p> For example, <code>&lt;cn type="e-notation"&gt;12.3&lt;sep/&gt;5&lt;/cn&gt;</code>
                           represents 12.3 times 10<sup>5</sup>. The default presentation of this example is
                           12.3e5. Note that this type is primarily useful for backwards compatibility with
                           MathML 2, and in most cases, it is preferable to use the "double"
                           type, if the number to be represented is in the range of IEEE doubles:
                        </p>
                     </dd>
                     <dt class="label">rational</dt>
                     <dd>
                        <p>A rational number is given as two integers to be used as the numerator and
                           denominator of a quotient. The numerator and denominator are
                           separated by <code>&lt;sep/&gt;</code>.
                        </p>
                        <div class="mathml-example" id="cn.rational.ex"><pre class="mathml">&lt;cn type="rational"&gt;22&lt;sep/&gt;7&lt;/cn&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;22&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;7&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                              <p><img src="image/cn_rational_ex.gif" alt="{{22}/{7}}"></p>
                           </blockquote>
                        </div>
                     </dd>
                     <dt class="label">complex-cartesian</dt>
                     <dd>
                        <p>A complex cartesian number is given as two numbers specifying the real and
                           imaginary parts.  The real and imaginary parts are separated
                           by the <code>&lt;sep/&gt;</code> element, and each part has
                           the format of a real number as described above.
                        </p>
                        <div class="mathml-example" id="cn.cc.ex"><pre class="mathml">
&lt;cn type="complex-cartesian"&gt; 12.3 &lt;sep/&gt; 5 &lt;/cn&gt;
</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mn&gt;12.3&lt;/mn&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mn&gt;5&lt;/mn&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;i&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                              <p><img src="image/cn_cc_ex.gif" alt="{{\mn{12.3}}+{5}\unicode{8290}i}"></p>
                           </blockquote>
                        </div>
                     </dd>
                     <dt class="label">complex-polar</dt>
                     <dd>
                        <p>A complex polar number is given as two numbers specifying
                           the magnitude and angle. The magnitude and angle are separated
                           by the <code>&lt;sep/&gt;</code> element, and each part has
                           the format of a real number as described above.
                        </p>
                        <div class="mathml-example" id="cn.cp.ex"><pre class="mathml">
&lt;cn type="complex-polar"&gt; 2 &lt;sep/&gt; 3.1415 &lt;/cn&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mn&gt;2&lt;/mn&gt;
 &lt;mo&gt;&amp;#x2062;&lt;/mo&gt;
 &lt;msup&gt;
  &lt;mi&gt;e&lt;/mi&gt;
  &lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mn&gt;3.1415&lt;/mn&gt;&lt;/mrow&gt;
 &lt;/msup&gt;
&lt;/mrow&gt;</pre><blockquote>
                              <p><img src="image/cn_cp_ex.gif" alt="{ {2} \unicode{8290} {\msup{e}{{i\unicode{8290}{\mn{3.1415}}}}} }"></p>
                           </blockquote><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;Polar&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;3.1415&lt;/mn&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                              <p><img src="image/cn_cp_ex-2.gif" alt="{ \mathop{\minormal{Polar}} {\left({2},{\mn{3.1415}}\right)} }"></p>
                           </blockquote>
                        </div>
                     </dd>
                     <dt class="label">constant</dt>
                     <dd>
                        <p>If the value <code>type</code> is "constant",
                           then the content should be a Unicode representation of a
                           well-known constant.  Some important constants and their
                           common Unicode representations are listed below.
                        </p>
                        <p>This <code>cn</code> type is primarily for backward
                           compatibility with MathML 1.0.  MathML 2.0 introduced many
                           empty elements, such as <code>&lt;pi/&gt;</code> to
                           represent constants, and using these representations or 
                           	  a Strict csymbol representation is preferred.
                        </p>
                     </dd>
                  </dl>
                  <p>In addition to the additional values of the type attribute, the
                     content of <code>cn</code> element can contain (in addition to the
                     <code>sep</code> element allowed in Strict Content MathML) <code>mglyph</code>
                     elements to refer to characters not currently available in Unicode, or
                     a general presentation construct (see <a href="chapter3-d.html#presm.summary">Section&nbsp;3.1.9 Summary of Presentation Elements</a>),
                     which is used for rendering (see <a href="chapter4-d.html#contm.rendering">Section&nbsp;4.1.2 The Structure and Scope of Content MathML Expressions</a>).
                  </p>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>If a <code>base</code> attribute is present, it specifies the base used for the digit
                     encoding of both integers.  The use of <code>base</code> with
                     "rational" numbers is deprecated.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm-strict-cn-sep" id="contm-strict-cn-sep"></a>Rewrite: cn sep
                     </h5>
                     <p>If there are <code>sep</code> children of the <code>cn</code>,
                        then intervening text may be rewritten as <code>cn</code>
                        elements.  If the <code>cn</code> element containing <code>sep</code>
                        also has a <code>base</code> attribute, this is copied to each
                        of the <code>cn</code> arguments of the resulting symbol, as
                        shown below.
                     </p><pre class="mathml">
&lt;cn type="<span class="egmeta">rational</span>" base="<span class="egmeta">b</span>"&gt;<span class="egmeta">n</span>&lt;sep/&gt;<span class="egmeta">d</span>&lt;/cn&gt;</pre><p> is rewritten to</p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="<span class="egmeta">nums1</span>"&gt;<span class="egmeta">rational</span>&lt;/csymbol&gt;
  &lt;cn type="integer" base="<span class="egmeta">b</span>"&gt;<span class="egmeta">n</span>&lt;/cn&gt;
  &lt;cn type="integer" base="<span class="egmeta">b</span>"&gt;<span class="egmeta">d</span>&lt;/cn&gt;
&lt;/apply&gt;</pre><p>The symbol used in the result depends on the <code>type</code> attribute according to the following table:
                     </p>
                     <table id="contm.table-cntype" border="1">
                        <thead>
                           <tr>
                              <th>type attribute</th>
                              <th>OpenMath Symbol</th>
                           </tr>
                        </thead>
                        <tbody>
                           <tr>
                              <td>e-notation</td>
                              <td><a href="http://www.openmath.org/cd/bigfloat1.xhtml#bigfloat">bigfloat</a></td>
                           </tr>
                           <tr>
                              <td>rational</td>
                              <td><a href="http://www.openmath.org/cd/nums1.xhtml#rational">rational</a></td>
                           </tr>
                           <tr>
                              <td>complex-cartesian</td>
                              <td><a href="http://www.openmath.org/cd/complex1.xhtml#complex_cartesian">complex_cartesian</a></td>
                           </tr>
                           <tr>
                              <td>complex-polar</td>
                              <td><a href="http://www.openmath.org/cd/complex1.xhtml#complex_polar">complex_polar</a></td>
                           </tr>
                        </tbody>
                     </table>
                     <p>Note: In the case of <a href="http://www.openmath.org/cd/bigfloat1.xhtml#bigfloat">bigfloat</a> the symbol
                        takes three arguments, <code>&lt;cn type="integer"&gt;10&lt;/cn&gt;</code> should be inserted as the second argument, denoting the base of the exponent used.
                     </p>
                     <p>If the <code>type</code> attribute has a different value, or if there is more than one <code>&lt;sep/&gt;</code> element, then the intervening expressions are converted as above, but a system-dependent choice of symbol for the head of
                        the application must be used.
                     </p>
                     <p>If a base attribute has been used then the resulting expression is not Strict Content MathML, and each of the arguments needs
                        to be recursively processed.
                     </p>
                  </div>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.cn-base" id="contm.cn-base"></a>Rewrite: cn based_integer
                     </h5>
                     <p>A <code>cn</code> element with a base attribute other than 10 is rewritten as follows. (A base attribute with value 10 is simply removed) .
                     </p><pre class="mathml">
&lt;cn type="<span class="egmeta">integer</span>" base="<span class="egmeta">16</span>"&gt;<span class="egmeta">FF60</span>&lt;/cn&gt;</pre><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="nums1"&gt;<span class="egmeta">based_integer</span>&lt;/csymbol&gt;
  &lt;cn type="integer"&gt;<span class="egmeta">16</span>&lt;/cn&gt;
  &lt;cs&gt;<span class="egmeta">FF60</span>&lt;/cs&gt;
&lt;/apply&gt;</pre><p>If the original element specified type "integer"
                        or if there is no type attribute, but the content of the
                        element just consists of the characters [a-zA-Z0-9] and white space
                        then the symbol used as the head in the resulting application should
                        be <a href="http://www.openmath.org/cd/nums1.xhtml#based_integer">based_integer</a> as shown. Otherwise it
                        should be should be <a href="http://www.openmath.org/cd/nums1.xhtml#based_float">based_float</a>.
                     </p>
                  </div>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.cn.strict.const" id="contm.cn.strict.const"></a>Rewrite: cn constant
                     </h5>
                     <p>In Strict Content MathML, constants should be represented using
                        <code>csymbol</code> elements.  A number of important constants are defined in the
                        <a href="http://www.openmath.org/cd/nums1.xhtml">nums1</a> content dictionary. An expression of the form 
                        
                     </p><pre class="mathml">&lt;cn type="constant"&gt;<span class="egmeta">c</span>&lt;/cn&gt;</pre><p>
                        has the Strict Content MathML equivalent
                        
                     </p><pre class="strict-mathml">&lt;csymbol cd="nums1"&gt;<span class="egmeta">c2</span>&lt;/csymbol&gt;</pre><p>
                        where <code>c2</code>  corresponds to <code>c</code> as specified in the following table.
                     </p>
                     <table id="contm.table-pragnum" border="1">
                        <thead>
                           <tr>
                              <th>Content</th>
                              <th>Description</th>
                              <th>OpenMath Symbol</th>
                           </tr>
                        </thead>
                        <tbody>
                           <tr>
                              <td>U+03C0 (<code>&amp;pi;</code>)
                              </td>
                              <td>The usual <var>π</var> of trigonometry: approximately 3.141592653...
                              </td>
                              <td><a href="http://www.openmath.org/cd/nums1.xhtml#pi">pi</a></td>
                           </tr>
                           <tr>
                              <td>U+2147 (<code>&amp;ExponentialE;</code> or <code>&amp;ee;</code>)
                              </td>
                              <td>The base for natural logarithms: approximately 2.718281828...</td>
                              <td><a href="http://www.openmath.org/cd/nums1.xhtml#e">e</a></td>
                           </tr>
                           <tr>
                              <td>U+2148 (<code>&amp;ImaginaryI;</code> or <code>&amp;ii;</code>)
                              </td>
                              <td>Square root of -1</td>
                              <td><a href="http://www.openmath.org/cd/nums1.xhtml#i">i</a></td>
                           </tr>
                           <tr>
                              <td>U+03B3 (<code>&amp;gamma;</code>)
                              </td>
                              <td>Euler's constant: approximately 0.5772156649...</td>
                              <td><a href="http://www.openmath.org/cd/nums1.xhtml#gamma">gamma</a></td>
                           </tr>
                           <tr>
                              <td>U+221E (<code>&amp;infin;</code> or <code>&amp;infty;</code>)
                              </td>
                              <td>Infinity. Proper interpretation varies with context</td>
                              <td><a href="http://www.openmath.org/cd/nums1.xhtml#infinity">infinity</a></td>
                           </tr>
                        </tbody>
                     </table>
                  </div>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.cn.pres" id="contm.cn.pres"></a>Rewrite: cn presentation mathml
                     </h5>
                     <p>If the <code>cn</code> contains Presentation MathML markup, then it may
                        be rewritten to Strict MathML using variants of the rules above where
                        the arguments of the constructor are <code>ci</code> elements annotated
                        with the supplied Presentation MathML.
                     </p>
                     <p>A <code>cn</code> expression with non-text content of the form 
                        
                     </p><pre class="mathml">
&lt;cn type="<span class="egmeta">rational</span>"&gt; <span class="egmeta">P</span> &lt;sep/&gt; <span class="egmeta">Q</span> &lt;/cn&gt;</pre><p> 
                        is transformed to Strict Content MathML by rewriting it to 
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="<span class="egmeta">nums1</span>"&gt;<span class="egmeta">rational</span>&lt;/csymbol&gt;
 &lt;semantics&gt;
  &lt;ci&gt;<span class="egmeta">p</span>&lt;/ci&gt;
  &lt;annotation-xml encoding="MathML-Presentation"&gt;
    <span class="egmeta">P</span> 
  &lt;/annotation-xml&gt;
 &lt;/semantics&gt;
 &lt;semantics&gt;
  &lt;ci&gt;<span class="egmeta">q</span>&lt;/ci&gt;
  &lt;annotation-xml encoding="MathML-Presentation"&gt;
    <span class="egmeta">Q</span> 
  &lt;/annotation-xml&gt;
 &lt;/semantics&gt;
&lt;/apply&gt;</pre><p>
                        Where the identifier names, p and q, (which have to be a text string) should be
                        determined from the presentation MathML content, in a system defined way, perhaps as
                        in the above example by taking the character data of the element ignoring any element
                        markup.  Systems doing such rewriting should ensure that constructs using the same
                        Presentation MathML content are rewritten to <code>semantics</code> elements using the
                        same <code>ci</code>, and that conversely constructs that use different MathML should be
                        rewritten to different identifier names (even if the Presentation MathML has  the same character data).
                        
                     </p>
                     <p>A related special case arises when a <code>cn</code> element
                        contains character data not permitted in Strict Content MathML
                        usage, e.g. non-digit, alphabetic characters.  Conceptually, this is
                        analogous to a <code>cn</code> element containing a presentation
                        markup <code>mtext</code> element, and could be rewritten accordingly.
                        However, since the resulting annotation would contain no additional
                        rendering information, such instances should be rewritten directly
                        as <code>ci</code> elements, rather than as a <code>semantics</code>
                        construct.
                     </p>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.ci" id="contm.ci"></a>4.2.2 Content Identifiers <code>&lt;ci&gt;</code></h3>
               <table class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th>Schema Fragment (Strict)</th>
                        <th>Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td><a href="chapter4-d.html#contm.ci">Ci</a></td>
                        <td><a href="chapter4-d.html#contm.ci">Ci</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_type">type</a>?
                        </td>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>, <a href="appendixa-d.html#parsing_type">type</a>?
                        </td>
                     </tr>
                     <tr>
                        <th><code>type</code> Attribute Values
                        </th>
                        <td>
                           "integer"|
                           "rational"| 
                           "real"|
                           "complex"| 
                           "complex-polar"|
                           "complex-cartesian"|
                           "constant"|
                           "function"| 
                           "vector"|
                           "list"|
                           "set"|
                           "matrix" 
                           
                        </td>
                        <td> string</td>
                     </tr>
                     <tr>
                        <th>Qualifiers</th>
                        <td></td>
                        <td>
                           <a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>, 
                           <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a>, 
                           <a href="appendixa-d.html#parsing_degree">degree</a>, 
                           <a href="appendixa-d.html#parsing_momentabout">momentabout</a>, 
                           <a href="appendixa-d.html#parsing_logbase">logbase</a>
                           
                        </td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td>text</td>
                        <td>text | <a href="appendixa-d.html#parsing_mglyph">mglyph</a> | <a href="appendixa-d.html#parsing_PresentationExpression">PresentationExpression</a></td>
                     </tr>
                  </tbody>
               </table>
               <p>Content MathML uses the <code>ci</code> element (mnemonic for "content
                  identifier") to construct a variable. Content identifiers
                  represent "mathematical variables" which have 
                  properties, but no fixed value. For example, <var>x</var> and <var>y</var> are variables 
                  in the expression "<var>x</var>+<var>y</var>", and the variable
                  <var>x</var> would be represented as 
                  
                  
               </p><pre class="strict-mathml">&lt;ci&gt;x&lt;/ci&gt;</pre><p>
                  
                  In MathML, variables are distinguished from symbols, which have fixed, external
                  definitions, and are represented by the <a href="chapter4-d.html#contm.csymbol">csymbol</a> element.
               </p>
               <p>After white space normalization the content of a <code>ci</code> element is interpreted as a
                  name that identifies it. Two variables are considered equal, if and only if their names
                  are identical and in the same scope (see <a href="chapter4-d.html#contm.binding">Section&nbsp;4.2.6 Bindings and Bound Variables <code>&lt;bind&gt;</code>
                     and <code>&lt;bvar&gt;</code></a> for a
                  discussion).
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.ci.strict" id="contm.ci.strict"></a>4.2.2.1 Strict uses of <code>&lt;ci&gt;</code></h4>
                  <p>The <code>ci</code> element uses the <code>type</code> attribute to specify the basic type of 
                     object that it represents. In Strict Content  MathML, the set of permissible values is
                     "integer", "rational", "real",
                     "complex", "complex-polar",
                     "complex-cartesian", "constant", "function",
                     <code>vector</code>, <code>list</code>, <code>set</code>, and <code>matrix</code>. These values correspond
                     to the symbols 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#integer_type">integer_type</a>, 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#rational_type">rational_type</a>, 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#real_type">real_type</a>,
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#complex_polar_type">complex_polar_type</a>,
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#complex_cartesian_type">complex_cartesian_type</a>, 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#constant_type">constant_type</a>, 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#fn_type">fn_type</a>,
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#vector_type">vector_type</a>,
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#list_type">list_type</a>, 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#set_type">set_type</a>, and 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml#matrix_type">matrix_type</a> in the 
                     <a href="http://www.openmath.org/cd/mathmltypes.xhtml">mathmltypes</a> Content Dictionary: In this sense the following two expressions are considered equivalent: 
                     
                  </p>
                  <div class="strict-mathml-example" id="contm.ci.mathmltypes"><pre class="mathml">&lt;ci type="integer"&gt;n&lt;/ci&gt;</pre><pre class="strict-mathml">
&lt;semantics&gt;
  &lt;ci&gt;n&lt;/ci&gt;
  &lt;annotation-xml cd="mathmltypes" name="type" encoding="MathML-Content"&gt;
    &lt;csymbol cd="mathmltypes"&gt;integer_type&lt;/csymbol&gt;
  &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.ci.extended" id="contm.ci.extended"></a>4.2.2.2 Non-Strict uses of <code>&lt;ci&gt;</code></h4>
                  <p>The <code>ci</code> element allows any string value for the <code>type</code>
                     attribute, in particular any of the names of the MathML container elements or their type
                     values.
                  </p>
                  <p>For a more advanced treatment of types, the <code>type</code> attribute is
                     inappropriate.  Advanced types require significant structure of their own (for example,
                     <var>vector(complex)</var>) and are probably best constructed as mathematical objects and
                     then associated with a MathML expression through use of the <code>semantics</code>
                     element. See <a href="appendixh-d.html#MathMLTypes">[MathMLTypes]</a> for more examples.
                  </p>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.ci.strict.ex" id="contm.ci.strict.ex"></a>Rewrite: ci type annotation
                     </h5>
                     <p>In Strict Content, type attributes are represented via 
                        semantic attribution. An expression of the form 
                        
                     </p><pre class="mathml">&lt;ci type="<span class="egmeta">T</span>"&gt;<span class="egmeta">n</span>&lt;/ci&gt;</pre><p>
                        is rewritten to 
                        
                     </p><pre class="strict-mathml">
&lt;semantics&gt;
  &lt;ci&gt;<span class="egmeta">n</span>&lt;/ci&gt;
  &lt;annotation-xml cd="mathmltypes" name="type" encoding="MathML-Content"&gt;
    &lt;ci&gt;<span class="egmeta">T</span>&lt;/ci&gt;
  &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre></div>
                  <p>The <code>ci</code> element can contain
                     <code>mglyph</code> elements to refer to characters not currently available in Unicode, or a
                     general presentation construct (see <a href="chapter3-d.html#presm.summary">Section&nbsp;3.1.9 Summary of Presentation Elements</a>), which is used for
                     rendering (see <a href="chapter4-d.html#contm.rendering">Section&nbsp;4.1.2 The Structure and Scope of Content MathML Expressions</a>).
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.ci.pres" id="contm.ci.pres"></a>Rewrite: ci presentation mathml
                     </h5>
                     <p>A <code>ci</code> expression with non-text content of the form 
                        
                     </p><pre class="mathml">&lt;ci&gt; <span class="egmeta">P</span> &lt;/ci&gt;</pre><p> 
                        is transformed to Strict Content MathML by rewriting it to 
                        
                     </p><pre class="strict-mathml">
&lt;semantics&gt;
  &lt;ci&gt;<span class="egmeta">p</span>&lt;/ci&gt;
  &lt;annotation-xml encoding="MathML-Presentation"&gt;
     <span class="egmeta">P</span> 
  &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre><p>
                        Where the identifier name, p, (which has to be a text string) should be
                        determined from the presentation MathML content, in a system defined way, perhaps as
                        in the above example by taking the character data of the element ignoring any element
                        markup.  Systems doing such rewriting should ensure that constructs using the same
                        Presentation MathML content are rewritten to <code>semantics</code> elements using the
                        same <code>ci</code>, and that conversely constructs that use different MathML should be
                        rewritten to different identifier names (even if the Presentation MathML has  the same character data).
                        
                     </p>
                  </div>
                  <div class="strict-mathml-example" id="contm.ci.c2">
                     <p> The following example encodes an atomic 
                        symbol that displays visually as <var>C</var><sup>2</sup> and that, 
                        for purposes of content, is treated as a single symbol
                     </p><pre class="mathml">
&lt;ci&gt;
  &lt;msup&gt;&lt;mi&gt;C&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
&lt;/ci&gt;</pre><p>The Strict Content MathML equivalent is</p><pre class="strict-mathml">
&lt;semantics&gt;
  &lt;ci&gt;C2&lt;/ci&gt;
  &lt;annotation-xml encoding="MathML-Presentation"&gt;
    &lt;msup&gt;&lt;mi&gt;C&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
  &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre><p>Sample Presentation</p><pre class="mathml">
 &lt;msup&gt;&lt;mi&gt;C&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;</pre><blockquote>
                        <p><img src="image/contm_ci_c2.gif" alt="{\msup{C}{{2}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rendering.ci" id="contm.rendering.ci"></a>4.2.2.3 Rendering Content Identifiers
                  </h4>
                  <p>If the content of a <code>ci</code> element consists of Presentation MathML, that
                     presentation is used. If no such tagging is supplied then the text
                     content is rendered as if it were the content of an <code>mi</code> element. If an
                     application supports bidirectional text rendering, then the rendering follows the
                     Unicode bidirectional rendering.
                  </p>
                  <p>The <code>type</code> attribute can be interpreted to
                     provide rendering information. For example in
                     
                  </p><pre class="mathml">&lt;ci type="vector"&gt;V&lt;/ci&gt;</pre><p>
                     a renderer could display a bold V for the vector.
                  </p>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.csymbol" id="contm.csymbol"></a>4.2.3 Content Symbols <code>&lt;csymbol&gt;</code></h3>
               <table class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th>Schema Fragment (Strict)</th>
                        <th>Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td><a href="chapter4-d.html#contm.csymbol">Csymbol</a></td>
                        <td><a href="chapter4-d.html#contm.csymbol">Csymbol</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_cd">cd</a></td>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>, <a href="appendixa-d.html#parsing_type">type</a>?, <a href="appendixa-d.html#parsing_cd">cd</a>?
                        </td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td><a href="appendixa-d.html#parsing_SymbolName">SymbolName</a></td>
                        <td>text | <a href="appendixa-d.html#parsing_mglyph">mglyph</a> | <a href="appendixa-d.html#parsing_PresentationExpression">PresentationExpression</a></td>
                     </tr>
                     <tr>
                        <th>Qualifiers</th>
                        <td></td>
                        <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>, <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a>, <a href="appendixa-d.html#parsing_degree">degree</a>, <a href="appendixa-d.html#parsing_momentabout">momentabout</a>, <a href="appendixa-d.html#parsing_logbase">logbase</a></td>
                     </tr>
                  </tbody>
               </table>
               <p>A <code>csymbol</code> is used to refer to a specific,
                  mathematically-defined concept with an external definition. In the
                  expression "<var>x</var>+<var>y</var>", the plus sign is
                  a symbol since it has a specific, external definition, namely the addition function.
                  MathML 3 calls such an identifier  a
                  <em>symbol</em>. Elementary functions and common mathematical
                  operators are all examples of symbols. Note that the term
                  "symbol" is used here in an abstract sense and has no
                  connection with any particular presentation of the construct on screen
                  or paper.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.csymbol.strict" id="contm.csymbol.strict"></a>4.2.3.1 Strict uses of  <code>&lt;csymbol&gt;</code></h4>
                  <p>The <code>csymbol</code> identifies the specific mathematical concept
                     it represents by referencing its definition via attributes.
                     Conceptually, a reference to an external definition is merely a URI,
                     i.e. a label uniquely identifying the definition.  However, to be
                     useful for communication between user agents, external definitions
                     must be shared.
                  </p>
                  <p>For this reason, several longstanding efforts have
                     been organized to develop systematic, public repositories of
                     mathematical definitions.  Most notable of these, the OpenMath Society
                     repository of Content Dictionaries (CDs) is extensive, open and
                     active. In MathML 3, OpenMath CDs are the preferred source of external
                     definitions. In particular, the definitions of pre-defined MathML 3
                     operators and functions are given in terms of OpenMath CDs.
                  </p>
                  <p>MathML 3 provides two mechanisms for referencing external definitions or content
                     dictionaries.  The first, using the <code>cd</code> attribute, follows conventions
                     established by OpenMath specifically for referencing CDs. This is the
                     form required in Strict Content MathML.  The second, using the
                     <code>definitionURL</code> attribute, is backward compatible with MathML 2, and can be used
                     to reference CDs or any other source of definitions that can be
                     identified by a URI.  It is described in the following section
                  </p>
                  <p>When referencing OpenMath CDs, the preferred method is to use the <code>cd</code>
                     attribute as follows. Abstractly, OpenMath symbol definitions are identified by a triple
                     of values: a <em>symbol name</em>, a <em>CD name</em>, and a <em>CD base</em>,
                     which is a URI that disambiguates CDs of the same name.  To associate such a triple with a
                     <code>csymbol</code>, the content of the <code>csymbol</code> specifies the symbol name, and the
                     name of the Content Dictionary is given using the <code>cd</code> attribute. The CD base is
                     determined either from the document embedding the <code>math</code> element which contains the
                     <code>csymbol</code> by a mechanism given by the embedding document format, or by system
                     defaults, or by the <code>cdgroup</code> attribute , which is optionally specified on the
                     enclosing <code>math</code> element; see <a href="chapter2-d.html#interf.toplevel.atts">Section&nbsp;2.2.1 Attributes</a>. In the absence
                     of specific information <code>http://www.openmath.org/cd</code> is assumed as the CD base
                     for all <code>csymbol</code> elements <code>annotation</code>, and <code>annotation-xml</code>.  This
                     is the CD base for the collection of standard CDs maintained by the OpenMath Society.
                  </p>
                  <p>The <code>cdgroup</code> specifies a URL to an OpenMath CD Group file.  For a detailed
                     description of the format of a CD Group file, see Section 4.4.2 (CDGroups) 
                     in <a href="appendixg-d.html#OpenMath2004">[OpenMath2004]</a>.  Conceptually, a CD group file is a list of
                     pairs consisting of a CD name, and a corresponding CD base. When a <code>csymbol</code>
                     references a CD name using the <code>cd</code> attribute, the name is looked up in the CD
                     Group file, and the associated CD base value is used for that <code>csymbol</code>. When a CD
                     Group file is specified, but a referenced CD name does not appear in the group file, or
                     there is an error in retrieving the group file, the referencing <code>csymbol</code> is not
                     defined.  However, the handling of the resulting error is not defined, and is the
                     responsibility of the user agent.
                  </p>
                  <p>While references to external definitions are URIs, it is strongly recommended that CD
                     files be retrievable at the location obtained by interpreting the URI as a URL.  In
                     particular, other properties of the symbol being defined may be available by inspecting
                     the Content Dictionary specified. These include not only the symbol definition, but also
                     examples and other formal properties.  Note, however, that there are multiple encodings
                     for OpenMath Content Dictionaries, and it is up to the user agent to correctly determine
                     the encoding when retrieving a CD.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.csymbol.extended" id="contm.csymbol.extended"></a>4.2.3.2 Non-Strict uses of <code>&lt;csymbol&gt;</code></h4>
                  <p>In addition to the forms described above, the <code>csymbol</code> and element can contain
                     <code>mglyph</code> elements to refer to characters not currently available in Unicode, or a
                     general presentation construct (see <a href="chapter3-d.html#presm.summary">Section&nbsp;3.1.9 Summary of Presentation Elements</a>), which is used for
                     rendering (see <a href="chapter4-d.html#contm.rendering">Section&nbsp;4.1.2 The Structure and Scope of Content MathML Expressions</a>). In this case, when
                     writing to Strict Content MathML, the csymbol should be treated as a
                     <code>ci</code> element, and rewritten using <a href="chapter4-d.html#contm.ci.pres">Rewrite: ci presentation mathml</a>.
                  </p>
                  <p>External definitions (in OpenMath CDs or elsewhere) may also be specified directly for
                     a <code>csymbol</code> using the <code>definitionURL</code> attribute.  When used to reference
                     OpenMath symbol definitions, the abstract triple of (symbol name, CD name, CD base) is
                     mapped to a fully-qualified URI as follows:
                     
                     
                  </p><pre><code>URI = </code><var>cdbase</var><code> + '/' + </code><var>cd-name</var><code> + '#' + </code><var>symbol-name</var></pre><p>
                     
                     For example,
                     
                     
                  </p><pre>(plus, arith1, http://www.openmath.org/cd)</pre><p>
                     
                     is mapped to
                     
                     
                  </p><pre><code>http://www.openmath.org/cd/arith1#plus</code></pre><p>
                     
                     The resulting URI is specified as the value of the <code>definitionURL</code> attribute.
                  </p>
                  <p>This form of reference is useful for backwards compatibility with MathML2 and to
                     facilitate the use of Content MathML within URI-based frameworks (such as RDF <a href="appendixh-d.html#rdf">[rdf]</a> in the Semantic Web or OMDoc <a href="appendixh-d.html#OMDoc1.2">[OMDoc1.2]</a>).  Another benefit is
                     that the symbol name in the CD does not need to correspond to the content of the
                     <code>csymbol</code> element.  However, in general, this method results in much longer MathML
                     instances.  Also, in situations where CDs are under development, the use of a CD Group
                     file allows the locations of CDs to change without a change to the markup.  A third
                     drawback to <code>definitionURL</code> is that unlike the <code>cd</code> attribute, it is not
                     limited to referencing symbol definitions in OpenMath content dictionaries.  Hence, it is
                     not in general possible for a user agent to automatically determine the proper
                     interpretation for <code>definitionURL</code> values without further information about the
                     context and community of practice in which the MathML instance occurs.
                  </p>
                  <p>Both the <code>cd</code> and <code>definitionURL</code> mechanisms of external reference
                     may be used within a single MathML instance.  However, when both a <code>cd</code> and a
                     <code>definitionURL</code> attribute are specified on a single <code>csymbol</code>, the
                     <code>cd</code> attribute takes precedence.
                  </p>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>In non-Strict usage <code>csymbol</code> allows the use of
                     a <code>type</code> attribute.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.csymbol.strict.ex" id="contm.csymbol.strict.ex"></a>Rewrite: csymbol type annotation
                     </h5>
                     <p>In Strict Content, type attributes are represented via 
                        semantic attribution. An expression of the form 
                        
                     </p><pre class="mathml">&lt;csymbol type="<span class="egmeta">T</span>"&gt;symbolname&lt;/csymbol&gt;</pre><p>
                        is rewritten to 
                        
                     </p><pre class="strict-mathml">
&lt;semantics&gt;
  &lt;csymbol&gt;symbolname&lt;/csymbol&gt;
  &lt;annotation-xml cd="mathmltypes" name="type" encoding="MathML-Content"&gt;
    &lt;ci&gt;<span class="egmeta">T</span>&lt;/ci&gt;
  &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rendering.csymbol" id="contm.rendering.csymbol"></a>4.2.3.3 Rendering Symbols
                  </h4>
                  <p>If the content of a <code>csymbol</code> element is tagged using presentation tags,
                     that presentation is used. If no such tagging is supplied then the text
                     content is rendered as if it were the content of an <code>mi</code> element. In
                     particular if an application supports bidirectional text rendering, then the
                     rendering follows the Unicode bidirectional rendering.
                  </p>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.cs" id="contm.cs"></a>4.2.4 String Literals <code>&lt;cs&gt;</code></h3>
               <table class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th>Schema Fragment (Strict)</th>
                        <th>Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td><a href="chapter4-d.html#contm.cs">Cs</a></td>
                        <td><a href="chapter4-d.html#contm.cs">Cs</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a></td>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td>text</td>
                        <td>text</td>
                     </tr>
                  </tbody>
               </table>
               <p>The <code>cs</code> element encodes "string literals"
                  which may be used in Content MathML expressions.
               </p>
               <p>The content of cs is text; no
                  Presentation MathML constructs are allowed even when used in
                  non-strict markup. Specifically, <code>cs</code> may not contain
                  <code>mglyph</code> elements, and the content does not undergo white space
                  normalization.
               </p>
               <div class="mathml-example" id="contm.cs.ex">
                  <p>Content MathML</p><pre class="mathml">
&lt;set&gt;
  &lt;cs&gt;A&lt;/cs&gt;&lt;cs&gt;B&lt;/cs&gt;&lt;cs&gt;  &lt;/cs&gt;
&lt;/set&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;{&lt;/mo&gt;
 &lt;ms&gt;A&lt;/ms&gt;
 &lt;mo&gt;,&lt;/mo&gt;
 &lt;ms&gt;B&lt;/ms&gt;
 &lt;mo&gt;,&lt;/mo&gt;
 &lt;ms&gt;&amp;#xa0;&amp;#xa0;&lt;/ms&gt;
 &lt;mo&gt;}&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                     <p><img src="image/cs-ex.gif" alt="{\left.\middle\{\mbox{\textquotedbl A\textquotedbl},\mbox{\textquotedbl B\textquotedbl },\mbox{\textquotedbl\ \ \textquotedbl }\middle\}\right.}"></p>
                  </blockquote>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.apply" id="contm.apply"></a>4.2.5 Function Application <code>&lt;apply&gt;</code></h3>
               <table class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th colspan="2">Schema Fragment (Strict)</th>
                        <th colspan="2">Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td colspan="2"><a href="chapter4-d.html#contm.apply">Apply</a></td>
                        <td colspan="2"><a href="chapter4-d.html#contm.apply">Apply</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td colspan="2"><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a></td>
                        <td colspan="2"><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td colspan="2"><a href="appendixa-d.html#parsing_ContExp">ContExp</a>+
                        </td>
                        <td colspan="2"><a href="appendixa-d.html#parsing_ContExp">ContExp</a>+
                           | 
                           (<a href="appendixa-d.html#parsing_ContExp">ContExp</a>, 
                           <a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>, 
                           <a href="appendixa-d.html#parsing_Qualifier">Qualifier</a>?, 
                           <a href="appendixa-d.html#parsing_ContExp">ContExp</a>*)
                        </td>
                     </tr>
                  </tbody>
               </table>
               <p>The most fundamental way of building a compound object in
                  mathematics is by applying a function or an operator to some
                  arguments.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.applications.strict" id="contm.applications.strict"></a>4.2.5.1 Strict Content MathML
                  </h4>
                  <p>In MathML, the <code>apply</code> element is used to build an expression tree that
                     represents the application a function or operator to its arguments. The
                     resulting tree corresponds to a complete mathematical expression. Roughly
                     speaking, this means a piece of mathematics that could be surrounded by
                     parentheses or "logical brackets" without changing its meaning.
                  </p>
                  <p>For example, (<var>x</var> + <var>y</var>) might be encoded as
                     
                     
                  </p><pre class="mathml">&lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;</pre><p>
                     
                     The opening and closing tags of <code>apply</code> specify exactly the scope of any
                     operator or function. The most typical way of using <code>apply</code> is simple and
                     recursive. Symbolically, the content model can be described as:
                     
                     
                  </p><pre class="mathml-extension">&lt;apply&gt; <em>op</em> [ <em>a</em> <em>b</em> ...] &lt;/apply&gt;</pre><p>
                     
                     where the <em>operands</em> <em>a</em>, <em>b</em>, ... are MathML
                     expression trees themselves, and <em>op</em> is a MathML expression tree that
                     represents an operator or function. Note that <code>apply</code> constructs can be
                     nested to arbitrary depth.
                  </p>
                  <p>An <code>apply</code> may in principle have any number of operands. For example,
                     (<var>x</var> + <var>y</var> + <var>z</var>) can be encoded as
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
  &lt;ci&gt;x&lt;/ci&gt;
  &lt;ci&gt;y&lt;/ci&gt;
  &lt;ci&gt;z&lt;/ci&gt;
&lt;/apply&gt;</pre><p>
                     Note that MathML also allows applications without operands, e.g. to represent functions like <code>random()</code>, or  <code>current-date()</code>.
                  </p>
                  <p>Mathematical expressions involving a mixture of operations result in nested
                     occurrences of <code>apply</code>. For example, <var>a</var> <var>x</var> + <var>b</var>
                     would be encoded as
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="arith1"&gt;times&lt;/csymbol&gt;
    &lt;ci&gt;a&lt;/ci&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;ci&gt;b&lt;/ci&gt;
&lt;/apply&gt;</pre><p>There is no need to introduce parentheses or to resort to
                     operator precedence in order to parse expressions correctly. The
                     <code>apply</code> tags provide the proper grouping for the re-use
                     of the expressions within other constructs. Any expression
                     enclosed by an <code>apply</code> element is well-defined, coherent
                     object whose interpretation does not depend on the surrounding
                     context.  This is in sharp contrast to presentation markup,
                     where the same expression may have very different meanings in
                     different contexts.  For example, an expression with a visual
                     rendering such as (<var>F</var>+<var>G</var>)(<var>x</var>)
                     might be a product, as in
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;times&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
    &lt;ci&gt;F&lt;/ci&gt;
    &lt;ci&gt;G&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/apply&gt;</pre><p>
                     
                     or it might indicate the application of the function <var>F</var> + <var>G</var> to
                     the argument <var>x</var>. This is indicated by constructing the sum
                     
                     
                  </p><pre class="mathml">&lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;&lt;ci&gt;F&lt;/ci&gt;&lt;ci&gt;G&lt;/ci&gt;&lt;/apply&gt;</pre><p>
                     
                     and applying it to the argument <var>x</var> as in
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
    &lt;ci&gt;F&lt;/ci&gt;
    &lt;ci&gt;G&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/apply&gt;</pre><p>
                     
                     In both cases, the interpretation of the outer <code>apply</code> is
                     explicit and unambiguous, and does not change regardless of
                     where the expression is used.
                  </p>
                  <p>The preceding example also illustrates that in an
                     <code>apply</code> construct, both the function and the arguments
                     may be simple identifiers or more complicated expressions.
                  </p>
                  <p>The <code>apply</code> element is conceptually necessary in order to distinguish
                     between a function or operator, and an instance of its use. The expression
                     constructed by applying a function to 0 or more arguments is always an element from
                     the codomain of the function. Proper usage depends on the operator that is being
                     applied. For example, the <code>plus</code> operator may have zero or more arguments,
                     while the <code>minus</code> operator requires one or two arguments in order to be properly
                     formed.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rendering.applications" id="contm.rendering.applications"></a>4.2.5.2 Rendering Applications
                  </h4>
                  <p>Strict Content MathML applications are rendered as mathematical
                     function applications.  If 
                     <code> <span class="egmeta">F</span> </code> denotes the rendering of 
                     <code> <span class="egmeta">f</span> </code> and 
                     <code> <span class="egmeta">Ai</span> </code>
                     the rendering of
                     <code> <span class="egmeta">ai</span> </code>, the the sample
                     rendering of a simple application is as follows:
                     
                  </p>
                  <div class="mathml-example" id="contm.render.apply">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt; <span class="egmeta">f</span> 
   <span class="egmeta">a1</span> 
   <span class="egmeta">a2</span> 
   <span class="egmeta">...</span> 
   <span class="egmeta">an</span> 
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
  <span class="egmeta">F</span> 
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mo fence="true"&gt;(&lt;/mo&gt;
   <span class="egmeta">A1</span> 
  &lt;mo separator="true"&gt;,&lt;/mo&gt;
   <span class="egmeta">...</span> 
  &lt;mo separator="true"&gt;,&lt;/mo&gt;
   <span class="egmeta">A2</span> 
  &lt;mo separator="true"&gt;,&lt;/mo&gt;
   <span class="egmeta">An</span> 
  &lt;mo fence="true"&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre></div>
                  <p>Non-Strict MathML applications may also be used with qualifiers. In the absence of
                     any more specific rendering rules for well-known operators, rendering
                     should follow the sample presentation below, motivated by the typical
                     presentation for <code>sum</code>. Let  
                     <code> <span class="egmeta">Op</span> </code> denote the rendering of 
                     <code> <span class="egmeta">op</span> </code>, 
                     <code> <span class="egmeta">X</span> </code>
                     the rendering of
                     <code> <span class="egmeta">x</span> </code>, and so on.  Then:
                     
                  </p>
                  <div class="mathml-example" id="contm.render.apply.limit">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt; <span class="egmeta">op</span> 
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">d</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munder&gt;
   <span class="egmeta">Op</span> 
  &lt;mrow&gt; <span class="egmeta">X</span> &lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;!--ELEMENT OF--&gt; <span class="egmeta">D</span> &lt;/mrow&gt;
 &lt;/munder&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;!--FUNCTION APPLICATION--&gt;
 &lt;mrow&gt;
  &lt;mo fence="true"&gt;(&lt;/mo&gt;
   <span class="egmeta">Expression-in-X</span> 
  &lt;mo fence="true"&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.binding" id="contm.binding"></a>4.2.6 Bindings and Bound Variables <code>&lt;bind&gt;</code>
                  and <code>&lt;bvar&gt;</code></h3>
               <p>Many complex mathematical expressions are constructed with the use of bound
                  variables, and bound variables are an important concept of logic and formal
                  languages. Variables become <em>bound</em> in the scope of an expression through
                  the use of a quantifier.  Informally, they can be thought of as the "dummy variables"
                  in expressions such as integrals, sums, products, and the logical quantifiers "for
                  all" and "there exists".  A bound variable is characterized by the property that
                  systematically renaming the variable (to a name not already appearing in the
                  expression) does not change the meaning of the expression.  
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.bind" id="contm.bind"></a>4.2.6.1 Bindings
                  </h4>
                  <table class="syntax">
                     <thead>
                        <tr>
                           <th></th>
                           <th>Schema Fragment (Strict)</th>
                           <th>Schema Fragment (Full)</th>
                        </tr>
                     </thead>
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.bind">Bind</a></td>
                           <td><a href="chapter4-d.html#contm.bind">Bind</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a></td>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>
                              <a href="appendixa-d.html#parsing_ContExp">ContExp</a>,
                              <a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>*,
                              <a href="appendixa-d.html#parsing_ContExp">ContExp</a>
                              
                           </td>
                           <td>
                              <a href="appendixa-d.html#parsing_ContExp">ContExp</a>, 
                              <a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>*, 
                              <a href="appendixa-d.html#parsing_Qualifier">Qualifier</a>*, 
                              <a href="appendixa-d.html#parsing_ContExp">ContExp</a>+
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>Binding expressions are represented as MathML expression trees using the <code>bind</code>
                     element. Its first child is a MathML expression that represents a binding operator, for
                     example integral operator. This is followed by a non-empty list of <code>bvar</code>
                     elements denoting the bound variables, and then the final child which is a general
                     Content MathML expression, known as the <em>body</em> of the binding.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.bvar" id="contm.bvar"></a>4.2.6.2 Bound Variables
                  </h4>
                  <table class="syntax">
                     <thead>
                        <tr>
                           <th></th>
                           <th>Schema Fragment (Strict)</th>
                           <th>Schema Fragment (Full)</th>
                        </tr>
                     </thead>
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.bvar">BVar</a></td>
                           <td><a href="chapter4-d.html#contm.bvar">BVar</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a></td>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ci">ci</a> | <a href="appendixa-d.html#parsing_semantics-ci">semantics-ci</a></td>
                           <td>
                              (<a href="appendixa-d.html#parsing_ci">ci</a> | <a href="appendixa-d.html#parsing_semantics-ci">semantics-ci</a>), <a href="appendixa-d.html#parsing_degree">degree</a>? | 
                              <a href="appendixa-d.html#parsing_degree">degree</a>?, (<a href="appendixa-d.html#parsing_ci">ci</a> | <a href="appendixa-d.html#parsing_semantics-ci">semantics-ci</a>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>bvar</code> element is used to denote the bound variable of a binding
                     expression, e.g. in sums, products, and quantifiers or user defined functions.
                  </p>
                  <p>The content of a <code>bvar</code> element is an <em>annotated variable</em>,
                     i.e. either a content identifier represented by a <code>ci</code> element or a
                     <code>semantics</code> element whose first child is an annotated variable. The
                     <em>name</em> of an annotated variable of the second kind is the name of its first
                     child. The <em>name</em> of a bound variable is that of the annotated variable
                     in the <code>bvar</code> element.
                  </p>
                  <p>Bound variables are identified by comparing their names. Such
                     identification can be made explicit by placing an <code>id</code> on the <code>ci</code>
                     element in the <code>bvar</code> element and referring to it using the <code>xref</code>
                     attribute on all other instances.  An example of this approach is
                     
                     
                  </p><pre class="mathml">
&lt;bind&gt;&lt;csymbol cd="quant1"&gt;forall&lt;/csymbol&gt;
  &lt;bvar&gt;&lt;ci id="var-x"&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;csymbol cd="relation1"&gt;lt&lt;/csymbol&gt;
    &lt;ci xref="var-x"&gt;x&lt;/ci&gt;
    &lt;cn&gt;1&lt;/cn&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>
                     
                     This <code>id</code> based approach is especially helpful when constructions
                     involving bound variables are nested.
                  </p>
                  <p>It is sometimes necessary to associate additional
                     information with a bound variable.  The information might be
                     something like a detailed mathematical type, an alternative
                     presentation or encoding or a domain of application.  Such
                     associations are accomplished in the standard way by replacing
                     a <code>ci</code> element (even inside the <code>bvar</code> element)
                     by a <code>semantics</code> element containing both the <code>ci</code>
                     and the additional information.  Recognition of an instance of
                     the bound variable is still based on the actual <code>ci</code>
                     elements and not the <code>semantics</code> elements or anything
                     else they may contain.  The <code>id</code> based-approach
                     outlined above may still be used.
                  </p>
                  <p>The following example encodes forall <var>x</var>. <var>x</var>+<var>y</var>=<var>y</var>+<var>x</var>.
                  </p><pre class="mathml">
&lt;bind&gt;&lt;csymbol cd="quant1"&gt;forall&lt;/csymbol&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;csymbol cd="relation1"&gt;eq&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>In non-Strict Content markup, the <code>bvar</code> element is used in
                     a number of idiomatic constructs.  These are described in <a href="chapter4-d.html#contm.qualifiers">Section&nbsp;4.3.3 Qualifiers</a> and <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.alpharenmaing" id="contm.alpharenmaing"></a>4.2.6.3 Renaming Bound Variables
                  </h4>
                  <p>It is a defining property of bound variables that they can be renamed
                     consistently in the scope of their parent <code>bind</code> element. This operation, sometimes known as <em>α-conversion</em>,
                     preserves the semantics of the expression.
                  </p>
                  <p>A bound variable <var>x</var> may be renamed to say <var>y</var> so long as <var>y</var> does not occur free in the body of the binding, or in any annotations of
                     the bound variable, <var>x</var> to be renamed, or later bound variables.
                  </p>
                  <p>If a bound variable <var>x</var> is renamed, all free occurrences of <var>x</var> in annotations in its <code>bvar</code> element, any following <code>bvar</code> children of the <code>bind</code> and in the expression in the body of the <code>bind</code> should be renamed.
                  </p>
                  <p> In the example in the previous section, note how renaming
                     <var>x</var> to <var>z</var> produces the equivalent expression forall
                     <var>z</var>. <var>z</var>+<var>y</var>=<var>y</var>+<var>z</var>,
                     whereas <var>x</var> may not be renamed to <var>y</var>, as
                     <var>y</var> is free in the body of the binding and would be
                     <em>captured</em>, producing the expression forall
                     <var>y</var>. <var>y</var>+<var>y</var>=<var>y</var>+<var>y</var>
                     which is not equivalent to the original expression.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rendering.binders" id="contm.rendering.binders"></a>4.2.6.4 Rendering Binding Constructions
                  </h4>
                  <p>If 
                     <code> <span class="egmeta">b</span> </code> and
                     <code> <span class="egmeta">s</span> </code> are Content MathML expressions
                     that render as the Presentation MathML expressions
                     <code> <span class="egmeta">B</span> </code> and
                     <code> <span class="egmeta">S</span> </code>
                     then the sample rendering of a binding element is as follows:
                  </p>
                  <div class="mathml-example" id="contm.bvar.render">
                     <p>Content MathML</p><pre class="mathml">
&lt;bind&gt; <span class="egmeta">b</span> 
  &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;
  &lt;bvar&gt; <span class="egmeta">...</span> &lt;/bvar&gt;
  &lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
   <span class="egmeta">s</span> 
&lt;/bind&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
  <span class="egmeta">B</span> 
 &lt;mrow&gt;
   <span class="egmeta">x1</span> 
  &lt;mo separator="true"&gt;,&lt;/mo&gt;
   <span class="egmeta">...</span> 
  &lt;mo separator="true"&gt;,&lt;/mo&gt;
   <span class="egmeta">xn</span> 
 &lt;/mrow&gt;
 &lt;mo separator="true"&gt;.&lt;/mo&gt;
  <span class="egmeta">S</span> 
&lt;/mrow&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.sharing" id="contm.sharing"></a>4.2.7 Structure Sharing <code>&lt;share&gt;</code></h3>
               <p>To conserve space in the XML encoding, MathML expression trees can make use of
                  structure sharing.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.share" id="contm.share"></a>4.2.7.1 The <code>share</code> element
                  </h4>
                  <table class="syntax">
                     <thead>
                        <tr>
                           <th></th>
                           <th colspan="2">Schema Fragment</th>
                        </tr>
                     </thead>
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td colspan="2"><a href="chapter4-d.html#contm.share">Share</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td colspan="2">
                              <a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>,
                              <a href="appendixa-d.html#parsing_src">src</a>
                              
                           </td>
                        </tr>
                        <tr>
                           <th><code>src</code> Attribute Values
                           </th>
                           <td><var>URI</var></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td colspan="2">Empty</td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>share</code> element has an <code>href</code> attribute used to
                     to reference a MathML expression tree. The value of the
                     <code>href</code> attribute is a URI specifying the <code>id</code>
                     attribute of the root node of the expression tree.  When building a  
                     MathML expression tree, the <code>share</code> element is equivalent to a copy of the MathML
                     expression tree referenced by the <code>href</code> attribute. Note that this copy is
                     <em>structurally equal</em>, but not identical to the element referenced. The
                     values of the <code>share</code> will often be relative URI references, in which case they
                     are resolved using the base URI of the document containing the <code>share</code> element.
                     
                  </p>
                  <p>For instance, the mathematical object <var>f(f(f(a,a),f(a,a)),f(f(a,a),f(a,a)))</var> can
                     be encoded as either one of the following representations (and some intermediate versions as well).
                     
                     
                  </p>
                  <table id="contm.share.table">
                     <tbody>
                        <tr>
                           <td>
                              <pre class="mathml">
&lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
    &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
    &lt;/apply&gt;
    &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/apply&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
    &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
    &lt;/apply&gt;
    &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre>
                              </td>
                           <td>
                              <pre class="mathml">
&lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
  &lt;apply id="t1"&gt;&lt;ci&gt;f&lt;/ci&gt;
    &lt;apply id="t11"&gt;&lt;ci&gt;f&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
      &lt;ci&gt;a&lt;/ci&gt;
    &lt;/apply&gt;
    &lt;share href="#t11"/&gt;



  &lt;/apply&gt;
  &lt;share href="#t1"/&gt;









&lt;/apply&gt;</pre>
                              </td>
                        </tr>
                     </tbody>
                  </table>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.acyclicity" id="contm.acyclicity"></a>4.2.7.2 An Acyclicity Constraint
                  </h4>
                  <p>Say that an element <em>dominates</em> all its children and all
                     elements they dominate. Say also that a
                     <code>share</code> element dominates its target, i.e. the element that carries the
                     <code>id</code> attribute pointed to by the <code>href</code> attribute. For instance in the
                     representation on the right above, the <code>apply</code> element with <code>id="t1"</code> and also the
                     second <code>share</code> (with <code>href="t11"</code>) both dominate the
                     <code>apply</code> element with <code>id="t11"</code>.
                  </p>
                  <p>The occurrences of the <code>share</code> element must obey the following global
                     <em>acyclicity constraint</em>: An element may not dominate itself. For example, the
                     following representation violates this constraint:
                     
                     
                  </p><pre class="error">
&lt;apply id="badid1"&gt;&lt;csymbol cd="arith1"&gt;divide&lt;/csymbol&gt;
  &lt;cn&gt;1&lt;/cn&gt;
  &lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
    &lt;cn&gt;1&lt;/cn&gt;
    &lt;share href="#badid1"/&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Here, the <code>apply</code> element with <code>id="badid1"</code> dominates its third child,
                     which dominates the <code>share</code> element, which dominates its target: the element with
                     <code>id="badid1"</code>. So by transitivity, this element dominates itself. By the
                     acyclicity constraint, the example is not a valid MathML expression tree. It
                     might be argued that such an expression could be given the interpretation of the continued fraction
                     <img src="image/contfrac1.gif" alt="  \frac{1}{1 + \frac{1}{1 + \frac{1}{1 + \ldots}}}" align="middle">.
                     However, the procedure of building an expression tree by replacing
                     <code>share</code> element does not terminate for such an
                     expression, and hence such expressions are not allowed by Content MathML.
                  </p>
                  <p>Note that the acyclicity constraints is not restricted to such simple cases, as the following
                     example shows:
                     
                     
                  </p><pre class="error">
&lt;apply id="bar"&gt;                        &lt;apply id="baz"&gt;
  &lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;     &lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
  &lt;cn&gt;1&lt;/cn&gt;                              &lt;cn&gt;1&lt;/cn&gt;
  &lt;share href="#baz"/&gt;                    &lt;share href="#bar"/&gt;
&lt;/apply&gt;                                &lt;/apply&gt;</pre><p>
                     
                     Here, the <code>apply</code> with <code>id="bar"</code> dominates its third child, the
                     <code>share</code> with <code>href="#baz"</code>.  That element dominates its target <code>apply</code>
                     (with <code>id="baz"</code>), which in turn dominates its third child, the <code>share</code>
                     with <code>href="#bar"</code>. Finally, the <code>share</code> with
                     <code>href="#bar"</code> dominates its target, the original 
                     <code>apply</code> element with <code>id="bar"</code>. So this pair of representations
                     ultimately violates the acyclicity constraint.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.share.binding" id="contm.share.binding"></a>4.2.7.3 Structure Sharing and Binding
                  </h4>
                  <p>Note that the <code>share</code> element is a <em>syntactic</em> referencing mechanism:
                     a <code>share</code> element stands for the exact element it points to. In particular,
                     referencing does not interact with binding in a semantically intuitive way, since it
                     allows a phenomenon called <em>variable capture</em> to
                     occur. Consider an example:
                     
                     
                  </p><pre class="mathml">
&lt;bind id="outer"&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;
    &lt;bind id="inner"&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
      &lt;share id="copy" href="#orig"/&gt;
    &lt;/bind&gt;
    &lt;apply id="orig"&gt;&lt;ci&gt;g&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>
                     
                     This represents a term
                     <img src="image/lamshare1.gif" alt="\lambda{x}.f(\lambda{x}.g(x),g(x))" align="middle">
                     which has two sub-terms of the form
                     <img src="image/lamshare2.gif" alt="g(x)" align="middle">,
                     one with <code>id="orig"</code>
                     (the one explicitly represented) and one with <code>id="copy"</code>,
                     represented by the <code>share</code> element.
                     In the original, explicitly-represented term,
                     the variable <var>x</var> is bound by the 
                     <em>outer</em> <code>bind</code> element.
                     However, in the copy, the variable <var>x</var> is
                     bound by the <em>inner</em> <code>bind</code> element.
                     One says that the inner <code>bind</code>
                     has captured the variable <var>x</var>.
                  </p>
                  <p>Using references that capture variables in this way can easily lead to representation
                     errors, and is not recommended.  For instance, using
                     α-conversion to rename the inner occurrence of <var>x</var>
                     into, say, <var>y</var> leads to the semantically equivalent expression
                     <img src="image/lamshare3.gif" alt="\lambda{x}.f(\lambda{y}.g(y),g(x))" align="middle">.  
                     However, in this form, it is no longer possible to share the expression
                     <img src="image/lamshare2.gif" alt="g(x)" align="middle">.
                     Replacing <var>x</var> with <var>y</var> in the inner
                     <code>bvar</code> without replacing the <code>share</code> element results in a change
                     in semantics.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rendering.share" id="contm.rendering.share"></a>4.2.7.4 Rendering Expressions with Structure Sharing
                  </h4>
                  <p>There are several acceptable renderings for the <code>share</code> element.  These include rendering the element
                     as a hypertext link to the referenced element and using the rendering of the element referenced by the
                     <code>href</code> attribute.
                  </p>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.semantics" id="contm.semantics"></a>4.2.8 Attribution via <code>semantics</code></h3>
               <p>Content elements can be annotated with additional information via the
                  <code>semantics</code> element. MathML uses the
                  <code>semantics</code> element to wrap the annotated element and the
                  <code>annotation-xml</code> and <code>annotation</code> elements used for representing the
                  annotations themselves. The use of the <code>semantics</code>, <code>annotation</code> and
                  <code>annotation-xml</code> is described in detail <a href="chapter5-d.html">Chapter&nbsp;5 Mixing Markup Languages for Mathematical Expressions</a>.
               </p>
               <p>The <code>semantics</code> element is be considered part of both
                  presentation MathML and Content MathML. MathML considers a <code>semantics</code> element
                  (strict) Content MathML, if and only if its first child is (strict) Content MathML.
               </p>
            </div>
            <div class="div3">
               
               <h3><a name="contm.cerror" id="contm.cerror"></a>4.2.9 Error Markup <code>&lt;cerror&gt;</code></h3>
               <table class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th>Schema Fragment (Strict)</th>
                        <th>Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td><a href="chapter4-d.html#contm.cerror">Error</a></td>
                        <td><a href="chapter4-d.html#contm.cerror">Error</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a></td>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td>
                           <a href="appendixa-d.html#parsing_csymbol">csymbol</a>, <a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           
                        </td>
                        <td>
                           <a href="appendixa-d.html#parsing_csymbol">csymbol</a>, <a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           
                        </td>
                     </tr>
                  </tbody>
               </table>
               <p>A content error expression is made up of a <code>csymbol</code>
                  followed by a sequence of zero or more MathML expressions. The
                  initial expression must be a <code>csymbol</code> indicating the kind of
                  error. Subsequent children, if present, indicate the context in
                  which the error occurred.
               </p>
               <p>The <code>cerror</code> element has no direct mathematical meaning.
                  Errors occur as the result of some action performed on an expression
                  tree and are thus of real interest only when some sort of
                  communication is taking place. Errors may occur inside other objects
                  and also inside other errors.
               </p>
               <p>As an example, to encode a division by zero error, one might
                  employ a hypothetical <code>aritherror</code> Content Dictionary
                  containing a <code>DivisionByZero</code> symbol, as in the following
                  expression:
                  
                  
               </p><pre class="mathml">
&lt;cerror&gt;
  &lt;csymbol cd="aritherror"&gt;DivisionByZero&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="arith1"&gt;divide&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
&lt;/cerror&gt;</pre><p>
                  
                  Note that error markup generally should enclose only the smallest
                  erroneous sub-expression.  Thus a <code>cerror</code> will often be a sub-expression of
                  a bigger one, e.g.
                  
                  
               </p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="relation1"&gt;eq&lt;/csymbol&gt;
  &lt;cerror&gt;
    &lt;csymbol cd="aritherror"&gt;DivisionByZero&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;divide&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;/cerror&gt;
  &lt;cn&gt;0&lt;/cn&gt;
&lt;/apply&gt;</pre><p>The default presentation of a <code>cerror</code> element is an
                  <code>merror</code> expression whose first child is a presentation of the
                  error symbol, and whose subsequent children are the default
                  presentations of the remaining children of the <code>cerror</code>. In
                  particular, if one of the remaining children of the <code>cerror</code> is
                  a presentation MathML expression, it is used literally in the
                  corresponding <code>merror</code>.
               </p>
               <div class="mathml-example" id="contm.cerror.ex"><pre class="mathml">
&lt;cerror&gt;
  &lt;csymbol cd="aritherror"&gt;DivisionByZero&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="arith1"&gt;divide&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
&lt;/cerror&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;merror&gt;
  &lt;mtext&gt;DivisionByZero:&amp;#160;&lt;/mtext&gt;
  &lt;mfrac&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mfrac&gt;
&lt;/merror&gt;</pre><blockquote>
                     <p><img src="image/cerror-ex.gif" alt="\hbox{DivisionByZero: } \frac{x}{0}"></p>
                  </blockquote>
               </div>
               <p>Note that when the context where an error occurs is so nonsensical
                  that its default presentation would not be useful, an application may
                  provide an alternative representation of the error context.  For
                  example:
                  
                  
               </p><pre class="mathml">
&lt;cerror&gt;
  &lt;csymbol cd="error"&gt;Illegal bound variable&lt;/csymbol&gt;
  &lt;cs&gt; &amp;lt;bvar&amp;gt;&amp;lt;plus/&amp;gt;&amp;lt;/bvar&amp;gt; &lt;/cs&gt;
&lt;/cerror&gt;</pre></div>
            <div class="div3">
               
               <h3><a name="contm.cbytes" id="contm.cbytes"></a>4.2.10 Encoded Bytes <code>&lt;cbytes&gt;</code></h3>
               <table class="syntax">
                  <thead>
                     <tr>
                        <th></th>
                        <th>Schema Fragment (Strict)</th>
                        <th>Schema Fragment (Full)</th>
                     </tr>
                  </thead>
                  <tbody>
                     <tr>
                        <th>Class</th>
                        <td><a href="chapter4-d.html#contm.cbytes">Cbytes</a></td>
                        <td><a href="chapter4-d.html#contm.cbytes">Cbytes</a></td>
                     </tr>
                     <tr>
                        <th>Attributes</th>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a></td>
                        <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                     </tr>
                     <tr>
                        <th>Content</th>
                        <td><a href="appendixa-d.html#parsing_base64">base64</a></td>
                        <td><a href="appendixa-d.html#parsing_base64">base64</a></td>
                     </tr>
                  </tbody>
               </table>
               <p>The content of <code>cbytes</code> represents a stream of bytes as a
                  sequence of characters in Base64 encoding, that is it matches the
                  base64Binary data type defined in <a href="appendixh-d.html#XMLSchemaDatatypes">[XMLSchemaDatatypes]</a>. All white space is ignored.
               </p>
               <p>The <code>cbytes</code> element is mainly used for OpenMath
                  compatibility, but may be used, as in OpenMath, to encapsulate output
                  from a system that may be hard to encode in MathML, such as binary
                  data relating to the internal state of a system, or image data.
               </p>
               <p>The rendering of <code>cbytes</code> is not expected to represent the
                  content and the proposed rendering is that of an empty
                  <code>mrow</code>. Typically <code>cbytes</code> is used in an
                  <code>annotation-xml</code> or is itself annotated with Presentation
                  MathML, so this default rendering should rarely be used.
               </p>
            </div>
         </div>
         <div class="div2">
            
            <h2><a name="contm.structure.extended" id="contm.structure.extended"></a>4.3 Content MathML for Specific Structures
            </h2>
            <p>The elements of Strict Content MathML described in
               <a href="chapter4-d.html#contm.core">the previous section</a> are sufficient to
               encode logical assertions and expression structure, and they do so
               in a way that closely models the standard constructions of
               mathematical logic that underlie the foundations of mathematics. As a
               consequence, Strict markup can be used to represent all of
               mathematics, and is ideal for providing consistent mathematical
               semantics for all Content MathML expressions.
               
            </p>
            <p>At the same time, many notational idioms of mathematics are not
               straightforward to represent directly with Strict Content markup.
               For example, standard notations for sums, integrals, sets, piecewise
               functions and many other common constructions require non-obvious
               technical devices, such as the introduction of lambda functions, to
               rigorously encode them using Strict markup. Consequently, in order
               to make Content MathML easier to use, a range of additional elements
               have been provided for encoding such idiomatic constructs more
               directly. This section discusses the general approach for encoding
               such idiomatic constructs, and their Strict Content equivalents.
               Specific constructions are discussed in detail in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>.
            </p>
            <p>Most idiomatic constructions which Content markup addresses fall
               into about a dozen classes.  Some of these classes, such as <a href="chapter4-d.html#contm.container"><em>container elements</em></a>, have
               their own syntax. Similarly, a small number of non-Strict
               constructions involve a single element with an exceptional syntax,
               for example <code>partialdiff</code>. These exceptional elements are
               discussed on a case-by-case basis in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. However, the majority of constructs consist of
               classes of operator elements which all share a particular usage of
               <a href="chapter4-d.html#contm.qualifiers"><em>qualifiers</em></a>.
               These classes of operators are described in <a href="chapter4-d.html#contm.opclasses">Section&nbsp;4.3.4 Operator Classes</a>.
            </p>
            <p>In all cases, non-Strict expressions may be rewritten using only
               Strict markup.  In most cases, the transformation is completely
               algorithmic, and may be automated. Rewrite rules for classes of
               non-Strict constructions are introduced and discussed later in this
               section, and rewrite rules for exceptional constructs involving a
               single operator are given in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. The
               complete algorithm for rewriting arbitrary Content MathML as Strict
               Content markup is summarized at the end of the Chapter in <a href="chapter4-d.html#contm.p2s">Section&nbsp;4.6 The Strict Content MathML Transformation</a>.
               
            </p>
            <div class="div3">
               
               <h3><a name="contm.container" id="contm.container"></a>4.3.1 Container Markup
               </h3>
               <p>Many mathematical structures are constructed from subparts or
                  parameters. The motivating example is a set. Informally, one
                  thinks of a set as a certain kind of mathematical object that
                  contains a collection of elements. Thus, it is intuitively natural
                  for the markup for a set to contain, in the XML sense, the markup
                  for its constituent elements. The markup may define the set
                  elements explicitly by enumerating them, or implicitly by rule,
                  using qualifier elements. However, in either case, the markup for
                  the elements is contained in the markup for the set, and
                  consequently this style of representation is termed
                  <em>container markup</em> in MathML. By contrast, Strict
                  markup represents an instance of a set as the result of applying a
                  function or <em>constructor symbol</em> to arguments.  In this
                  style of markup, the markup for the set construction is a sibling
                  of the markup for the set elements in an enclosing <code>apply</code>
                  element.
               </p>
               <p>While the two approaches are formally equivalent, container
                  markup is generally more intuitive for non-expert authors to use, while
                  Strict markup is preferable is contexts where semantic rigor is
                  paramount.  In addition, MathML 2 relied on container markup, and
                  thus container markup is necessary in cases where backward
                  compatibility is required.
               </p>
               <p>MathML provides container markup for the following mathematical
                  constructs: sets, lists, intervals, vectors, matrices (two
                  elements), piecewise functions (three elements) and lambda
                  functions.  There are corresponding constructor symbols in Strict
                  markup for each of these, with the exception of lambda functions,
                  which correspond to binding symbols in Strict markup. Note that in
                  MathML 2, the term "container markup" was also taken to include
                  token elements, and the deprecated <code>declare</code>, <code>fn</code>
                  and <code>reln</code> elements, but MathML 3 limits usage of the term
                  to the above constructs.
               </p>
               <p>The rewrite rules for obtaining equivalent Strict Content
                  markup from container markup depend on the <a href="chapter4-d.html#contm.opclasses">operator class</a> of the particular
                  operator involved.  For details about a specific container
                  element, obtain its operator class (and any applicable special
                  case information) by consulting the syntax table and discussion
                  for that element in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. Then apply the
                  rewrite rules for that specific operator class as described in
                  <a href="chapter4-d.html#contm.opclasses">Section&nbsp;4.3.4 Operator Classes</a>.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.container.constructor" id="contm.container.constructor"></a>4.3.1.1 Container Markup for Constructor Symbols
                  </h4>
                  <p>The arguments to container elements corresponding to
                     constructors may either be explicitly given as a sequence of child
                     elements, or they may be specified by a rule using qualifiers. The
                     only exceptions are the <code>piecewise</code>, <code>piece</code>, and
                     <code>otherwise</code> elements used for representing functions with
                     <a href="chapter4-d.html#contm.piecewise">piecewise</a> definitions.  The
                     arguments of these elements must always be specified
                     explicitly.
                  </p>
                  <div class="strict-mathml-example" id="contm.strict-set">
                     <p>Here is an example of container markup with explicitly specified arguments:
                        
                        
                     </p><pre class="mathml">&lt;set&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;ci&gt;c&lt;/ci&gt;&lt;/set&gt;</pre><p>
                        
                        This is equivalent to the following Strict Content MathML expression:
                        
                        
                     </p><pre class="strict-mathml">&lt;apply&gt;&lt;csymbol cd="set1"&gt;set&lt;/csymbol&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;ci&gt;c&lt;/ci&gt;&lt;/apply&gt;</pre></div>
                  <div class="strict-mathml-example" id="contm.strict-set-bvar">
                     <p>Another example of container markup, where the list of arguments is
                        given indirectly as an expression with a bound variable. The container markup
                        for the set of even integers is:
                        
                        
                     </p><pre class="mathml">
&lt;set&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt; 
  &lt;domainofapplication&gt;&lt;integers/&gt;&lt;/domainofapplication&gt;
  &lt;apply&gt;&lt;times/&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/set&gt;</pre><p>
                        
                        This may be written as follows in Strict Content MathML:
                        
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="set1"&gt;map&lt;/csymbol&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;times&lt;/csymbol&gt;
      &lt;cn&gt;2&lt;/cn&gt;
      &lt;ci&gt;x&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/bind&gt;
  &lt;csymbol cd="setname1"&gt;Z&lt;/csymbol&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.lambda.container" id="contm.lambda.container"></a>4.3.1.2 Container Markup for Binding Constructors
                  </h4>
                  <p>The <code>lambda</code> element is a container element
                     corresponding to the <a href="http://www.openmath.org/cd/fns1.xhtml#lambda">lambda</a> symbol
                     in the <a href="http://www.openmath.org/cd/fns1.xhtml">fns1</a> Content Dictionary.  However, unlike the
                     container elements of the preceding section, which purely
                     construct mathematical objects from arguments, the <code>lambda</code>
                     element performs variable binding as well.  Therefore, the child
                     elements of <code>lambda</code> have distinguished roles.  In
                     particular, a <code>lambda</code> element must have at least one
                     <code>bvar</code> child, optionally followed by <a href="chapter4-d.html#contm.qualifiers">qualifier elements</a>, followed by a
                     Content MathML element. This basic difference between the
                     <code>lambda</code> container and the other constructor container
                     elements is also reflected in the OpenMath symbols to which they
                     correspond.  The constructor symbols have an OpenMath role of
                     "application", while the lambda symbol has a role of "bind".
                  </p>
                  <div class="strict-mathml-example" id="contm.strict-lambda">
                     <p>This example shows the use of <code>lambda</code> container element and the equivalent use of <code>bind</code> in Strict Content MathML
                     </p><pre class="mathml">&lt;lambda&gt;&lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/lambda&gt;</pre><pre class="strict-mathml">
&lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
 &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;&lt;ci&gt;x&lt;/ci&gt;
&lt;/bind&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.bind.apply" id="contm.bind.apply"></a>4.3.2 Bindings with <code>&lt;apply&gt;</code></h3>
               <p>MathML allows the use of the <code>apply</code> element to perform
                  variable binding in non-Strict constructions instead of
                  the <code>bind</code> element.  This usage conserves backwards
                  compatibility with MathML 2.  It also simplifies the encoding of
                  several constructs involving bound variables with qualifiers as
                  described <a href="chapter4-d.html#contm.qualifiers">below</a>.
               </p>
               <p>Use of the <code>apply</code> element to bind variables is allowed
                  in two situations.  First, when the operator to be applied is
                  itself a binding operator, the <code>apply</code> element merely
                  substitutes for the <code>bind</code> element.  The logical quantifiers
                  <code>&lt;forall/&gt;</code>, <code>&lt;exists/&gt;</code> and the
                  container element <code>lambda</code> are the primary examples of this
                  type.
               </p>
               <p>The second situation arises when the operator being applied
                  allows the use of bound variables with qualifiers.  The most
                  common examples are sums and integrals.  In most of these cases,
                  the variable binding is to some extent implicit in the notation,
                  and the equivalent Strict representation requires the introduction
                  of auxiliary constructs such as lambda expressions for formal
                  correctness.
               </p>
               <p>Because expressions using bound variables with qualifiers are
                  idiomatic in nature, and do not always involve true variable
                  binding, one cannot expect systematic renaming (alpha-conversion)
                  of variables "bound" with <code>apply</code> to preserve meaning in
                  all cases.  An example for this is the <code>diff</code> element where
                  the <code>bvar</code> term is technically not bound at all.
               </p>
               <div class="strict-mathml-example" id="contm.strict-apply-bvar">
                  <p>The following example illustrates the use of <code>apply</code>
                     with a binding operator.  In these cases, the corresponding Strict
                     equivalent merely replaces the <code>apply</code> element with a
                     <code>bind</code> element:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;forall/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;geq/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>
                     The equivalent Strict expression is:
                     
                  </p><pre class="strict-mathml">
&lt;bind&gt;&lt;csymbol cd="logic1"&gt;forall&lt;/csymbol&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;csymbol cd="relation1"&gt;geq&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/bind&gt;</pre></div>
               <div class="strict-mathml-example" id="contm.strict-apply-bvar-2">
                  <p>In this example, the sum operator is not itself a binding
                     operator, but bound variables with qualifiers are implicit in the
                     standard notation, which is reflected in the non-Strict markup.
                     In the equivalent Strict representation, it is necessary to
                     convert the summand into a lambda expression, and recast the
                     qualifiers as an argument expression:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;sum/&gt;
  &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;cn&gt;100&lt;/cn&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>
                     The equivalent Strict expression is: 
                     
                  </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;sum&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="interval1"&gt;integer_interval&lt;/csymbol&gt;
    &lt;cn&gt;0&lt;/cn&gt;
    &lt;cn&gt;100&lt;/cn&gt;
  &lt;/apply&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;power&lt;/csymbol&gt;
      &lt;ci&gt;x&lt;/ci&gt;
      &lt;ci&gt;i&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/bind&gt;
&lt;/apply&gt;</pre></div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.qualifiers" id="contm.qualifiers"></a>4.3.3 Qualifiers
               </h3>
               <p>Many common mathematical constructs involve an operator
                  together with some additional data.  The additional data is either
                  implicit in conventional notation, such as a bound variable, or
                  thought of as part of the operator, as is the case with the limits
                  of a definite integral.  MathML 3 uses <em>qualifier</em>
                  elements to represent the additional data in such cases.
               </p>
               <p>Qualifier elements are always used in conjunction with operator or container
                  elements.  Their meaning is idiomatic, and depends on the context in which they are
                  used.  When used with an operator, qualifiers always follow the operator and precede
                  any arguments that are present. In all cases, if more than one qualifier is present,
                  they appear in the order <code>bvar</code>, <code>lowlimit</code>, <code>uplimit</code>,
                  <code>interval</code>, <code>condition</code>, <code>domainofapplication</code>, <code>degree</code>,
                  <code>momentabout</code>, <code>logbase</code>.
               </p>
               <p>The precise function of qualifier elements depends on the
                  operator or container that they modify.  The majority of use cases
                  fall into one of several categories, discussed below, and usage
                  notes for specific operators and qualifiers are given in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.domainofapplication.qualifier" id="contm.domainofapplication.qualifier"></a>4.3.3.1 Uses of 
                     <code>&lt;domainofapplication&gt;</code>,
                     <code>&lt;interval&gt;</code>,
                     <code>&lt;condition&gt;</code>,
                     <code>&lt;lowlimit&gt;</code> and
                     <code>&lt;uplimit&gt;</code></h4>
                  <p>The primary use of <code>domainofapplication</code>, <code>interval</code>,
                     <code>uplimit</code>, <code>lowlimit</code> and <code>condition</code> is to
                     restrict the values of a bound variable.  The most general qualifier
                     is <code>domainofapplication</code>. It is used to specify a set (perhaps
                     with additional structure, such as an ordering or metric) over which
                     an operation is to take place. The <code>interval</code> qualifier, and
                     the pair <code>lowlimit</code> and <code>uplimit</code> also restrict a bound
                     variable to a set in the special case where the set is an
                     interval. The <code>condition</code> qualifier, like
                     <code>domainofapplication</code>, is general, and can be used to restrict
                     bound variables to arbitrary sets.  However, unlike the other
                     qualifiers, it restricts the bound variable by specifying a
                     Boolean-valued function of the bound variable.  Thus,
                     <code>condition</code> qualifiers always contain instances of the bound
                     variable, and thus require a preceding <code>bvar</code>, while the other
                     qualifiers do not.  The other qualifiers may even be used when no
                     variables are being bound, e.g. to indicate the restriction of a
                     function to a subdomain.
                  </p>
                  <p>In most cases, any of the qualifiers capable of representing the
                     domain of interest can be used interchangeably. The most general
                     qualifier is <code>domainofapplication</code>, and therefore has a
                     privileged role. It is the preferred form, unless there are
                     particular idiomatic reasons to use one of the other qualifiers,
                     e.g. limits for an integral.  In MathML 3, the other forms are treated
                     as shorthand notations for <code>domainofapplication</code> because they
                     may all be rewritten as equivalent <code>domainofapplication</code>
                     constructions.  The rewrite rules to do this are given below. The other
                     qualifier elements are provided because they correspond to common
                     notations and map more easily to familiar presentations.  Therefore,
                     in the situations where they naturally arise, they may be more
                     convenient and direct than <code>domainofapplication</code>.
                  </p>
                  <p>To illustrate these ideas, consider the following examples showing alternative
                     representations of a definite integral.  Let <var>C</var> denote the interval from 0 to 1,
                     and <var>f</var>(<var>x</var>) = <var>x</var><sup>2</sup>. Then
                     <code>domainofapplication</code> could be used express the integral of a
                     function <var>f</var> over
                     <var>C</var> in this way:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;domainofapplication&gt;
    &lt;ci type="set"&gt;C&lt;/ci&gt;
  &lt;/domainofapplication&gt;
  &lt;ci type="function"&gt;f&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Note that no explicit bound variable is identified in this
                     encoding, and the integrand is a function. Alternatively, the
                     <code>interval</code> qualifier could be used with an explicit bound variable:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;interval&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/interval&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>The pair <code>lowlimit</code> and <code>uplimit</code> can also be used.
                     This is perhaps the most "standard" representation of this integral:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Finally, here is the same integral, represented using
                     a <code>condition</code> on the bound variable:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;and/&gt;
      &lt;apply&gt;&lt;leq/&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;leq/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>
                     
                     Note the use of the explicit bound variable within the
                     <code>condition</code> term. Note also that when a bound
                     variable is used, the integrand is an expression in the bound
                     variable, not a function.
                  </p>
                  <p>The general technique of using a <code>condition</code> element
                     together with <code>domainofapplication</code> is quite powerful.  For
                     example, to extend the previous example to a multivariate domain, one
                     may use an extra bound variable and a domain of application
                     corresponding to a cartesian product:
                     
                     
                  </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;domainofapplication&gt;
    &lt;set&gt;
      &lt;bvar&gt;&lt;ci&gt;t&lt;/ci&gt;&lt;/bvar&gt;
      &lt;bvar&gt;&lt;ci&gt;u&lt;/ci&gt;&lt;/bvar&gt;
      &lt;condition&gt;
        &lt;apply&gt;&lt;and/&gt;
          &lt;apply&gt;&lt;leq/&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;t&lt;/ci&gt;&lt;/apply&gt;
          &lt;apply&gt;&lt;leq/&gt;&lt;ci&gt;t&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
          &lt;apply&gt;&lt;leq/&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;u&lt;/ci&gt;&lt;/apply&gt;
          &lt;apply&gt;&lt;leq/&gt;&lt;ci&gt;u&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
        &lt;/apply&gt;
      &lt;/condition&gt;
      &lt;list&gt;&lt;ci&gt;t&lt;/ci&gt;&lt;ci&gt;u&lt;/ci&gt;&lt;/list&gt;
    &lt;/set&gt;
  &lt;/domainofapplication&gt;
  &lt;apply&gt;&lt;times/&gt;
    &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Note that the order of the inner and outer bound variables is significant.</p>
                  <p><em>Mappings to Strict Content MathML</em></p>
                  <p>When rewriting expressions to Strict Content MathML, qualifier
                     elements are removed via a series of rules described in this section.
                     The general algorithm for rewriting a MathML expression involving
                     qualifiers proceeds in two steps.  First, constructs using the
                     <code>interval</code>, <code>condition</code>, <code>uplimit</code> and
                     <code>lowlimit</code> qualifiers are converted to constructs using only
                     <code>domainofapplication</code>. Second, <code>domainofapplication</code>
                     expressions are then rewritten as Strict Content markup.
                     
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.limits-strict" id="contm.limits-strict"></a>Rewrite: interval qualifier
                     </h5><pre class="mathml">
&lt;apply&gt; <span class="egmeta">H</span> 
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;lowlimit&gt; <span class="egmeta">a</span> &lt;/lowlimit&gt;
  &lt;uplimit&gt; <span class="egmeta">b</span> &lt;/uplimit&gt;
   <span class="egmeta">C</span> 
&lt;/apply&gt;</pre><pre class="strict-mathml">
&lt;apply&gt; <span class="egmeta">H</span> 
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt;
    &lt;apply&gt;&lt;csymbol cd="interval1"&gt;<span class="egmeta">interval</span>&lt;/csymbol&gt;
       <span class="egmeta">a</span> 
       <span class="egmeta">b</span> 
    &lt;/apply&gt;
  &lt;/domainofapplication&gt;
   <span class="egmeta">C</span> 
&lt;/apply&gt;</pre><p>The symbol used in this translation depends on the head of the
                        application, denoted by <code> <span class="egmeta">H</span> </code>
                        here. By default <a href="http://www.openmath.org/cd/interval1.xhtml#interval">interval</a> should be
                        used, unless the semantics of the head term can be determined and
                        indicate a more specific interval symbols.  In particular, several
                        predefined Content MathML element should be used with more specific
                        interval symbols.  If the head is <code>int</code> then <a href="http://www.openmath.org/cd/interval1.xhtml#oriented_interval">oriented_interval</a> is used.  When the head term
                        is <code>sum</code> or <code>product</code>, <a href="http://www.openmath.org/cd/interval1.xhtml#integer_interval">integer_interval</a> should be used.
                     </p>
                     <p>The above technique for replacing <code>lowlimit</code> and <code>uplimit</code> qualifiers
                        with a <code>domainofapplication</code> element is also used for replacing the
                        <code>interval</code> qualifier. 
                     </p>
                  </div>
                  <p>The <code>condition</code> qualifier restricts a bound variable by specifying a
                     Boolean-valued expression on a larger domain, specifying whether a given value is in the
                     restricted domain. The <code>condition</code> element contains a single child that represents
                     the truth condition. Compound conditions are formed by applying Boolean operators such as
                     <code>and</code> in the condition.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.condition-strict" id="contm.condition-strict"></a>Rewrite: condition
                     </h5>
                     <p>To rewrite an expression using the <code>condition</code>
                        qualifier as one using <code>domainofapplication</code>,
                        
                        
                     </p><pre class="mathml-fragment">
&lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;
&lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
&lt;condition&gt; <span class="egmeta">P</span> &lt;/condition&gt;</pre><p>
                        
                        is rewritten to
                        
                        
                     </p><pre class="mathml-fragment">
&lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;
&lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
&lt;domainofapplication&gt;
  &lt;apply&gt;&lt;csymbol cd="set1"&gt;suchthat&lt;/csymbol&gt;
     <span class="egmeta">R</span> 
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;
      &lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
       <span class="egmeta">P</span> 
    &lt;/bind&gt;
  &lt;/apply&gt;
&lt;/domainofapplication&gt;</pre><p>
                        If the <code>apply</code> has a <code>domainofapplication</code> (perhaps originally expressed as
                        <code>interval</code> or an <code>uplimit</code>/<code>lowlimit</code> pair) then that is used for
                        <code> <span class="egmeta">R</span> </code>. Otherwise <code> <span class="egmeta">R</span> </code> is a set determined by the <code>type</code> attribute
                        of the bound variable as specified in <a href="chapter4-d.html#contm.ci.extended">Section&nbsp;4.2.2.2 Non-Strict uses of <code>&lt;ci&gt;</code></a>, if that is
                        present. If the type is unspecified, the translation introduces an unspecified domain via
                        content identifier <code>&lt;ci&gt;R&lt;/ci&gt;</code>.
                     </p>
                  </div>
                  <p>By applying the rules above, expression using the
                     <code>interval</code>, <code>condition</code>, <code>uplimit</code> and
                     <code>lowlimit</code> can be rewritten using only
                     <code>domainofapplication</code>. Once a <code>domainofapplication</code> has
                     been obtained, the final mapping to Strict markup is accomplished
                     using the following rules:
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.strict-doa" id="contm.strict-doa"></a>Rewrite: restriction
                     </h5>
                     <p>An application of a function that is qualified by the
                        <code>domainofapplication</code> qualifier (expressed by an <code>apply</code> element without
                        bound variables) is converted to an application of a function term constructed with the
                        <a href="http://www.openmath.org/cd/fns1.xhtml#restriction">restriction</a> symbol.
                     </p><pre class="mathml">
&lt;apply&gt; <span class="egmeta">F</span> 
  &lt;domainofapplication&gt;
     <span class="egmeta">C</span> 
  &lt;/domainofapplication&gt;
   <span class="egmeta">a1</span> 
   <span class="egmeta">an</span> 
&lt;/apply&gt;</pre><p>may be written as:</p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="fns1"&gt;restriction&lt;/csymbol&gt;
     <span class="egmeta">F</span> 
     <span class="egmeta">C</span> 
  &lt;/apply&gt;
   <span class="egmeta">a1</span> 
   <span class="egmeta">an</span> 
&lt;/apply&gt;</pre></div>
                  <p>In general, an application involving bound variables and (possibly) <code>domainofapplication</code> is rewritten using the following rule, which makes the domain the first positional argument of the application, and uses
                     the lambda symbol to encode the variable bindings. Certain classes of operator have alternative rules, as described below.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.dombind-strict" id="contm.dombind-strict"></a>Rewrite: apply bvar domainofapplication
                     </h5>
                     <p>A content MathML expression with bound variables and 
                        <code>domainofapplication</code>
                        
                     </p><pre class="mathml-fragment">
&lt;apply&gt; <span class="egmeta">H</span> 
  &lt;bvar&gt; <span class="egmeta">v1</span> &lt;/bvar&gt;
  ...
  &lt;bvar&gt; <span class="egmeta">vn</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
     <span class="egmeta">A1</span> 
    ...
     <span class="egmeta">Am</span> 
&lt;/apply&gt;</pre><p>
                        is rewritten to 
                        
                     </p><pre class="mathml-fragment">
&lt;apply&gt; <span class="egmeta">H</span> 
   <span class="egmeta">D</span> 
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">v1</span> &lt;/bvar&gt;
    ...
    &lt;bvar&gt; <span class="egmeta">vn</span> &lt;/bvar&gt;
     <span class="egmeta">A1</span> 
  &lt;/bind&gt;
  ...
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">v1</span> &lt;/bvar&gt;
    ...
    &lt;bvar&gt; <span class="egmeta">vn</span> &lt;/bvar&gt;
     <span class="egmeta">Am</span> 
  &lt;/bind&gt;
&lt;/apply&gt;</pre><p>
                        If there is no <code>domainofapplication</code> qualifier the <code> <span class="egmeta">D</span> </code> child is
                        omitted.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.degree" id="contm.degree"></a>4.3.3.2 Uses of <code>&lt;degree&gt;</code></h4>
                  <p>The <code>degree</code> element is a qualifier used to specify the
                     "degree" or "order" of an operation.  MathML uses the
                     <code>degree</code> element in this way in three contexts: to specify the degree of a
                     root, a moment, and in various derivatives. Rather than introduce special elements for
                     each of these families, MathML provides a single general construct, the
                     <code>degree</code> element in all three cases.
                  </p>
                  <p>Note that the <code>degree</code> qualifier is not used to restrict a bound variable in
                     the same sense of the qualifiers discussed above.  Indeed, with roots and moments, no
                     bound variable is involved at all, either explicitly or implicitly. In the case of
                     differentiation, the <code>degree</code> element is used in conjunction with a
                     <code>bvar</code>, but even in these cases, the variable may not be genuinely bound.
                  </p>
                  <p>For the usage of <code>degree</code> with the <a href="chapter4-d.html#contm.root"><code>root</code></a> and <a href="chapter4-d.html#contm.moment"><code>moment</code></a> operators, see the discussion of those
                     operators below. The usage of <code>degree</code> in differentiation is more complex.  In
                     general, the <code>degree</code> element indicates the order of the derivative with
                     respect to that variable. The degree element is allowed as the second child of a
                     <code>bvar</code> element identifying a variable with respect to which the derivative is
                     being taken. Here is an example of a second derivative using the <code>degree</code>
                     qualifier:
                  </p><pre class="mathml">
&lt;apply&gt;&lt;diff/&gt;
  &lt;bvar&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;degree&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/degree&gt;
  &lt;/bvar&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>For details see <a href="chapter4-d.html#contm.diff">Section&nbsp;4.4.4.2 Differentiation <code>&lt;diff/&gt;</code></a> and <a href="chapter4-d.html#contm.partialdiff">Section&nbsp;4.4.4.3 Partial Differentiation <code>&lt;partialdiff/&gt;</code></a>.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.otherqualifiers" id="contm.otherqualifiers"></a>4.3.3.3 Uses of <code>&lt;momentabout&gt;</code> and <code>&lt;logbase&gt;</code></h4>
                  <p>The qualifiers <code>momentabout</code> and <code>logbase</code> are
                     specialized elements specifically for use with the <a href="chapter4-d.html#contm.moment"><code>moment</code></a>
                     and <a href="chapter4-d.html#contm.log"><code>log</code></a> operators
                     respectively.  See the descriptions of those operators below for their usage.
                  </p>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.opclasses" id="contm.opclasses"></a>4.3.4 Operator Classes
               </h3>
               <p>The Content MathML elements described in detail in the next section
                  may be broadly separated into <em>classes</em>. The class of each
                  element is shown in the syntax table that introduces the element in
                  <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. The class gives an indication of the
                  general intended mathematical usage of the element, and also
                  determines its usage as determined by the schema.  The class also
                  determines the applicable rewrite rules for mapping to Strict Content
                  MathML.  This section presents the rewrite rules for each of the
                  operator classes.
               </p>
               <p>The rules in this section cover the use cases applicable to
                  specific operator classes.  Special-case rewrite rules for individual
                  elements are discussed in the sections below.  However, the most
                  common usage pattern is generic, and is used by operators from almost all
                  operator classes. It consists of applying an operator to an explicit list
                  of arguments using an <code>apply</code> element.  In these cases,
                  rewriting to Strict Content MathML is simply a matter of replacing the
                  empty element with an appropriate <code>csymbol</code>, as listed in the
                  syntax tables in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>.  This is summarized in
                  the following rule.
               </p>
               <div class="strict-mathml-example">
                  
                  <h5><a name="contm.strict-opel" id="contm.strict-opel"></a>Rewrite: element
                  </h5>
                  <p>  For example,</p><pre class="mathml"><span class="egmeta">&lt;plus/&gt;</span></pre><p>is equivalent to the Strict form 
                     
                  </p><pre class="strict-mathml">&lt;csymbol cd="<span class="egmeta">arith1</span>"&gt;<span class="egmeta">plus</span>&lt;/csymbol&gt;</pre></div>
               <p>In MathML 2, the <code>definitionURL</code> attribute could be
                  used to redefine or modify the meaning of an operator element. When the <code>definitionURL</code> 
                  attribute is present, the value for the <code>cd</code> attribute on the <code>csymbol</code> should be 
                  determined by the <code>definitionURL</code> value if possible. The correspondence between <code>cd</code> and <code>definitionURL</code> values is described <a href="chapter4-d.html#contm.csymbol.extended">Section&nbsp;4.2.3.2 Non-Strict uses of <code>&lt;csymbol&gt;</code></a>.
               </p>
               <div class="div4">
                  
                  <h4><a name="contm.nary" id="contm.nary"></a>4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                     nary-linalg, nary-set, nary-constructor)
                  </h4>
                  <p>Many MathML operators may be used with an arbitrary number of
                     arguments. The corresponding OpenMath symbols for elements in these classes
                     also take an arbitrary number of arguments.
                     In all such cases, either the arguments my be given
                     explicitly as children of the <code>apply</code> or <code>bind</code> element, or
                     the list may be specified implicitly via the use of qualifier
                     elements.
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.nary.schema" id="contm.nary.schema"></a>4.3.4.1.1 Schema Patterns
                     </h5>
                     <p>The elements representing these n-ary operators are
                        specified in the following schema patterns in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>:
                        <a href="appendixa-d.html#parsing_nary-arith.class">nary-arith.class</a>, <a href="appendixa-d.html#parsing_nary-functional.class">nary-functional.class</a>, <a href="appendixa-d.html#parsing_nary-logical.class">nary-logical.class</a>,
                        <a href="appendixa-d.html#parsing_nary-linalg.class">nary-linalg.class</a>, <a href="appendixa-d.html#parsing_nary-set.class">nary-set.class</a>, <a href="appendixa-d.html#parsing_nary-constructor.class">nary-constructor.class</a>.
                     </p>
                  </div>
                  <div class="div5">
                     
                     <h5><a name="contm.nary.rewrite" id="contm.nary.rewrite"></a>4.3.4.1.2 Rewriting to Strict Content MathML
                     </h5>
                     <p>If the argument list is given explicitly, the <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a> rule applies.
                     </p>
                     <p>Any use of qualifier elements is expressed in Strict Content
                        MathML, via explicitly applying the function to a list of arguments
                        using the <a href="http://www.openmath.org/cd/fns2.xhtml#apply_to_list">apply_to_list</a> symbol as shown
                        in the following rule. The rule only considers the
                        <code>domainofapplication</code> qualifier as other qualifiers may be
                        rewritten to <code>domainofapplication</code> as described earlier.
                     </p>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.p2s.lifted" id="contm.p2s.lifted"></a>Rewrite: n-ary domainofapplication
                        </h5>
                        <p>An expression of the following form,
                           where <code><span class="egmeta">&lt;union/&gt;</span></code> represents any
                           element of the relevant class and 
                           <code> <span class="egmeta">expression-in-x</span> </code>
                           is an arbitrary expression involving the bound variable(s)
                           
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;union/&gt;</span>
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                           is rewritten to 
                           
                        </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="fns2"&gt;apply_to_list&lt;/csymbol&gt;
  &lt;csymbol cd="<span class="egmeta">set1</span>"&gt;<span class="egmeta">union</span>&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="list1"&gt;map&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
       <span class="egmeta">expression-in-x</span> 
    &lt;/bind&gt;
     <span class="egmeta">D</span> 
  &lt;/apply&gt;
&lt;/apply&gt;</pre></div>
                     <p>The above rule applies to all symbols in the listed classes.
                        In the  case of <b>nary-set.class</b> the choice of Content
                        Dictionary to use depends on the <code>type</code> attribute on the
                        symbol, defaulting to <a href="http://www.openmath.org/cd/set1.xhtml">set1</a>, but <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a>
                        should be used if <code>type</code>="multiset".
                     </p>
                     <p>Note that the members of the <b>nary-constructor.class</b>, such
                        as <code>vector</code>, use <em>constructor</em> syntax where the arguments and
                        qualifiers are given as children of the element rather than as
                        children of a containing <code>apply</code>.  In this case, the above rules apply 
                        with the analogous syntactic modifications.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.nary.setlist" id="contm.nary.setlist"></a>4.3.4.2 N-ary Constructors for set and list (class nary-setlist-constructor)
                  </h4>
                  <p>The use of <code>set</code> and <code>list</code> follows the same format
                     as other n-ary constructors, however when rewriting to Strict
                     Content MathML a variant of the above rule is used. This is because the <a href="http://www.openmath.org/cd/set1.xhtml#map">map</a>
                     symbol implicitly constructs the required set or list, and <a href="http://www.openmath.org/cd/fns2.xhtml#apply_to_list">apply_to_list</a> is
                     not needed in this case.
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.narysetlist.schema" id="contm.narysetlist.schema"></a>4.3.4.2.1 Schema Patterns
                     </h5>
                     <p>The elements representing these n-ary operators are
                        specified in the schema pattern <a href="appendixa-d.html#parsing_nary-setlist-constructor.class">nary-setlist-constructor.class</a>.
                     </p>
                  </div>
                  <div class="div5">
                     
                     <h5><a name="contm.narysetlist.rewrite" id="contm.narysetlist.rewrite"></a>4.3.4.2.2 Rewriting to Strict Content MathML
                     </h5>
                     <p>If the argument list is given explicitly, the <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a> rule applies.
                     </p>
                     <p>When qualifiers are used to specify the list of arguments, the following rule is used.</p>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.rewrite.setliste" id="contm.rewrite.setliste"></a>Rewrite: n-ary setlist domainofapplication
                        </h5>
                        <p>An expression of the following form,
                           where <code><span class="egmeta">&lt;set/&gt;</span></code> is either of the elements <code>set</code> or <code>list</code> and 
                           <code> <span class="egmeta">expression-in-x</span> </code>
                           is an arbitrary expression involving the bound variable(s)
                           
                        </p><pre class="mathml">
<span class="egmeta">&lt;set&gt;</span>
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x</span> 
<span class="egmeta">&lt;/set&gt;</span></pre><p>
                           is rewritten to 
                           
                        </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="<span class="egmeta">set1</span>"&gt;map&lt;/csymbol&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
     <span class="egmeta">expression-in-x</span> 
  &lt;/bind&gt;
   <span class="egmeta">D</span> 
&lt;/apply&gt;</pre><p>Note that
                           when <code> <span class="egmeta">D</span> </code> is already a set
                           or list of the appropriate type for the container element, and the lambda function created
                           from <code> <span class="egmeta">expression-in-x</span> </code> is
                           the identity, the entire container element should be rewritten
                           directly as <code> <span class="egmeta">D</span> </code>.
                        </p>
                     </div>
                     <p>In the  case of <code>set</code>, the choice of Content
                        Dictionary and symbol depends on the value of its <code>type</code> attribute. When the 
                        <code>type</code> attribute is "set", the <a href="http://www.openmath.org/cd/set1.xhtml#set">set</a> symbol is used.  When the 
                        <code>type</code> attribute is "multiset", the <a href="http://www.openmath.org/cd/multiset1.xhtml#multiset">multiset</a> symbol is used. For any other values of type
                        the <a href="http://www.openmath.org/cd/set1.xhtml#set">set</a> symbol should be used, annotated with the type
                        by rewriting the <code>type</code> attribute using the rule
                        <a href="chapter4-d.html#contm.strict-attributes">Rewrite: attributes</a>.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.nary.reln" id="contm.nary.reln"></a>4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)
                  </h4>
                  <p>MathML allows transitive relations to be used with multiple
                     arguments, to give a natural expression to "chains" of
                     relations such as <var>a</var> &lt; <var>b</var> &lt; <var>c</var> &lt;
                     <var>d</var>. However unlike the case of the arithmetic operators, the
                     underlying symbols used in the Strict Content MathML are classed as
                     binary, so it is not possible to use  
                     <a href="http://www.openmath.org/cd/fns2.xhtml#apply_to_list">apply_to_list</a> as in the previous
                     section, but instead a similar function  
                     <a href="http://www.openmath.org/cd/fns2.xhtml#predicate_on_list">predicate_on_list</a> is used, the
                     semantics of which is essentially to take the conjunction of applying
                     the predicate to elements of the domain two at a time.
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.nary.reln.schema" id="contm.nary.reln.schema"></a>4.3.4.3.1 Schema Patterns
                     </h5>
                     <p>The elements representing these n-ary operators are
                        specified in the following schema patterns in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>:
                        <a href="appendixa-d.html#parsing_nary-reln.class">nary-reln.class</a>, <a href="appendixa-d.html#parsing_nary-set-reln.class">nary-set-reln.class</a>.
                     </p>
                  </div>
                  <div class="div5">
                     
                     <h5><a name="contm.nary.reln.rewrite" id="contm.nary.reln.rewrite"></a>4.3.4.3.2 Rewriting to Strict Content MathML
                     </h5>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.rewrite.reln" id="contm.rewrite.reln"></a>Rewrite: n-ary relations
                        </h5>
                        <p>An expression of the form 
                           
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;lt/&gt;</span>
   <span class="egmeta">a</span>  <span class="egmeta">b</span>  <span class="egmeta">c</span>  <span class="egmeta">d</span> 
&lt;/apply&gt;</pre><p>
                           
                           rewrites to Strict Content MathML
                           
                           
                        </p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="fns2"&gt;predicate_on_list&lt;/csymbol&gt;
 &lt;csymbol cd="<span class="egmeta">reln1</span>"&gt;<span class="egmeta">lt</span>&lt;/csymbol&gt;
 &lt;apply&gt;&lt;csymbol cd="list1"&gt;list&lt;/csymbol&gt;
   <span class="egmeta">a</span>  <span class="egmeta">b</span>  <span class="egmeta">c</span>  <span class="egmeta">d</span> 
 &lt;/apply&gt;
&lt;/apply&gt;
</pre></div>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.rewrite.reln.bvar" id="contm.rewrite.reln.bvar"></a>Rewrite: n-ary relations bvar
                        </h5>
                        <p>An expression of the form 
                           
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;lt/&gt;</span>
 &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
 &lt;domainofapplication&gt; <span class="egmeta">R</span> &lt;/domainofapplication&gt;
  <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                           
                           where
                           <code> <span class="egmeta">expression-in-x</span> </code>
                           is an arbitrary expression involving the bound variable, rewrites to the Strict Content MathML
                           
                           
                        </p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="fns2"&gt;predicate_on_list&lt;/csymbol&gt;
 &lt;csymbol cd="<span class="egmeta">reln1</span>"&gt;<span class="egmeta">lt</span>&lt;/csymbol&gt;
 &lt;apply&gt;&lt;csymbol cd="list1"&gt;map&lt;/csymbol&gt;
    <span class="egmeta">R</span> 
   &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
     &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
      <span class="egmeta">expression-in-x</span> 
   &lt;/bind&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre></div>
                     <p>The above rules apply to all symbols in classes <b>nary-reln.class</b>
                        and <b>nary-set-reln.class</b>. In the latter case the choice of Content
                        Dictionary to use depends on the <code>type</code> attribute on the
                        symbol, defaulting to <a href="http://www.openmath.org/cd/set1.xhtml">set1</a>, but <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a>
                        should be used if <code>type</code>="multiset".
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.nary.unary" id="contm.nary.unary"></a>4.3.4.4 N-ary/Unary Operators (classes nary-minmax, nary-stats)
                  </h4>
                  <p>The MathML elements, <code>max</code>, <code>min</code> and some statistical
                     elements such as <code>mean</code> may be used  as a n-ary function as in
                     the above classes, however a special interpretation is given in the
                     case that a single argument is supplied. If a single argument is
                     supplied the function is applied to the elements represented by the
                     argument.
                  </p>
                  <p>The underlying symbol used in Strict Content MathML for these
                     elements is <em>Unary</em> and so if the MathML is used with
                     0 or more than 1 arguments, the function is applied to the set
                     constructed from the explicitly supplied arguments according to the
                     following rule.
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.nary.unary.schema" id="contm.nary.unary.schema"></a>4.3.4.4.1 Schema Patterns
                     </h5>
                     <p>The elements representing these n-ary operators are
                        specified in the following schema patterns in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>:
                        <a href="appendixa-d.html#parsing_nary-minmax.class">nary-minmax.class</a>, <a href="appendixa-d.html#parsing_nary-stats.class">nary-stats.class</a>.
                     </p>
                  </div>
                  <div class="div5">
                     
                     <h5><a name="contm.nary.unary.rewrite" id="contm.nary.unary.rewrite"></a>4.3.4.4.2 Rewriting to Strict Content MathML
                     </h5>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.p2s.max" id="contm.p2s.max"></a>Rewrite: n-ary unary set
                        </h5>
                        <p>When an element,
                           <code><span class="egmeta">&lt;max/&gt;</span></code>, of class nary-stats or nary-minmax
                           is applied to an explicit
                           list of  0 or 2 or more arguments,
                           <code> <span class="egmeta">a1</span>  <span class="egmeta">a2</span>  <span class="egmeta">an</span> </code> 
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;max/&gt;</span> <span class="egmeta">a1</span>  <span class="egmeta">a2</span>  <span class="egmeta">an</span> &lt;/apply&gt;</pre><p>It is is translated to the unary application of the symbol
                           <code>&lt;csymbol cd="<span class="egmeta">minmax1</span>" name="<span class="egmeta">max</span>"/&gt;</code>
                           as specified in the syntax table for the element to the set of
                           arguments, constructed using the
                           <code>&lt;csymbol cd="set1" name="set"/&gt;</code>
                           symbol.
                        </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="<span class="egmeta">minmax1</span>"&gt;<span class="egmeta">max</span>&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="set1"&gt;set&lt;/csymbol&gt;
     <span class="egmeta">a1</span>  <span class="egmeta">a2</span>  <span class="egmeta">an</span> 
  &lt;/apply&gt;
&lt;/apply&gt;</pre></div>
                     <p>Like all MathML n-ary operators, The list of arguments may be
                        specified implicitly using qualifier elements. This is expressed in
                        Strict Content MathML using the following rule, which is similar to
                        the rule <a href="chapter4-d.html#contm.p2s.lifted">Rewrite: n-ary domainofapplication</a> but differs in that the
                        symbol can be directly applied to the constructed set of arguments and
                        it is not necessary to use <a href="http://www.openmath.org/cd/fns2.xhtml#apply_to_list">apply_to_list</a>.
                     </p>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.unary.nary.doma" id="contm.unary.nary.doma"></a>Rewrite: n-ary unary domainofapplication
                        </h5>
                        <p>An expression of the following form,
                           where <code><span class="egmeta">&lt;max/&gt;</span></code> represents any
                           element of the relevant class and 
                           <code> <span class="egmeta">expression-in-x</span> </code>
                           is an arbitrary expression involving the bound variable(s)
                           
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;max/&gt;</span>
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                           is rewritten to 
                           
                        </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="<span class="egmeta">minmax1</span>"&gt;<span class="egmeta">max</span>&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="set1"&gt;map&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
       <span class="egmeta">expression-in-x</span> 
    &lt;/bind&gt;
     <span class="egmeta">D</span> 
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Note that
                           when <code> <span class="egmeta">D</span> </code> is already a set
                           and the lambda function created from <code> <span class="egmeta">expression-in-x</span> </code> is
                           the identity, the <code>domainofapplication</code> term should should be
                           rewritten directly
                           as <code> <span class="egmeta">D</span> </code>.
                        </p>
                     </div>
                     <p>If the element is applied to a single argument the
                        <a href="http://www.openmath.org/cd/set1.xhtml#set">set</a> symbol is not used and the symbol is
                        applied directly to the argument.
                     </p>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.nary.unary.single" id="contm.nary.unary.single"></a>Rewrite: n-ary unary single
                        </h5>
                        <p>When an element,
                           <code><span class="egmeta">&lt;max/&gt;</span></code>, of class nary-stats or nary-minmax
                           is applied to a single argument,
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;max/&gt;</span> <span class="egmeta">a</span> &lt;/apply&gt;</pre><p>It is is translated to the unary application of the symbol
                           in the syntax table for the element.
                        </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="<span class="egmeta">minmax1</span>"&gt;<span class="egmeta">max</span>&lt;/csymbol&gt;  <span class="egmeta">a</span>  &lt;/apply&gt;</pre></div>
                     <p>Note: Earlier versions of MathML were not explicit about the correct
                        interpretation of elements in this class, and left it undefined as to
                        whether an expression such as max(X) was a trivial application of max
                        to a singleton, or whether it should be interpreted as meaning the
                        maximum of values of the set X. Applications finding that the rule 
                        <a href="chapter4-d.html#contm.nary.unary.single">Rewrite: n-ary unary single</a> can not be applied as the
                        supplied argument is a scalar may wish to use the rule
                        <a href="chapter4-d.html#contm.p2s.max">Rewrite: n-ary unary set</a> as an error recovery.
                        As a further complication, in the case of the statistical functions
                        the Content Dictionary to use in this case depends on the desired
                        interpretation of the argument as a set of explicit data or a random
                        variable representing a distribution. 
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.binary" id="contm.binary"></a>4.3.4.5 Binary Operators (classes binary-arith, binary-logical, binary-reln, binary-linalg, binary-set)
                  </h4>
                  <p>Binary operators take two arguments and simply map to OpenMath
                     symbols via <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>
                     without the need of any special rewrite rules. The binary 
                     constructor <code>interval</code> is similar but uses constructor syntax
                     in which the arguments are children of the element, and the symbol
                     used depends on the type element as described in <a href="chapter4-d.html#contm.interval">Section&nbsp;4.4.1.1 Interval <code>&lt;interval&gt;</code></a> 
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.binary.schema" id="contm.binary.schema"></a>4.3.4.5.1 Schema Patterns
                     </h5>
                     <p>The elements representing these binary operators are
                        specified in the following schema patterns in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>:
                        <a href="appendixa-d.html#parsing_binary-arith.class">binary-arith.class</a>, <a href="appendixa-d.html#parsing_binary-logical.class">binary-logical.class</a>, <a href="appendixa-d.html#parsing_binary-reln.class">binary-reln.class</a>, <a href="appendixa-d.html#parsing_binary-linalg.class">binary-linalg.class</a>, <a href="appendixa-d.html#parsing_binary-set.class">binary-set.class</a>.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.unary" id="contm.unary"></a>4.3.4.6 Unary Operators (classes unary-arith, unary-linalg, unary-functional, unary-set, unary-elementary, unary-veccalc)
                  </h4>
                  <p>Unary operators take a single argument and map to OpenMath symbols
                     via <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a> without the need of any special rewrite rules.
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.unary.schema" id="contm.unary.schema"></a>4.3.4.6.1 Schema Patterns
                     </h5>
                     <p>The elements representing these unary operators are
                        specified in the following schema patterns in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>:
                        <a href="appendixa-d.html#parsing_unary-arith.class">unary-arith.class</a>, <a href="appendixa-d.html#parsing_unary-functional.class">unary-functional.class</a>, <a href="appendixa-d.html#parsing_unary-set.class">unary-set.class</a>, <a href="appendixa-d.html#parsing_unary-elementary.class">unary-elementary.class</a>, <a href="appendixa-d.html#parsing_unary-veccalc.class">unary-veccalc.class</a>.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.constant" id="contm.constant"></a>4.3.4.7 Constants (classes constant-arith, constant-set)
                  </h4>
                  <p>Constant symbols relate to mathematical constants such as e and true and
                     also to names of sets such as the Real Numbers, and Integers.
                     In Strict Content MathML, they rewrite simply to the corresponding
                     symbol listed in the syntax tables for these elements in <a href="chapter4-d.html#contm.constantsandsymbols">Section&nbsp;4.4.10 Constant and Symbol Elements</a>.
                     
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.constant.schema" id="contm.constant.schema"></a>4.3.4.7.1 Schema Patterns
                     </h5>
                     <p>The elements representing these constants are
                        specified in the schema patterns 
                        <a href="appendixa-d.html#parsing_constant-arith.class">constant-arith.class</a> and  <a href="appendixa-d.html#parsing_constant-set.class">constant-set.class</a>.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.quantifier" id="contm.quantifier"></a>4.3.4.8 Quantifiers (class quantifier)
                  </h4>
                  <p>The Quantifier class is used for the forall and exists quantifiers
                     of predicate calculus.
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.quantifier.schema" id="contm.quantifier.schema"></a>4.3.4.8.1 Schema Patterns
                     </h5>
                     <p>The elements representing quantifiers are
                        specified in the schema pattern <a href="appendixa-d.html#parsing_quantifier.class">quantifier.class</a>.
                     </p>
                  </div>
                  <div class="div5">
                     
                     <h5><a name="contm.quantifier.rewrite" id="contm.quantifier.rewrite"></a>4.3.4.8.2 Rewriting to Strict Content MathML
                     </h5>
                     <p>If used with <code>bind</code> and no qualifiers,
                        then the interpretation in Strict Content MathML is simple. In general
                        if used with <code>apply</code> or qualifiers, the interpretation in
                        Strict Content MathML is via the following rule.
                     </p>
                     <div class="strict-mathml-example">
                        
                        <h5><a name="contm.rewrite.quantifier" id="contm.rewrite.quantifier"></a>Rewrite: quantifier
                        </h5>
                        <p> An expression of following form where
                           <code><span class="egmeta">&lt;exists/&gt;</span></code> denotes an element of
                           class <b>quantifier</b> and 
                           <code> <span class="egmeta">expression-in-x</span> </code>
                           is an arbitrary expression involving the bound variable(s)
                           
                        </p><pre class="mathml">
&lt;apply&gt;<span class="egmeta">&lt;exists/&gt;</span>
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                           is rewritten to an expression 
                           
                        </p><pre class="strict-mathml">
&lt;bind&gt;&lt;csymbol cd="<span class="egmeta">quant1</span>"&gt;<span class="egmeta">exists</span>&lt;/csymbol&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;apply&gt;&lt;csymbol cd="<span class="egmeta">logic1</span>"&gt;<span class="egmeta">and</span>&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="set1"&gt;in&lt;/csymbol&gt; <span class="egmeta">x</span>  <span class="egmeta">D</span> &lt;/apply&gt;
   <span class="egmeta">expression-in-x</span> 
  &lt;/apply&gt;
&lt;/bind&gt;
</pre><p>
                           where the symbols
                           <code>&lt;csymbol cd="<span class="egmeta">quant1</span>"&gt;<span class="egmeta">exists</span>&lt;/csymbol&gt;</code>
                           and
                           <code>&lt;csymbol cd="<span class="egmeta">logic1</span>"&gt;<span class="egmeta">and</span>&lt;/csymbol&gt;</code>
                           are as specified in the syntax table of the element.
                           (The additional symbol being  
                           <a href="http://www.openmath.org/cd/logic1.xhtml#and">and</a> in the case of <code>exists</code> and 
                           <a href="http://www.openmath.org/cd/logic1.xhtml#implies">implies</a> in the case of <code>forall</code>.) When no 
                           <code>domainofapplication</code> is present, no logical conjunction is necessary, and the translation 
                           is direct.
                           
                        </p>
                     </div>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.otherclass" id="contm.otherclass"></a>4.3.4.9 Other Operators (classes lambda, interval, int, diff partialdiff, sum, product, limit)
                  </h4>
                  <p>Special purpose classes, described in the sections for the
                     appropriate elements
                  </p>
                  <div class="div5">
                     
                     <h5><a name="contm.otherclass.schema" id="contm.otherclass.schema"></a>4.3.4.9.1 Schema Patterns
                     </h5>
                     <p>The elements are specified in the following schema patterns in <a href="appendixa-d.html">Appendix&nbsp;A Parsing MathML</a>:
                        <a href="appendixa-d.html#parsing_lambda.class">lambda.class</a>, <a href="appendixa-d.html#parsing_interval.class">interval.class</a>, <a href="appendixa-d.html#parsing_int.class">int.class</a>, <a href="appendixa-d.html#parsing_partialdiff.class">partialdiff.class</a>, <a href="appendixa-d.html#parsing_sum.class">sum.class</a>, <a href="appendixa-d.html#parsing_product.class">product.class</a>, <a href="appendixa-d.html#parsing_limit.class">limit.class</a>.
                     </p>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.3.5" id="id.4.3.5"></a>4.3.5 Non-strict Attributes
               </h3>
               <p>A number of content MathML elements such as <code>cn</code> and
                  <code>interval</code> allow attributes to specialize the semantics of the
                  objects they represent.  For these cases, special rewrite rules are
                  given on a case-by-case basis in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. However,
                  content MathML elements also accept <a href="chapter2-d.html#fund.globatt">attributes shared all MathML elements</a>, and
                  depending on the context, may also contain attributes from other XML
                  namespaces.  Such attributes must be rewritten in alternative form in
                  Strict Content Markup.
               </p>
               <div class="strict-mathml-example">
                  
                  <h5><a name="contm.strict-attributes" id="contm.strict-attributes"></a>Rewrite: attributes
                  </h5>
                  <p> For instance,  
                     
                  </p><pre class="mathml">
&lt;ci class="<span class="egmeta">foo</span>" xmlns:other="<span class="egmeta">http://example.com</span>" other:att="<span class="egmeta">bla</span>"&gt;<span class="egmeta">x</span>&lt;/ci&gt;</pre><p>
                     is rewritten to 
                     
                  </p><pre class="strict-mathml">
&lt;semantics&gt;
  &lt;ci&gt;<span class="egmeta">x</span>&lt;/ci&gt;
  &lt;annotation cd="mathmlattr"
     name="class" encoding="text/plain"&gt;<span class="egmeta">foo</span>&lt;/annotation&gt;
  &lt;annotation-xml cd="mathmlattr" name="foreign" encoding="MathML-Content"&gt;
    &lt;apply&gt;&lt;csymbol cd="mathmlattr"&gt;foreign_attribute&lt;/csymbol&gt;
      &lt;cs&gt;<span class="egmeta">http://example.com</span>&lt;/cs&gt;
      &lt;cs&gt;<span class="egmeta">other</span>&lt;/cs&gt;
      &lt;cs&gt;<span class="egmeta">att</span>&lt;/cs&gt;
      &lt;cs&gt;<span class="egmeta">bla</span>&lt;/cs&gt;
    &lt;/apply&gt;
  &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre><p>
                     
                     For MathML attributes not allowed in Strict Content MathML the content
                     dictionary <a href="http://www.openmath.org/cd/mathmlattr.xhtml">mathmlattr</a> is referenced, which provides
                     symbols for all attributes allowed on content MathML
                     elements.
                  </p>
               </div>
            </div>
         </div>
         <div class="div2">
            
            <h2><a name="contm.opel" id="contm.opel"></a>4.4 Content MathML for Specific Operators and Constants
            </h2>
            <p>This section presents elements representing a core set of
               mathematical operators, functions and constants.  Most are empty
               elements, covering the subject matter of standard mathematics
               curricula up to the level of calculus.  The remaining elements are
               <a href="chapter4-d.html#contm.container">container</a> elements for
               sets, intervals, vectors and so on.  For brevity, all elements
               defined in this section are sometimes called <em>operator
                  elements</em>.
            </p>
            <p>Each subsection below discusses a specific operator element,
               beginning with a syntax table, giving the elements <a href="chapter4-d.html#contm.opclasses">operator class</a>.  Special case rules
               for rewriting as Strict Markup are introduced as needed.
               However, in most cases, the generic rewrite rules for the
               appropriate operator class is sufficient.  In particular, unless
               otherwise indicated, elements are to be rewritten using the
               default <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>
               rule.  Note, however, that all elements in this section must be rewritten in
               some fashion, since they are not allowed in Strict Content markup.
            </p>
            <p>In MathML 2, the <code>definitionURL</code> attribute could be
               used to redefine or modify the meaning of an operator
               element. This use of the <code>definitionURL</code> attribute is <a href="chapter2-d.html#interf.deprec">deprecated</a> in MathML 3. Instead a
               <code>csymbol</code> element should be used.  In general, the value of
               <code>cd</code> attribute on the <code>csymbol</code> will correspond to
               the <code>definitionURL</code> value.
            </p>
            <div class="div3">
               
               <h3><a name="contm.basicfun" id="contm.basicfun"></a>4.4.1 Functions and Inverses
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.interval" id="contm.interval"></a>4.4.1.1 Interval <code>&lt;interval&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">interval</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>,<a href="appendixa-d.html#parsing_closure">closure</a>?
                           </td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a>,<a href="appendixa-d.html#parsing_ContExp">ContExp</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td>
                              <a href="http://www.openmath.org/cd/interval1.xhtml#interval_cc">interval_cc</a>, 
                              <a href="http://www.openmath.org/cd/interval1.xhtml#interval_oc">interval_oc</a>, 
                              <a href="http://www.openmath.org/cd/interval1.xhtml#interval_co">interval_co</a>, 
                              <a href="http://www.openmath.org/cd/interval1.xhtml#interval_oo">interval_oo</a>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>interval</code> element is a container element used to represent simple mathematical intervals of the
                     real number line.  It takes an optional attribute <code>closure</code>, with a default value
                     of "closed".
                  </p>
                  <div class="mathml-example" id="interval1.interval.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;interval closure="open"&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/interval&gt;</pre><pre class="mathml">
&lt;interval closure="closed"&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/interval&gt;</pre><pre class="mathml">
&lt;interval closure="open-closed"&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/interval&gt;</pre><pre class="mathml">
&lt;interval closure="closed-open"&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/interval&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mfenced&gt;</pre><blockquote>
                        <p><img src="image/interval1-interval_oo-ex1.gif" alt="{\left(x,{1}\right)}"></p>
                     </blockquote><pre class="mathml">
&lt;mfenced open="[" close="]"&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mfenced&gt;</pre><blockquote>
                        <p><img src="image/interval1-interval_cc-ex1.gif" alt="{\left[{0},{1}\right]}"></p>
                     </blockquote><pre class="mathml">
&lt;mfenced open="(" close="]"&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mfenced&gt;</pre><blockquote>
                        <p><img src="image/interval1-interval_oc-ex1.gif" alt="{\left({0},{1}\right]}"></p>
                     </blockquote><pre class="mathml">
&lt;mfenced open="[" close=")"&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mfenced&gt;</pre><blockquote>
                        <p><img src="image/interval1-interval_co-ex1.gif" alt="{\left[{0},{1}\right)}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>In Strict markup, the <code>interval</code> element corresponds to one
                     of four symbols from the <a href="http://www.openmath.org/cd/interval1.xhtml">interval1</a> content
                     dictionary. If <code>closure</code> has the value "open" then
                     <code>interval</code> corresponds to the
                     <a href="http://www.openmath.org/cd/interval1.xhtml#interval_oo">interval_oo</a>.
                     With the value "closed"
                     <code>interval</code> corresponds to the symbol
                     <a href="http://www.openmath.org/cd/interval1.xhtml#interval_cc">interval_cc</a>,
                     with value "open-closed" to
                     <a href="http://www.openmath.org/cd/interval1.xhtml#interval_oc">interval_oc</a>, and with
                     "closed-open" to
                     <a href="http://www.openmath.org/cd/interval1.xhtml#interval_co">interval_co</a>.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.inverse" id="contm.inverse"></a>4.4.1.2 Inverse <code>&lt;inverse&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#inverse">inverse</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>inverse</code> element is applied to a function in order to
                     construct a generic expression for the functional inverse of that
                     function. The <code>inverse</code> element may either be applied to
                     arguments, or it may appear alone, in which case it represents an
                     abstract inversion operator acting on other functions.
                  </p>
                  <div class="mathml-example" id="fns1.inverse.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;inverse/&gt;
  &lt;ci&gt; f &lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msup&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mn&gt;-1&lt;/mn&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;&lt;/msup&gt;</pre><blockquote>
                        <p><img src="image/fns1-inverse-ex1.gif" alt="{\msup{f}{{\left.\middle({\mn{-1}}\middle)\right.}}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="fns1.inverse.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;inverse/&gt;&lt;ci type="matrix"&gt;A&lt;/ci&gt;&lt;/apply&gt;
  &lt;ci&gt;a&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msup&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mn&gt;-1&lt;/mn&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;&lt;/msup&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-inverse-ex2.gif" alt="{\msup{A}{{\left.\middle({\mn{-1}}\middle)\right.}}\unicode{8289}{\left(a\right)}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.lambda" id="contm.lambda"></a>4.4.1.3 Lambda <code>&lt;lambda&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">lambda</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>, <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a>, <a href="appendixa-d.html#parsing_ContExp">ContExp</a></td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#lambda">lambda</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>lambda</code> element is used to construct a user-defined
                     function from an expression, bound variables, and qualifiers. In a
                     lambda construct with <var>n</var> (possibly 0) bound variables, the
                     first <var>n</var> children are <code>bvar</code> elements that identify
                     the variables that are used as placeholders in the last child for
                     actual parameter values. The bound variables can be restricted by an
                     optional <code>domainofapplication</code> qualifier or one of its
                     <a href="chapter4-d.html#contm.domainofapplication.qualifier">shorthand
                        notations</a>. The meaning of the <code>lambda</code> construct is an
                     <var>n</var>-ary function that returns the expression in the last
                     child where the bound variables are replaced with the respective
                     arguments.
                  </p>
                  <p>The <code>domainofapplication</code> child restricts the possible
                     values of the arguments of the constructed function. For instance, the
                     following <code>lambda</code> construct represents a function on
                     the integers.
                     
                     
                  </p><pre class="mathml">
&lt;lambda&gt;
  &lt;bvar&gt;&lt;ci&gt; x &lt;/ci&gt;&lt;/bvar&gt;
  &lt;domainofapplication&gt;&lt;integers/&gt;&lt;/domainofapplication&gt;
  &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt; x &lt;/ci&gt;&lt;/apply&gt;
&lt;/lambda&gt;</pre><p>
                     
                     If a <code>lambda</code> construct does not contain bound variables, then
                     the <code>lambda</code> construct is superfluous and may be removed,
                     unless it also contains a <code>domainofapplication</code> construct.  
                     In that case, if the last child of the <code>lambda</code> construct is
                     itself a function, then the <code>domainofapplication</code> restricts
                     its existing functional arguments, as in this example, which is
                     a variant representation for the function above.  
                     
                     
                  </p><pre class="mathml">
&lt;lambda&gt;
  &lt;domainofapplication&gt;&lt;integers/&gt;&lt;/domainofapplication&gt; 
  &lt;sin/&gt;
&lt;/lambda&gt;</pre><p>  
                     
                     Otherwise, if the last child of the <code>lambda</code> construct is not a
                     function, say a number, then the <code>lambda</code> construct will not be
                     a function, but the same number, and any <code>domainofapplication</code>
                     is ignored.
                  </p>
                  <div class="mathml-example" id="fns1.lambda.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;lambda&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;sin/&gt;
    &lt;apply&gt;&lt;plus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/lambda&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;&amp;#x3bb;&lt;/mi&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;.&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mi&gt;sin&lt;/mi&gt;
   &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
   &lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-lambda-ex2.gif" alt="{\unicode{955}x.{\left({\mathop{{\minormal{sin}}}{\left.\middle(x+{1}\middle)\right.}}\right)}}"></p>
                     </blockquote><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;&amp;#x21a6;&lt;/mo&gt;
  &lt;mrow&gt;
   &lt;mi&gt;sin&lt;/mi&gt;
   &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
   &lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;
  &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-lambda-ex2-2.gif" alt="{x\unicode{8614}{\mathop{{\minormal{sin}}}{\left.\middle(x+{1}\middle)\right.}}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.rewrite.lambda" id="contm.rewrite.lambda"></a>Rewrite: lambda
                     </h5>
                     <p>If the <code>lambda</code> element does not contain qualifiers, the
                        lambda expression is directly translated into a <code>bind</code>
                        expression.
                     </p><pre class="mathml">
&lt;lambda&gt;
  &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;&lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
   <span class="egmeta">expression-in-x1-xn</span> 
&lt;/lambda&gt;</pre><p>rewrites to the Strict Content MathML</p><pre class="mathml">
&lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
  &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;&lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
   <span class="egmeta">expression-in-x1-xn</span> 
&lt;/bind&gt;</pre></div>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.rewrite.lambda.domofa" id="contm.rewrite.lambda.domofa"></a>Rewrite: lambda domainofapplication
                     </h5>
                     <p>If the <code>lambda</code> element does contain qualifiers, the
                        qualifier may be rewritten to <code>domainofapplication</code>
                        and then the lambda expression is translated to a
                        function term constructed with <a href="http://www.openmath.org/cd/fns1.xhtml#lambda">lambda</a>
                        and restricted to the specified domain using 
                        <a href="http://www.openmath.org/cd/fns1.xhtml#restriction">restriction</a>.
                     </p><pre class="mathml">
&lt;lambda&gt;
  &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;&lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x1-xn</span> 
&lt;/lambda&gt;</pre><p>rewrites to the Strict Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;csymbol cd="fns1"&gt;restriction&lt;/csymbol&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;&lt;bvar&gt; <span class="egmeta">xn</span> &lt;/bvar&gt;
     <span class="egmeta">expression-in-x1-xn</span> 
  &lt;/bind&gt;
   <span class="egmeta">D</span> 
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.compose" id="contm.compose"></a>4.4.1.4 Function composition <code>&lt;compose/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#left_compose">left_compose</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>compose</code> element represents the function
                     composition operator. Note that MathML makes no assumption about the domain
                     and codomain of the constituent functions in a composition; the domain of the
                     resulting composition may be empty.
                  </p>
                  <p>The <code>compose</code> element is a commutative n-ary operator.  Consequently, it may be
                     lifted to the induced operator defined on a collection of arguments indexed by a (possibly
                     infinite) set by using qualifier elements as described in <a href="chapter4-d.html#contm.nary">Section&nbsp;4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                        nary-linalg, nary-set, nary-constructor)</a>.
                     
                  </p>
                  <div class="mathml-example" id="fns1.compose.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;compose/&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;g&lt;/ci&gt;&lt;ci&gt;h&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2218;&lt;/mo&gt;&lt;mi&gt;g&lt;/mi&gt;&lt;mo&gt;&amp;#x2218;&lt;/mo&gt;&lt;mi&gt;h&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-compose-ex1.gif" alt="{f\unicode{8728}g\unicode{8728}h}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="fns1.compose.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;
    &lt;apply&gt;&lt;compose/&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;g&lt;/ci&gt;&lt;/apply&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;apply&gt;&lt;ci&gt;g&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2218;&lt;/mo&gt;&lt;mi&gt;g&lt;/mi&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
  &lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mi&gt;f&lt;/mi&gt;
  &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
  &lt;mfenced&gt;
   &lt;mrow&gt;
    &lt;mi&gt;g&lt;/mi&gt;
    &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
    &lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-compose-ex2.gif" alt="{{{\left.\middle(f\unicode{8728}g\middle)\right.}\unicode{8289}{\left(x\right)}}={\mathop{f}{\left({\mathop{g}{\left(x\right)}}\right)}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.ident" id="contm.ident"></a>4.4.1.5 Identity function <code>&lt;ident/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#identity">identity</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>ident</code> element represents the
                     identity function. Note that MathML makes no assumption about the
                     domain and codomain of the represented identity function, which
                     depends on the context in which it is used.
                  </p>
                  <div class="mathml-example" id="fns1.ident.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;compose/&gt;
    &lt;ci type="function"&gt;f&lt;/ci&gt;
    &lt;apply&gt;&lt;inverse/&gt;
      &lt;ci type="function"&gt;f&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/apply&gt;
  &lt;ident/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;
  &lt;mi&gt;f&lt;/mi&gt;
  &lt;mo&gt;&amp;#x2218;&lt;/mo&gt;
  &lt;msup&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mn&gt;-1&lt;/mn&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;&lt;/msup&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mi&gt;id&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-ident-ex1.gif" alt="{{f\unicode{8728}\msup{f}{{\left.\middle({\mn{-1}}\middle)\right.}}}={\minormal{id}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.domain" id="contm.domain"></a>4.4.1.6 Domain <code>&lt;domain/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#domain">domain</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>domain</code> element represents the domain of the
                     function to which it is applied.  The domain is the set of values
                     over which the function is defined.
                  </p>
                  <div class="mathml-example" id="fns1.domain.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;domain/&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;/apply&gt;
  &lt;reals/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;domain&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mi mathvariant="double-struck"&gt;R&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-domain-ex1.gif" alt="{{\mathop{{\minormal{domain}}}{\left(f\right)}}={\midoublestruck{R}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.codomain" id="contm.codomain"></a>4.4.1.7 codomain <code>&lt;codomain/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#range">range</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>codomain</code> represents the codomain, or range, of the function
                     to which is is applied.  Note that the codomain is not necessarily
                     equal to the image of the function, it is merely required to contain
                     the image.
                  </p>
                  <div class="mathml-example" id="fns1.range.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;codomain/&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;/apply&gt;
  &lt;rationals/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;codomain&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mi mathvariant="double-struck"&gt;Q&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-range-ex1.gif" alt="{{\mathop{{\minormal{codomain}}}{\left(f\right)}}={\midoublestruck{Q}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.image" id="contm.image"></a>4.4.1.8 Image <code>&lt;image/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/fns1.xhtml#image">image</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>image</code> element represent the image of
                     the function to which it is applied. The image of a function is the
                     set of values taken by the function. Every point in the image is
                     generated by the function applied to some point of the domain.
                  </p>
                  <div class="mathml-example" id="fns1.image.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;image/&gt;&lt;sin/&gt;&lt;/apply&gt;
  &lt;interval&gt;&lt;cn&gt;-1&lt;/cn&gt;&lt;cn&gt; 1&lt;/cn&gt;&lt;/interval&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;image&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mfenced open="[" close="]"&gt;&lt;mn&gt;-1&lt;/mn&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/fns1-image-ex1.gif" alt="{{\mathop{{\minormal{image}}}{\left({\minormal{sin}}\right)}}={\left[{\mn{-1}},{1}\right]}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.piecewise" id="contm.piecewise"></a>4.4.1.9 Piecewise declaration (<code>&lt;piecewise&gt;</code>, <code>&lt;piece&gt;</code>, <code>&lt;otherwise&gt;</code>)
                  </h4>
                  <table>
                     <tbody>
                        <tr>
                           <td>
                              
                              
                              <table class="syntax">
                                 <tbody>
                                    <tr>
                                       <th>Class</th>
                                       <td><a href="chapter4-d.html#contm.container.constructor">Constructor</a></td>
                                    </tr>
                                    <tr>
                                       <th>Attributes</th>
                                       <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                                    </tr>
                                    <tr>
                                       <th>Content</th>
                                       <td><a href="appendixa-d.html#parsing_piece">piece</a>* 
                                          <a href="appendixa-d.html#parsing_otherwise">otherwise</a>?
                                       </td>
                                    </tr>
                                    <tr>
                                       <th>OM Symbols</th>
                                       <td><a href="http://www.openmath.org/cd/piece1.xhtml#piecewise">piecewise</a></td>
                                    </tr>
                                 </tbody>
                              </table>
                              
                              <em>Syntax Table for <code>piecewise</code></em>
                              
                           </td>
                           <td>
                              
                              <table class="syntax">
                                 <tbody>
                                    <tr>
                                       <th>Class</th>
                                       <td><a href="chapter4-d.html#contm.container.constructor">Constructor</a></td>
                                    </tr>
                                    <tr>
                                       <th>Attributes</th>
                                       <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                                    </tr>
                                    <tr>
                                       <th>Content</th>
                                       <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a> <a href="appendixa-d.html#parsing_ContExp">ContExp</a></td>
                                    </tr>
                                    <tr>
                                       <th>OM Symbols</th>
                                       <td><a href="http://www.openmath.org/cd/piece1.xhtml#piece">piece</a></td>
                                    </tr>
                                 </tbody>
                              </table>
                              
                              <em>Syntax Table for <code>piece</code></em>
                              
                           </td>
                           <td>
                              
                              <table class="syntax">
                                 <tbody>
                                    <tr>
                                       <th>Class</th>
                                       <td><a href="chapter4-d.html#contm.container.constructor">Constructor</a></td>
                                    </tr>
                                    <tr>
                                       <th>Attributes</th>
                                       <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                                    </tr>
                                    <tr>
                                       <th>Content</th>
                                       <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a></td>
                                    </tr>
                                    <tr>
                                       <th>OM Symbols</th>
                                       <td><a href="http://www.openmath.org/cd/piece1.xhtml#otherwise">otherwise</a></td>
                                    </tr>
                                 </tbody>
                              </table>
                              
                              <em>Syntax Table for <code>otherwise</code></em>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>piecewise</code>, <code>piece</code>, and <code>otherwise</code> elements are used to
                     represent "piecewise" function definitions of the form "
                     <var>H</var>(<var>x</var>) = 0 if <var>x</var> less than 0, <var>H</var>(<var>x</var>) = 1
                     otherwise".
                  </p>
                  <p>The declaration is constructed using the <code>piecewise</code> element.  This contains
                     zero or more <code>piece</code> elements, and optionally one <code>otherwise</code> element. Each
                     <code>piece</code> element contains exactly two children. The first child defines the value
                     taken by the <code>piecewise</code> expression when the condition specified in the associated
                     second child of the <code>piece</code> is true.  The degenerate case of no <code>piece</code>
                     elements and no <code>otherwise</code> element is treated as undefined for all values of the
                     domain.
                  </p>
                  <p>The <code>otherwise</code> element allows the specification of a value to be taken by the
                     <code>piecewise</code> function when none of the conditions (second child elements of the
                     <code>piece</code> elements) is true, i.e. a default value.
                  </p>
                  <p>It should be noted that no "order of execution" is implied by the
                     ordering of the <code>piece</code> child elements within <code>piecewise</code>. It is the
                     responsibility of the author to ensure that the subsets of the function domain defined by
                     the second children of the <code>piece</code> elements are disjoint, or that, where they
                     overlap, the values of the corresponding first children of the <code>piece</code> elements
                     coincide. If this is not the case, the meaning of the expression is
                     undefined.
                  </p>
                  <p>Here is an example:</p>
                  <div class="mathml-example" id="piece1.piecewise.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;piecewise&gt;
  &lt;piece&gt;
    &lt;apply&gt;&lt;minus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;lt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;/piece&gt;
  &lt;piece&gt;
    &lt;cn&gt;0&lt;/cn&gt;
    &lt;apply&gt;&lt;eq/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;/piece&gt;
  &lt;piece&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;apply&gt;&lt;gt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;/piece&gt;
&lt;/piecewise&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;{&lt;/mo&gt;
 &lt;mtable&gt;
  &lt;mtr&gt;
   &lt;mtd&gt;&lt;mrow&gt;&lt;mo&gt;&amp;#x2212;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;&lt;/mtd&gt;
   &lt;mtd columnalign="left"&gt;&lt;mtext&gt;&amp;#xa0; if &amp;#xa0;&lt;/mtext&gt;&lt;/mtd&gt;
   &lt;mtd&gt;&lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;&lt;/mtd&gt;
  &lt;/mtr&gt;
  &lt;mtr&gt;
   &lt;mtd&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mtd&gt;
   &lt;mtd columnalign="left"&gt;&lt;mtext&gt;&amp;#xa0; if &amp;#xa0;&lt;/mtext&gt;&lt;/mtd&gt;
   &lt;mtd&gt;&lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;&lt;/mtd&gt;
  &lt;/mtr&gt;
  &lt;mtr&gt;
   &lt;mtd&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mtd&gt;
   &lt;mtd columnalign="left"&gt;&lt;mtext&gt;&amp;#xa0; if &amp;#xa0;&lt;/mtext&gt;&lt;/mtd&gt;
   &lt;mtd&gt;&lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;gt;&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;&lt;/mtd&gt;
  &lt;/mtr&gt;
 &lt;/mtable&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/piece1-piecewise-ex1.gif" alt="{\left.\middle\{{\begin{matrix}{\unicode{8722}x}\endcell{\mathrm{\unicode{160}~if~\unicode{160}}}\endcell{x\lt{0}}\\{0}\endcell{\mathrm{\unicode{160}~if~\unicode{160}}}\endcell{x={0}}\\x\endcell{\mathrm{\unicode{160}~if~\unicode{160}}}\endcell{x\gt{0}}\end{matrix}}\right.}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>In Strict Content MathML, the container elements
                     <code>piecewise</code>, <code>piece</code> and <code>otherwise</code> are mapped
                     to applications of the constructor symbols of the same names in the
                     <a href="http://www.openmath.org/cd/piece1.xhtml">piece1</a> CD.  Apart from the fact that these three
                     elements (respectively symbols) are used together, the mapping to
                     Strict markup is straightforward:
                  </p>
                  <div class="strict-mathml-example" id="contm.piecewise-example">
                     <p>Content MathML</p><pre class="mathml">
&lt;piecewise&gt;
  &lt;piece&gt;
    &lt;apply&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;lt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;/piece&gt;
  &lt;piece&gt;
    &lt;cn&gt;1&lt;/cn&gt;
    &lt;apply&gt;&lt;gt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
  &lt;/piece&gt;
  &lt;otherwise&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/otherwise&gt;
&lt;/piecewise&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="piece1"&gt;piecewise&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="piece1"&gt;piece&lt;/csymbol&gt;
    &lt;cn&gt;0&lt;/cn&gt;
    &lt;apply&gt;&lt;csymbol cd="relation1"&gt;lt&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;  
  &lt;/apply&gt;   
  &lt;apply&gt;&lt;csymbol cd="piece1"&gt;piece&lt;/csymbol&gt;
    &lt;cn&gt;1&lt;/cn&gt;
    &lt;apply&gt;&lt;csymbol cd="relation1"&gt;gt&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;  
  &lt;/apply&gt;   
  &lt;apply&gt;&lt;csymbol cd="piece1"&gt;otherwise&lt;/csymbol&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/apply&gt;   
&lt;/apply&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.4.2" id="id.4.4.2"></a>4.4.2 Arithmetic, Algebra and Logic
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.quotient" id="contm.quotient"></a>4.4.2.1 Quotient <code>&lt;quotient/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/integer1.xhtml#quotient">quotient</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>quotient</code> element represents the integer division
                     operator. When the operator is applied to integer arguments
                     <var>a</var> and <var>b</var>, the result is the "quotient of
                     <var>a</var> divided by <var>b</var>". That is, the quotient
                     of integers <var>a</var> and <var>b</var>, is the integer
                     <var>q</var> such that <var>a</var> = <var>b</var> * <var>q</var> +
                     <var>r</var>, with |<var>r</var>| less than |<var>b</var>| and
                     <var>a</var> * <var>r</var> positive. In common usage, <var>q</var>
                     is called the quotient and <var>r</var> is the remainder. 
                  </p>
                  <div class="mathml-example" id="integer1.quotient.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;quotient/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x230a;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mo&gt;&amp;#x230b;&lt;/mo&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/integer1-quotient-ex1.gif" alt="{\unicode{8970}a/b\unicode{8971}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.factorial" id="contm.factorial"></a>4.4.2.2 Factorial <code>&lt;factorial/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/integer1.xhtml#factorial">factorial</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the unary factorial operator on non-negative integers.</p>
                  <p>The factorial of an integer <var>n</var> is given by <var>n</var>! = <var>n</var>*(<var>n</var>-1)* ... * 1
                  </p>
                  <div class="mathml-example" id="integer1.factorial.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;factorial/&gt;&lt;ci&gt;n&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;n&lt;/mi&gt;&lt;mo&gt;!&lt;/mo&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/integer1-factorial-ex1.gif" alt="{n!}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.divide" id="contm.divide"></a>4.4.2.3 Division <code>&lt;divide/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#divide">divide</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>divide</code> element represents the division operator in a
                     number field.
                  </p>
                  <div class="mathml-example" id="arith1.divide.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;divide/&gt;
  &lt;ci&gt;a&lt;/ci&gt;
  &lt;ci&gt;b&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-divide-ex1.gif" alt="{a/b}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.max" id="contm.max"></a>4.4.2.4 Maximum <code>&lt;max/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-minmax</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,
                              <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/minmax1.xhtml#max">max</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>max</code> element denotes the maximum function, which
                     returns the largest of the arguments to which it is applied.  Its
                     arguments may be explicitly specified in the enclosing
                     <code>apply</code> element, or specified using qualifier elements
                     as described in <a href="chapter4-d.html#contm.nary.unary">Section&nbsp;4.3.4.4 N-ary/Unary Operators (classes nary-minmax, nary-stats)</a>.  Note that when applied to
                     infinite sets of arguments, no maximal argument may exist.
                  </p>
                  <div class="mathml-example" id="minmax1.max.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;max/&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;5&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;max&lt;/mi&gt;
 &lt;mrow&gt;
  &lt;mo&gt;{&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;5&lt;/mn&gt;&lt;mo&gt;}&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/minmax1-max-ex1.gif" alt="{{\minormal{max}}{\left.\middle\{{2},{3},{5}\middle\}\right.}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="minmax1.big.max.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;max/&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;in/&gt;
      &lt;ci&gt;y&lt;/ci&gt;
      &lt;interval&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/interval&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;max&lt;/mi&gt;
 &lt;mrow&gt;
  &lt;mo&gt;{&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mo&gt;|&lt;/mo&gt;
  &lt;mrow&gt;
   &lt;msup&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msup&gt;
   &lt;mo&gt;&amp;#x2208;&lt;/mo&gt;
   &lt;mfenced open="[" close="]"&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mfenced&gt;
  &lt;/mrow&gt;
  &lt;mo&gt;}&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/minmax1-big_max-ex1.gif" alt="{{\minormal{max}}{\left.\middle\{y^3\middle|{y\unicode{8712}{\left[{0},{1}\right]}}\middle\}\right.}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.min" id="contm.min"></a>4.4.2.5 Minimum <code>&lt;min/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-minmax</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/minmax1.xhtml#min">min</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>min</code> element denotes the minimum function, which returns the smallest of
                     the arguments to which it is applied.  Its arguments may be explicitly specified in the
                     enclosing <code>apply</code> element, or specified using qualifier
                     elements as described in <a href="chapter4-d.html#contm.nary.unary">Section&nbsp;4.3.4.4 N-ary/Unary Operators (classes nary-minmax, nary-stats)</a>.  Note that when applied to infinite sets of arguments, no
                     minimal argument may exist.
                  </p>
                  <div class="mathml-example" id="minmax1.min.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;min/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;min&lt;/mi&gt;
 &lt;mrow&gt;&lt;mo&gt;{&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mo&gt;}&lt;/mo&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/minmax1-min-ex1.gif" alt="{{\minormal{min}}{\left.\middle\{a,b\middle\}\right.}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="minmax1.big.min.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;min/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;notin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci type="set"&gt;B&lt;/ci&gt;&lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;min&lt;/mi&gt;
 &lt;mrow&gt;&lt;mo&gt;{&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;mo&gt;|&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2209;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mo&gt;}&lt;/mo&gt;
&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/minmax1-big_min-ex2.gif" alt="{{\minormal{min}}{\left.\middle\{x^2\middle|{x\unicode{8713}B}\middle\}\right.}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.minus" id="contm.minus"></a>4.4.2.6 Subtraction <code>&lt;minus/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a>, <a href="chapter4-d.html#contm.binary">binary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#unary_minus">unary_minus</a>, <a href="http://www.openmath.org/cd/arith1.xhtml#minus">minus</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>minus</code> element can be used as a <em>unary arithmetic operator</em>
                     (e.g. to represent - <var>x</var>), or as a <em>binary arithmetic operator</em>
                     (e.g. to represent <var>x</var>- <var>y</var>).
                  </p>
                  <p>If it is used with one argument, <code>minus</code> corresponds to the <a href="http://www.openmath.org/cd/arith1.xhtml#unary_minus">unary_minus</a> symbol.
                  </p>
                  <div class="mathml-example" id="arith1.unary.minus.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;minus/&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x2212;&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-unary_minus-ex1.gif" alt="{\unicode{8722}{3}}"></p>
                     </blockquote>
                  </div>
                  <p>If it is used with two arguments, <code>minus</code> corresponds to the
                     <a href="http://www.openmath.org/cd/arith1.xhtml#minus">minus</a> symbol
                  </p>
                  <div class="mathml-example" id="arith1.minus.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;minus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2212;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-minus-ex1.gif" alt="{x\unicode{8722}y}"></p>
                     </blockquote>
                  </div>
                  <p>In both cases, the translation to Strict Content markup is direct,
                     as described in <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>. It is merely a
                     matter of choosing the symbol that reflects the actual usage.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.plus" id="contm.plus"></a>4.4.2.7 Addition <code>&lt;plus/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#plus">plus</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>plus</code> element represents the addition operator.  Its
                     arguments are normally specified explicitly in the enclosing
                     <code>apply</code> element.  As an n-ary commutative operator, it can
                     be used with qualifiers to specify arguments, however,
                     this is discouraged, and the <code>sum</code> operator should be
                     used to represent such expressions instead.
                  </p>
                  <div class="mathml-example" id="arith1.plus.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;plus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-plus-ex1.gif" alt="{x+y+z}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.power" id="contm.power"></a>4.4.2.8 Exponentiation <code>&lt;power/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#power">power</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>power</code> element represents the exponentiation
                     operator. The first argument is raised to the power of the second
                     argument.
                  </p>
                  <div class="mathml-example" id="arith1.power.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msup&gt;</pre><blockquote>
                        <p><img src="image/arith1-power-ex1.gif" alt="\msup{x}{{3}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rem" id="contm.rem"></a>4.4.2.9 Remainder <code>&lt;rem/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/integer1.xhtml#remainder">remainder</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>rem</code> element represents the modulus operator, which
                     returns the remainder that results from dividing the first argument by
                     the second.  That is, when applied to integer arguments <var>a</var>
                     and <var>b</var>, it returns the unique integer <var>r</var> such that
                     <var>a</var> = <var>b</var> * <var>q</var> + <var>r</var>, with
                     |<var>r</var>| less than |<var>b</var>| and <var>a</var> *
                     <var>r</var> positive.
                  </p>
                  <div class="mathml-example" id="arith1.remainder.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;rem/&gt;&lt;ci&gt; a &lt;/ci&gt;&lt;ci&gt; b &lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;mod&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-remainder-ex1.gif" alt="{a\mathbin{\mathrm{mod}}b}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.times" id="contm.times"></a>4.4.2.10 Multiplication <code>&lt;times/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#times">times</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>times</code> element represents the n-ary multiplication operator.  Its
                     arguments are normally specified explicitly in the enclosing
                     <code>apply</code> element.  As an n-ary commutative operator, it can 
                     be used with qualifiers to specify arguments by rule, however,
                     this is discouraged, and the <code>product</code> operator should be
                     used to represent such expressions instead.
                  </p>
                  <div class="mathml-example" id="arith1.times.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;times/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-times-ex1.gif" alt="{a\unicode{8290}b}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.root" id="contm.root"></a>4.4.2.11 Root <code>&lt;root/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a>, <a href="chapter4-d.html#contm.binary">binary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_degree">degree</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#root">root</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>root</code> element is used to extract roots. The kind of root to be taken is
                     specified by a "degree" element, which should be given as the second child of
                     the <code>apply</code> element enclosing the <code>root</code> element. Thus, square roots
                     correspond to the case where <code>degree</code> contains the value 2, cube roots
                     correspond to 3, and so on. If no <code>degree</code> is present, a default value of 2 is
                     used.
                  </p>
                  <div class="mathml-example" id="arith1.root.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;root/&gt;
  &lt;degree&gt;&lt;ci type="integer"&gt;n&lt;/ci&gt;&lt;/degree&gt;
  &lt;ci&gt;a&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">&lt;mroot&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;n&lt;/mi&gt;&lt;/mroot&gt;</pre><blockquote>
                        <p><img src="image/arith1-root-ex1.gif" alt="\sqrt[{n}]{a}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Content Markup</em></p>
                  <p>In Strict Content markup, the <a href="http://www.openmath.org/cd/arith1.xhtml#root">root</a>
                     symbol is always used with two arguments, with the second indicating
                     the degree of the root being extracted.
                  </p>
                  <div class="strict-mathml-example" id="arith1.root.ex2">
                     <p>Content MathML</p><pre class="mathml">&lt;apply&gt;&lt;root/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;root&lt;/csymbol&gt;
  &lt;ci&gt;x&lt;/ci&gt;
  &lt;cn type="integer"&gt;2&lt;/cn&gt;
&lt;/apply&gt;</pre></div>
                  <div class="strict-mathml-example" id="arith1.root.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;root/&gt;
  &lt;degree&gt;&lt;ci type="integer"&gt;n&lt;/ci&gt;&lt;/degree&gt;
  &lt;ci&gt;a&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;root&lt;/csymbol&gt;
  &lt;ci&gt;a&lt;/ci&gt;
  &lt;cn type="integer"&gt;n&lt;/cn&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.gcd" id="contm.gcd"></a>4.4.2.12 Greatest common divisor <code>&lt;gcd/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#gcd">gcd</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>gcd</code> element represents the n-ary operator which returns
                     the greatest common divisor of its arguments. Its
                     arguments may be explicitly specified in the enclosing
                     <code>apply</code> element, or specified by rule as described in
                     <a href="chapter4-d.html#contm.nary">Section&nbsp;4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                        nary-linalg, nary-set, nary-constructor)</a>.
                  </p>
                  <div class="mathml-example" id="arith1.gcd.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;gcd/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;ci&gt;c&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;gcd&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-gcd-ex1.gif" alt="{\mathop{{\minormal{gcd}}}{\left(a,b,c\right)}}"></p>
                     </blockquote>
                  </div>
                  <p>This default rendering is English-language locale specific: other locales may have
                     different default renderings.
                  </p>
                  <p>When the <code>gcd</code> element is applied to an explicit list of arguments, the
                     translation to Strict Content markup is direct, using the <a href="http://www.openmath.org/cd/arith1.xhtml#gcd">gcd</a> symbol, as described in <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>.  However, when
                     qualifiers are used, the equivalent Strict markup is computed via
                     <a href="chapter4-d.html#contm.p2s.lifted">Rewrite: n-ary domainofapplication</a>.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.and" id="contm.and"></a>4.4.2.13 And <code>&lt;and/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-logical</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#and">and</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>and</code> element represents the logical "and" function which is
                     an n-ary function taking Boolean arguments and returning a Boolean value. It is true if
                     all arguments are true, and false otherwise. Its arguments may be explicitly specified
                     in the enclosing <code>apply</code> element, or specified by rule as described in <a href="chapter4-d.html#contm.nary">Section&nbsp;4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                        nary-linalg, nary-set, nary-constructor)</a>.
                  </p>
                  <div class="mathml-example" id="logic1.and.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;and/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x2227;&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-and-ex1.gif" alt="{a\unicode{8743}b}"></p>
                     </blockquote>
                  </div>
                  <div class="strict-mathml-example" id="contm.and.bvar.ex">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;and/&gt;
  &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;ci&gt;n&lt;/ci&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;gt/&gt;&lt;apply&gt;&lt;selector/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/apply&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Strict Content MathML</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="fns2"&gt;apply_to_list&lt;/csymbol&gt;
  &lt;csymbol cd="logic1"&gt;and&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="list1"&gt;map&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
      &lt;apply&gt;&lt;csymbol cd="relation1"&gt;gt&lt;/csymbol&gt;
        &lt;apply&gt;&lt;csymbol cd="linalg1"&gt;vector_selector&lt;/csymbol&gt;
          &lt;ci&gt;i&lt;/ci&gt;
          &lt;ci&gt;a&lt;/ci&gt;
        &lt;/apply&gt;
        &lt;cn&gt;0&lt;/cn&gt;
      &lt;/apply&gt;
    &lt;/bind&gt;
    &lt;apply&gt;&lt;csymbol cd="interval1"&gt;integer_interval&lt;/csymbol&gt;
      &lt;cn type="integer"&gt;0&lt;/cn&gt;
      &lt;ci&gt;n&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munderover&gt;
  &lt;mo&gt;&amp;#x22C0;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;
  &lt;mi&gt;n&lt;/mi&gt;
 &lt;/munderover&gt;
 &lt;mrow&gt;
  &lt;mo&gt;(&lt;/mo&gt;
  &lt;msub&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;/msub&gt;
  &lt;mo&gt;&amp;gt;&lt;/mo&gt;
  &lt;mn&gt;0&lt;/mn&gt;
  &lt;mo&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/contm_and_bvar_ex.gif" alt="{\munderover\bigwedge{i=0}{n}{\left(a\sb{i} \gt 0 \right)}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.or" id="contm.or"></a>4.4.2.14 Or <code>&lt;or/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-logical</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#or">or</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>or</code> element represents the logical "or" function. It is
                     true if any of the arguments are true, and false otherwise.
                  </p>
                  <div class="mathml-example" id="logic1.or.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;or/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x2228;&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-or-ex1.gif" alt="{a\unicode{8744}b}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.xor" id="contm.xor"></a>4.4.2.15 Exclusive Or <code>&lt;xor/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-logical</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#xor">xor</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>xor</code> element represents the logical "xor"
                     function. It is true if there are an odd number of true arguments or
                     false otherwise.
                  </p>
                  <div class="mathml-example" id="logic1.xor.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;xor/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;xor&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-xor-ex1.gif" alt="{a\mathbin{\mathrm{xor}}b}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.not" id="contm.not"></a>4.4.2.16 Not <code>&lt;not/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-logical</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#not">not</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>note</code> element represents the logical not function
                     which takes one Boolean argument, and returns the opposite Boolean
                     value.
                  </p>
                  <div class="mathml-example" id="logic1.not.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;not/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#xac;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-not-ex1.gif" alt="{\unicode{172}a}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.implies" id="contm.implies"></a>4.4.2.17 Implies <code>&lt;implies/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-logical</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#implies">implies</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>implies</code> element represents the logical implication
                     function which takes two Boolean expressions as arguments. It
                     evaluates to false if the first argument is true and the second
                     argument is false, otherwise it evaluates to true.
                  </p>
                  <div class="mathml-example" id="logic1.implies.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;implies/&gt;&lt;ci&gt;A&lt;/ci&gt;&lt;ci&gt;B&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x21d2;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-implies-ex1.gif" alt="{A\unicode{8658}B}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.forall" id="contm.forall"></a>4.4.2.18 Universal quantifier <code>&lt;forall/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.quantifier">quantifier</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/quant1.xhtml#forall">forall</a>,
                              <a href="http://www.openmath.org/cd/logic1.xhtml#implies">implies</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>forall</code> element represents the universal ("for all")
                     quantifier which takes one or more bound variables, and an
                     argument which specifies the assertion being quantified.
                     In addition, <code>condition</code> or other qualifiers may be used as
                     described in <a href="chapter4-d.html#contm.quantifier">Section&nbsp;4.3.4.8 Quantifiers (class quantifier)</a> to limit the domain
                     of the bound variables.
                  </p>
                  <div class="mathml-example" id="quant1.forall.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;bind&gt;&lt;forall/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;eq/&gt;
    &lt;apply&gt;&lt;minus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;cn&gt;0&lt;/cn&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2200;&lt;/mo&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;.&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2212;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
   &lt;mo&gt;=&lt;/mo&gt;
   &lt;mn&gt;0&lt;/mn&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/quant1-forall-ex1.gif" alt="{\unicode{8704}x.{\left({{x\unicode{8722}x}={0}}\right)}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <div class="strict-mathml-example" id="quant1.forall.ex2">
                     <p>When the <code>forall</code> element is used with a <code>condition</code> qualifier the
                        strict equivalent is constructed with the help of logical implication by the rule
                        <a href="chapter4-d.html#contm.rewrite.quantifier">Rewrite: quantifier</a>.  Thus
                        
                        
                     </p><pre class="mathml">
&lt;bind&gt;&lt;forall/&gt;
  &lt;bvar&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;q&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;and/&gt;
      &lt;apply&gt;&lt;in/&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;rationals/&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;in/&gt;&lt;ci&gt;q&lt;/ci&gt;&lt;rationals/&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;lt/&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;ci&gt;q&lt;/ci&gt;&lt;/apply&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;lt/&gt;
    &lt;ci&gt;p&lt;/ci&gt;
    &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;q&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>
                        translates to 
                        
                     </p><pre class="strict-mathml">
&lt;bind&gt;&lt;csymbol cd="quant1"&gt;forall&lt;/csymbol&gt;
  &lt;bvar&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;q&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;csymbol cd="logic1"&gt;implies&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="logic1"&gt;and&lt;/csymbol&gt;
      &lt;apply&gt;&lt;csymbol cd="set1"&gt;in&lt;/csymbol&gt;
        &lt;ci&gt;p&lt;/ci&gt;
        &lt;csymbol cd="setname1"&gt;Q&lt;/csymbol&gt;
        &lt;/apply&gt;
      &lt;apply&gt;&lt;csymbol cd="set1"&gt;in&lt;/csymbol&gt;
        &lt;ci&gt;q&lt;/ci&gt;
        &lt;csymbol cd="setname1"&gt;Q&lt;/csymbol&gt;
      &lt;/apply&gt;
      &lt;apply&gt;&lt;csymbol cd="relation1"&gt;lt&lt;/csymbol&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;ci&gt;q&lt;/ci&gt;&lt;/apply&gt;
    &lt;/apply&gt;
    &lt;apply&gt;&lt;csymbol cd="relation1"&gt;lt&lt;/csymbol&gt;
      &lt;ci&gt;p&lt;/ci&gt;
      &lt;apply&gt;&lt;csymbol cd="arith1"&gt;power&lt;/csymbol&gt;
        &lt;ci&gt;q&lt;/ci&gt;
        &lt;cn&gt;2&lt;/cn&gt;
      &lt;/apply&gt;
    &lt;/apply&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2200;&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;Q&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;Q&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;.&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/quant1-forall-ex2.gif" alt="{\unicode{8704}{{p\unicode{8712}{\midoublestruck{Q}}}\unicode{8743}{q\unicode{8712}{\midoublestruck{Q}}}\unicode{8743}{\left.\middle(p\lt q\middle)\right.}}.{\left({p\lt\msup{q}{{2}}}\right)}}"></p>
                     </blockquote><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2200;&lt;/mo&gt;
 &lt;mrow&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;.&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mrow&gt;
    &lt;mo&gt;(&lt;/mo&gt;
    &lt;mrow&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;Q&lt;/mi&gt;&lt;/mrow&gt;
    &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
    &lt;mrow&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;Q&lt;/mi&gt;&lt;/mrow&gt;
    &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
    &lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;p&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;
    &lt;mo&gt;)&lt;/mo&gt;
   &lt;/mrow&gt;
   &lt;mo&gt;&amp;#x21d2;&lt;/mo&gt;
   &lt;mrow&gt;
    &lt;mo&gt;(&lt;/mo&gt;
    &lt;mi&gt;p&lt;/mi&gt;
    &lt;mo&gt;&amp;lt;&lt;/mo&gt;
    &lt;msup&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
    &lt;mo&gt;)&lt;/mo&gt;
   &lt;/mrow&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/quant1-forall-ex2-2.gif" alt="{ \unicode{8704} {p,q} . {\left({ {\left. \middle( {p\unicode{8712}{\midoublestruck{Q}}} \unicode{8743} {q\unicode{8712}{\midoublestruck{Q}}} \unicode{8743} {\left.\middle(p\lt q\middle)\right.} \middle) \right.} \unicode{8658} {\left. \middle( p \lt \msup{q}{{2}} \middle) \right.} }\right)} }"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.exists" id="contm.exists"></a>4.4.2.19 Existential quantifier <code>&lt;exists/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.quantifier">quantifier</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/quant1.xhtml#exists">exists</a>,
                              <a href="http://www.openmath.org/cd/logic1.xhtml#and">and</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>exists</code> element represents the existential ("there exists")
                     quantifier which takes one or more bound variables, and an
                     argument which specifies the assertion being quantified. In
                     addition, <code>condition</code> or other qualifiers may be used as 
                     described in <a href="chapter4-d.html#contm.quantifier">Section&nbsp;4.3.4.8 Quantifiers (class quantifier)</a> to limit the domain
                     of the bound variables.
                  </p>
                  <div class="mathml-example" id="quant1.exists.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;bind&gt;&lt;exists/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;eq/&gt;
    &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;cn&gt;0&lt;/cn&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2203;&lt;/mo&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;.&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
   &lt;mo&gt;=&lt;/mo&gt;
   &lt;mn&gt;0&lt;/mn&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/quant1-exists-ex1.gif" alt="{\unicode{8707}x.{\left({{\mathop{f}{\left(x\right)}}={0}}\right)}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="quant1.exists.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;exists/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;domainofapplication&gt;
    &lt;integers/&gt;
  &lt;/domainofapplication&gt;
   &lt;apply&gt;&lt;eq/&gt;
    &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;cn&gt;0&lt;/cn&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Strict MathML equivalent:</p><pre class="strict-mathml">
&lt;bind&gt;&lt;csymbol cd="quant1"&gt;exists&lt;/csymbol&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;csymbol cd="logic1"&gt;and&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="set1"&gt;in&lt;/csymbol&gt;
      &lt;ci&gt;x&lt;/ci&gt;
      &lt;csymbol cd="setname1"&gt;Z&lt;/csymbol&gt;
    &lt;/apply&gt;
    &lt;apply&gt;&lt;csymbol cd="relation1"&gt;eq&lt;/csymbol&gt;
      &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
      &lt;cn&gt;0&lt;/cn&gt;
    &lt;/apply&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2203;&lt;/mo&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;.&lt;/mo&gt;
 &lt;mfenced separators=""&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;Z&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
  &lt;mrow&gt;
   &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
   &lt;mo&gt;=&lt;/mo&gt;
   &lt;mn&gt;0&lt;/mn&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/quant1-exists-ex2.gif" alt="{\unicode{8707}x.{\left({x\unicode{8712}{\midoublestruck{Z}}}\unicode{8743}{{\mathop{f}{\left(x\right)}}={0}}\right)}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.abs" id="contm.abs"></a>4.4.2.20 Absolute Value <code>&lt;abs/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#abs">abs</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>abs</code> element represents the absolute value
                     function. The argument should be numerically valued. When the
                     argument is a complex number, the absolute value is often referred
                     to as the modulus.
                  </p>
                  <div class="mathml-example" id="arith1.abs.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;abs/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;|&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;|&lt;/mo&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-abs-ex1.gif" alt="{\left.\middle|x\middle|\right.}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.conjugate" id="contm.conjugate"></a>4.4.2.21 Complex conjugate <code>&lt;conjugate/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/complex1.xhtml#conjugate">conjugate</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>
                     The <code>conjugate</code> element represents the function defined
                     over the complex numbers with returns the complex conjugate of
                     its argument.
                     
                  </p>
                  <div class="mathml-example" id="complex1.conjugate.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;conjugate/&gt;
  &lt;apply&gt;&lt;plus/&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;apply&gt;&lt;times/&gt;&lt;cn&gt;&amp;#x2148;&lt;/cn&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mover&gt;
 &lt;mrow&gt;
  &lt;mi&gt;x&lt;/mi&gt;
  &lt;mo&gt;+&lt;/mo&gt;
  &lt;mrow&gt;&lt;mn&gt;&amp;#x2148;&lt;/mn&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;&amp;#xaf;&lt;/mo&gt;
&lt;/mover&gt;</pre><blockquote>
                        <p><img src="image/complex1-conjugate-ex1.gif" alt="{\overline{{x+{{\mn{\unicode{8520}}}\unicode{8290}y}}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.arg" id="contm.arg"></a>4.4.2.22 Argument <code>&lt;arg/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/complex1.xhtml#argument">argument</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>
                     The <code>arg</code> element represents the unary function which
                     returns the angular argument of a complex number, namely the
                     angle which a straight line drawn from the number to zero makes
                     with the real line (measured anti-clockwise). 
                     
                  </p>
                  <div class="mathml-example" id="complex1.argument.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;arg/&gt;
  &lt;apply&gt;&lt;plus/&gt;
    &lt;ci&gt; x &lt;/ci&gt;
    &lt;apply&gt;&lt;times/&gt;&lt;imaginaryi/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;arg&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mi&gt;x&lt;/mi&gt;
   &lt;mo&gt;+&lt;/mo&gt;
   &lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/complex1-argument-ex1.gif" alt="{\mathop{{\minormal{arg}}}{\left({x+{i\unicode{8290}y}}\right)}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.real" id="contm.real"></a>4.4.2.23 Real part <code>&lt;real/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/complex1.xhtml#real">real</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>
                     The <code>real</code> element represents the unary operator used to
                     construct an expression representing the "real" part of a
                     complex number, that is, the <var>x</var> component in <var>x</var> + i<var>y</var>.
                     
                  </p>
                  <div class="mathml-example" id="complex1.real.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;real/&gt;
  &lt;apply&gt;&lt;plus/&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;apply&gt;&lt;times/&gt;&lt;imaginaryi/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x211b;&lt;/mo&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mi&gt;x&lt;/mi&gt;
   &lt;mo&gt;+&lt;/mo&gt;
   &lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/complex1-real-ex1.gif" alt="{\unicode{8475}\unicode{8289}{\left({x+{i\unicode{8290}y}}\right)}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.imaginary" id="contm.imaginary"></a>4.4.2.24 Imaginary part <code>&lt;imaginary/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/complex1.xhtml#imaginary">imaginary</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>
                     The <code>imaginary</code> element represents the unary operator used to
                     construct an expression representing the "imaginary" part of a
                     complex number, that is, the <var>y</var> component in <var>x</var> + i<var>y</var>.
                     
                  </p>
                  <div class="mathml-example" id="complex1.imaginary.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;imaginary/&gt;
  &lt;apply&gt;&lt;plus/&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;apply&gt;&lt;times/&gt;&lt;imaginaryi/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2111;&lt;/mo&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;
  &lt;mrow&gt;
   &lt;mi&gt;x&lt;/mi&gt;
   &lt;mo&gt;+&lt;/mo&gt;
   &lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
  &lt;/mrow&gt;
 &lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/complex1-imaginary-ex1.gif" alt="{\unicode{8465}\unicode{8289}{\left({x+{i\unicode{8290}y}}\right)}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.lcm" id="contm.lcm"></a>4.4.2.25 Lowest common multiple <code>&lt;lcm/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#lcm">lcm</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>lcm</code> element represents the n-ary operator used to
                     construct an expression which represents the least common multiple
                     of its arguments. If no argument is provided, the lcm is 1. If one
                     argument is provided, the lcm is that argument. The least common
                     multiple of <var>x</var> and 1 is <var>x</var>.
                  </p>
                  <div class="mathml-example" id="arith1.lcm.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;lcm/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;ci&gt;c&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;lcm&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-lcm-ex1.gif" alt="{\mathop{{\minormal{lcm}}}{\left(a,b,c\right)}}"></p>
                     </blockquote>
                  </div>
                  <p>This default rendering is English-language locale specific: other locales may have
                     different default renderings.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.floor" id="contm.floor"></a>4.4.2.26 Floor <code>&lt;floor/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/rounding1.xhtml#floor">floor</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>floor</code> element represents the operation that rounds
                     down (towards negative infinity) to the nearest integer. This
                     function takes one real number as an argument and returns an
                     integer.
                  </p>
                  <div class="mathml-example" id="rounding1.floor.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;floor/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x230a;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x230b;&lt;/mo&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/rounding1-floor-ex1.gif" alt="{\unicode{8970}a\unicode{8971}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.ceiling" id="contm.ceiling"></a>4.4.2.27 Ceiling <code>&lt;ceiling/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/rounding1.xhtml#ceiling">ceiling</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>ceiling</code> element represents the operation that rounds
                     up (towards positive infinity) to the nearest integer. This function
                     takes one real number as an argument and returns an integer.
                  </p>
                  <div class="mathml-example" id="rounding1.ceiling.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;ceiling/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x2308;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x2309;&lt;/mo&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/rounding1-ceiling-ex1.gif" alt="{\unicode{8968}a\unicode{8969}}"></p>
                     </blockquote>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.4.3" id="id.4.4.3"></a>4.4.3 Relations
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.eq" id="contm.eq"></a>4.4.3.1 Equals <code>&lt;eq/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#eq">eq</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>eq</code> elements represents the equality relation. While equality is a binary relation,
                     <code>el</code> may be used with more than two arguments, denoting a chain
                     of equalities, as described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>.
                  </p>
                  <div class="mathml-example" id="relation1.eq.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;cn type="rational"&gt;2&lt;sep/&gt;4&lt;/cn&gt;
  &lt;cn type="rational"&gt;1&lt;sep/&gt;2&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mrow&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-eq-ex1.gif" alt="{{{2}/{4}}={{1}/{2}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.neq" id="contm.neq"></a>4.4.3.2 Not Equals <code>&lt;neq/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#neq">neq</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>neq</code> element represents the binary inequality
                     relation, i.e. the relation "not equal to" which returns true unless
                     the two arguments are equal.
                  </p>
                  <div class="mathml-example" id="relation1.neq.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;neq/&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;&amp;#x2260;&lt;/mo&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-neq-ex1.gif" alt="{{3}\unicode{8800}{4}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.gt" id="contm.gt"></a>4.4.3.3 Greater than <code>&lt;gt/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#gt">gt</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>gt</code> element represents the "greater than" function
                     which returns true if the first argument is greater than the second, and
                     returns false otherwise. While this is a binary relation,
                     <code>gt</code> may be used with more than two arguments, denoting a chain
                     of inequalities, as described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>.
                  </p>
                  <div class="mathml-example" id="relation1.gt.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;gt/&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;&amp;gt;&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-gt-ex1.gif" alt="{{3}\gt{2}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.lt" id="contm.lt"></a>4.4.3.4 Less Than <code>&lt;lt/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#lt">lt</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>lt</code> element represents the "less than" function
                     which returns true if the first argument is less than the second, and
                     returns false otherwise. While this is a binary relation,
                     <code>lt</code> may be used with more than two arguments, denoting a chain
                     of inequalities, as described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>.
                  </p>
                  <div class="mathml-example" id="relation1.lt.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;lt/&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-lt-ex1.gif" alt="{{2}\lt{3}\lt{4}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.geq" id="contm.geq"></a>4.4.3.5 Greater Than or Equal <code>&lt;geq/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#geq">geq</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>geq</code> element represents the "greater than or equal to" function
                     which returns true if the first argument is greater than or equal to
                     the second, and returns false otherwise. While this is a binary relation,
                     <code>geq</code> may be used with more than two arguments, denoting a chain
                     of inequalities, as described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>.
                  </p>
                  <div class="strict-mathml-example" id="relation1.geq.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;geq/&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;</pre><p>Strict Content MathML</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="fns2"&gt;predicate_on_list&lt;/csymbol&gt;
 &lt;csymbol cd="reln1"&gt;geq&lt;/csymbol&gt;
 &lt;apply&gt;&lt;csymbol cd="list1"&gt;list&lt;/csymbol&gt;
  &lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;
 &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mo&gt;&amp;#x2265;&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;&amp;#x2265;&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-geq-ex1.gif" alt="{{4}\unicode{8805}{3}\unicode{8805}{3}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.leq" id="contm.leq"></a>4.4.3.6 Less Than or Equal <code>&lt;leq/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#leq">leq</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>leq</code> element represents the "less than or equal to" function
                     which returns true if the first argument is less than or equal to
                     the second, and returns false otherwise. While this is a binary relation,
                     <code>leq</code> may be used with more than two arguments, denoting a chain
                     of inequalities, as described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>.
                  </p>
                  <div class="mathml-example" id="relation1.leq.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;leq/&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;&amp;#x2264;&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;&amp;#x2264;&lt;/mo&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-leq-ex1.gif" alt="{{3}\unicode{8804}{3}\unicode{8804}{4}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.equivalent" id="contm.equivalent"></a>4.4.3.7 Equivalent <code>&lt;equivalent/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-logical</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#equivalent">equivalent</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>equivalent</code> element represents the relation that
                     asserts two Boolean expressions are logically equivalent,
                     that is have the same Boolean value for any inputs.
                  </p>
                  <div class="mathml-example" id="logic1.equivalent1.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;equivalent/&gt;
  &lt;ci&gt;a&lt;/ci&gt;
  &lt;apply&gt;&lt;not/&gt;&lt;apply&gt;&lt;not/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;a&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2261;&lt;/mo&gt;
 &lt;mrow&gt;&lt;mo&gt;&amp;#xac;&lt;/mo&gt;&lt;mrow&gt;&lt;mo&gt;&amp;#xac;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mrow&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-equivalent1-ex1.gif" alt="{a\unicode{8801}{\unicode{172}{\unicode{172}a}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.approx" id="contm.approx"></a>4.4.3.8 Approximately <code>&lt;approx/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/relation1.xhtml#approx">approx</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>approx</code> element represent the relation that asserts
                     the approximate equality of its arguments.
                  </p>
                  <div class="mathml-example" id="relation1.approx.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;approx/&gt;
  &lt;pi/&gt;
  &lt;cn type="rational"&gt;22&lt;sep/&gt;7&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;&amp;#x3c0;&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2243;&lt;/mo&gt;
 &lt;mrow&gt;&lt;mn&gt;22&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;7&lt;/mn&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/relation1-approx-ex1.gif" alt="{\unicode{960}\unicode{8771}{{22}/{7}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.factorof" id="contm.factorof"></a>4.4.3.9 Factor Of <code>&lt;factorof/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/integer1.xhtml#factorof">factorof</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>factorof</code> element is used to indicate the
                     mathematical relationship that the first argument "is a factor of"
                     the second. This relationship is true if and only 
                     if <var>b</var> mod <var>a</var> = 0.
                  </p>
                  <div class="mathml-example" id="integer1.factorof.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;factorof/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;|&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/integer1-factorof-ex1.gif" alt="{\left.a\middle|b\right.}"></p>
                     </blockquote>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.4.4" id="id.4.4.4"></a>4.4.4 Calculus and Vector Calculus
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.int" id="contm.int"></a>4.4.4.1 Integral <code>&lt;int/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">int</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/calculus1.xhtml#int">int</a> <a href="http://www.openmath.org/cd/calculus1.xhtml#defint">defint</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>int</code> element is the operator element for a definite or indefinite integral
                     over a function or a definite over an expression with a bound variable.
                  </p>
                  <div class="mathml-example" id="calculus1.int.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;int/&gt;&lt;sin/&gt;&lt;/apply&gt;
  &lt;cos/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mrow&gt;&lt;mi&gt;&amp;#x222b;&lt;/mi&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;/mrow&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mi&gt;cos&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/calculus1-int-ex1.gif" alt="{{\unicode{8747}{\minormal{sin}}}={\minormal{cos}}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="calculus1.defint.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;interval&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/interval&gt;
  &lt;cos/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msubsup&gt;&lt;mi&gt;&amp;#x222b;&lt;/mi&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;/msubsup&gt;&lt;mi&gt;cos&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/calculus1-defint-ex1.gif" alt="{\mosubsup\int{a}{b}{\minormal{cos}}}"></p>
                     </blockquote>
                  </div>
                  <p>The <code>int</code> element can also be used with bound variables serving as the
                     integration variables.
                  </p>
                  <div class="mathml-example" id="calculus1.defint.ex2">
                     <p>Content MathML</p>
                     <p> Here, definite integrals are indicated by providing qualifier elements specifying a
                        domain of integration (here a <code>lowlimit</code>/<code>uplimit</code> pair). This is perhaps
                        the most "standard" representation of this integral:
                     </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msubsup&gt;&lt;mi&gt;&amp;#x222b;&lt;/mi&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/msubsup&gt;
 &lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
 &lt;mi&gt;d&lt;/mi&gt;
 &lt;mi&gt;x&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/calculus1-defint-ex2.gif" alt="\mosubsup\int{0}{1} {\msup{x}{2}} d x"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>As an indefinite integral applied to a function, the <code>int</code> element corresponds to
                     the <a href="http://www.openmath.org/cd/calculus1.xhtml#int">int</a> symbol from the <a href="http://www.openmath.org/cd/calculus1.xhtml">calculus1</a> content
                     dictionary. As a definite integral applied to a function, the <code>int</code> element
                     corresponds to the <a href="http://www.openmath.org/cd/calculus1.xhtml#defint">defint</a> symbol
                     from the <a href="http://www.openmath.org/cd/calculus1.xhtml">calculus1</a> content dictionary.
                  </p>
                  <p>When no bound variables are present, the translation
                     of an indefinite integral to Strict Content Markup is straight
                     forward.  When bound variables are present, the following rule
                     should be used.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.p2s.int" id="contm.p2s.int"></a>Rewrite: int
                     </h5>
                     <p>Translate an indefinite integral, where 
                        <code> <span class="egmeta">expression-in-x</span> </code> is an
                        arbitrary expression involving the bound variable(s) 
                        <code> <span class="egmeta">x</span> </code>
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                        to the expression
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;int&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
     <span class="egmeta">expression-in-x</span> 
    &lt;/bind&gt;
  &lt;/apply&gt;
   <span class="egmeta">x</span> 
&lt;/apply&gt;</pre><p>
                        
                        Note that as <var>x</var> is not bound in the original indefinite integral,
                        the integrated function is applied to the variable <var>x</var> making it
                        an explicit free variable in Strict Content Markup expression, even though
                        it is bound in the subterm used as an argument to <a href="http://www.openmath.org/cd/calculus1.xhtml#int">int</a>.
                     </p>
                  </div>
                  <div class="strict-mathml-example" id="contm.strict-int">
                     <p>For instance, the expression
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;cos/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>
                        has the Strict Content MathML equivalent
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;int&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
      &lt;apply&gt;&lt;cos/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;/bind&gt;
  &lt;/apply&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/apply&gt;
</pre></div>
                  <p>For a definite integral without bound variables, the
                     translation is also straightforward.
                  </p>
                  <div class="strict-mathml-example" id="contm.strict-domainofapplication-nobvar">
                     <p> For instance, the integral of a differential form <var>f</var> over an arbitrary domain
                        <var>C</var> represented as
                        
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;domainofapplication&gt;&lt;ci&gt;C&lt;/ci&gt;&lt;/domainofapplication&gt;
  &lt;ci&gt;f&lt;/ci&gt;
&lt;/apply&gt;</pre><p>
                        
                        is equivalent to the Strict Content MathML:
                        
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="calculus1"&gt;defint&lt;/csymbol&gt;&lt;ci&gt;C&lt;/ci&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;/apply&gt;</pre><p>Note, however, the additional remarks on the translations of other
                        kinds of qualifiers that may be used to specify a domain of integration in the rules for
                        definite integrals following.
                     </p>
                  </div>
                  <p>When bound variables are present, the situation is more complicated in general, and the
                     following rules are used.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.p2s.defint" id="contm.p2s.defint"></a>Rewrite: defint
                     </h5>
                     <p>Translate a definite integral, where 
                        <code> <span class="egmeta">expression-in-x</span> </code> is an
                        arbitrary expression involving the bound variable(s) 
                        <code> <span class="egmeta">x</span> </code>
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;domainofapplication&gt; <span class="egmeta">D</span> &lt;/domainofapplication&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                        to the expression
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="calculus1"&gt;defint&lt;/csymbol&gt;
   <span class="egmeta">D</span>   
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
   <span class="egmeta">expression-in-x</span> 
  &lt;/bind&gt;
&lt;/apply&gt;</pre></div>
                  <p>But the definite integral with an <code>lowlimit</code>/<code>uplimit</code> pair carries the
                     strong intuition that the range of integration is oriented, and thus swapping lower and
                     upper limits will change the sign of the result. To accommodate this, use the following special
                     translation rule:
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.p2s.int.LUlimit" id="contm.p2s.int.LUlimit"></a>Rewrite: defint limits
                     </h5><pre class="mathml">
&lt;apply&gt;&lt;int/&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;lowlimit&gt; <span class="egmeta">a</span> &lt;/lowlimit&gt;
  &lt;uplimit&gt; <span class="egmeta">b</span> &lt;/uplimit&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                        where
                        <code> <span class="egmeta">expression-in-x</span> </code>
                        is an expression in the variable <var>x</var>
                        is translated to to the expression:
                     </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="calculus1"&gt;defint&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="interval1"&gt;oriented_interval&lt;/csymbol&gt;
     <span class="egmeta">a</span>   <span class="egmeta">b</span> 
  &lt;/apply&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
   <span class="egmeta">expression-in-x</span> 
  &lt;/bind&gt;
&lt;/apply&gt;</pre><p>The <a href="http://www.openmath.org/cd/interval1.xhtml#oriented_interval">oriented_interval</a>
                        symbol is also used when translating the <code>interval</code>
                        qualifier, when it is used to specify the domain of integration.
                        Integration is assumed to proceed from the left endpoint to the
                        right endpoint.
                     </p>
                     <p>The case for multiple integrands is treated analogously.</p>
                  </div>
                  <div class="strict-mathml-example" id="contm.strict-condition">
                     <p>Note that use of the <code>condition</code>
                        qualifier also
                        requires special treatment.  In particular, it extends to multivariate domains by
                        using extra bound variables and a domain corresponding to a cartesian product as in:
                     </p><pre class="mathml">
&lt;bind&gt;&lt;int/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;and/&gt;
      &lt;apply&gt;&lt;leq/&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;leq/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;leq/&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;leq/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;times/&gt;
    &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/bind&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="calculus1"&gt;defint&lt;/csymbol&gt;
 &lt;apply&gt;&lt;csymbol cd="set1"&gt;suchthat&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="set1"&gt;cartesianproduct&lt;/csymbol&gt;
   &lt;csymbol cd="setname1"&gt;R&lt;/csymbol&gt;
   &lt;csymbol cd="setname1"&gt;R&lt;/csymbol&gt;
  &lt;/apply&gt;
  &lt;apply&gt;&lt;csymbol cd="logic1"&gt;and&lt;/csymbol&gt;
   &lt;apply&gt;&lt;csymbol cd="arith1"&gt;leq&lt;/csymbol&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
   &lt;apply&gt;&lt;csymbol cd="arith1"&gt;leq&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
   &lt;apply&gt;&lt;csymbol cd="arith1"&gt;leq&lt;/csymbol&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
   &lt;apply&gt;&lt;csymbol cd="arith1"&gt;leq&lt;/csymbol&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;
  &lt;/apply&gt;
  &lt;bind&gt;&lt;csymbol cd="fns11"&gt;lambda&lt;/csymbol&gt;
   &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
   &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
   &lt;apply&gt;&lt;csymbol cd="arith1"&gt;times&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;power&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;power&lt;/csymbol&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;
   &lt;/apply&gt;
  &lt;/bind&gt;
 &lt;/apply&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.diff" id="contm.diff"></a>4.4.4.2 Differentiation <code>&lt;diff/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">Differential-Operator</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/calculus1.xhtml#diff">diff</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>diff</code> element is the differentiation operator element for functions or
                     expressions of a single variable.  It may be applied directly to an actual function
                     thereby denoting a function which is the derivative of the original function, or it can be
                     applied to an expression involving a single variable.
                  </p>
                  <div class="mathml-example" id="calculus1.diff.ex2">
                     <p>Content MathML</p><pre class="mathml">&lt;apply&gt;&lt;diff/&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msup&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2032;&lt;/mo&gt;&lt;/msup&gt;</pre><blockquote>
                        <p><img src="image/calculus1-diff-ex2.gif" alt="\msup{f}{\unicode{8242}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="calculus1.diff.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;diff/&gt;
    &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
    &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
  &lt;apply&gt;&lt;cos/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mfrac&gt;
  &lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;&lt;/mrow&gt;
  &lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/mfrac&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mrow&gt;&lt;mi&gt;cos&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/calculus1-diff-ex1.gif" alt="{ {\frac{{d{\mathop{{\minormal{sin}}}x}}}{{dx}}} = {\mathop{{\minormal{cos}}}x} }"></p>
                     </blockquote>
                  </div>
                  <p>The <code>bvar</code> element may also contain a <code>degree</code> element, which specifies
                     the order of the derivative to be taken.
                  </p>
                  <div class="mathml-example" id="calculus1.diff.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;diff/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;degree&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/degree&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mfrac&gt;
 &lt;mrow&gt;
  &lt;msup&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
  &lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;/msup&gt;
 &lt;/mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;d&lt;/mi&gt;&lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;/mrow&gt;
&lt;/mfrac&gt;</pre></div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>For the translation to strict Markup it is crucial to realize that in the expression
                     case, the variable is actually not bound by the differentiation operator.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.p2s.diff" id="contm.p2s.diff"></a>Rewrite: diff
                     </h5>
                     <p>Translate an expression 
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;diff/&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>
                        where
                        <code> <span class="egmeta">expression-in-x</span> </code> is an
                        expression in the variable <var>x</var>
                        to the expression
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;diff&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
     <span class="egmeta">E</span> 
    &lt;/bind&gt;
  &lt;/apply&gt;
   <span class="egmeta">x</span> 
&lt;/apply&gt;</pre><p>
                        Note that the differentiated function is applied to the variable
                        <var>x</var> making its status as a free variable explicit in strict
                        markup. Thus the strict equivalent of  
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;diff/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>
                        is
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;diff&lt;/csymbol&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
      &lt;apply&gt;&lt;csymbol cd="transc1"&gt;sin&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;/bind&gt;
  &lt;/apply&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/apply&gt;</pre></div>
                  <p>If the <code>bvar</code> element contains a <code>degree</code> element, use the
                     <code>nthdiff</code> symbol.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.p2s.nthdiff" id="contm.p2s.nthdiff"></a>Rewrite: nthdiff
                     </h5><pre class="mathml">
&lt;apply&gt;&lt;diff/&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;degree&gt; <span class="egmeta">n</span> &lt;/degree&gt;&lt;/bvar&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>where
                        <code> <span class="egmeta">expression-in-x</span> </code> is an
                        is an expression in the variable <var>x</var>
                        is translated to to the expression:
                     </p><pre class="mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;nthdiff&lt;/csymbol&gt;
     <span class="egmeta">n</span> 
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
     <span class="egmeta">expression-in-x</span> 
    &lt;/bind&gt;
  &lt;/apply&gt;
   <span class="egmeta">x</span> 
&lt;/apply&gt;</pre></div>
                  <div class="strict-mathml-example" id="contm.nthdiff.ex">
                     <p>For example</p><pre class="mathml">
&lt;apply&gt;&lt;diff/&gt;
  &lt;bvar&gt;&lt;degree&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/degree&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;nthdiff&lt;/csymbol&gt;
    &lt;cn&gt;2&lt;/cn&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
      &lt;apply&gt;&lt;csymbol cd="transc1"&gt;sin&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;/bind&gt;
  &lt;/apply&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.partialdiff" id="contm.partialdiff"></a>4.4.4.3 Partial Differentiation <code>&lt;partialdiff/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">partialdiff</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/calculus1.xhtml#partialdiff">partialdiff</a> <a href="http://www.openmath.org/cd/calculus1.xhtml#partialdiffdegree">partialdiffdegree</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>partialdiff</code> element is the partial differentiation operator element for
                     functions or expressions in several variables.
                  </p>
                  <p>For the case of partial differentiation of a function, the
                     containing <code>partialdiff</code> takes two arguments: firstly a list of
                     indices indicating by position which function arguments are involved in
                     constructing the partial derivatives, and secondly the actual function
                     to be partially differentiated.  The indices may be repeated.
                  </p>
                  <div class="mathml-example" id="calculus1.partialdiff.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;partialdiff/&gt;
  &lt;list&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/list&gt;
  &lt;ci type="function"&gt;f&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msub&gt;
  &lt;mi&gt;D&lt;/mi&gt;
  &lt;mrow&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/mrow&gt;
 &lt;/msub&gt;
 &lt;mi&gt;f&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/calculus1-partialdiff-ex3.gif" alt="{\msub{D}{{{1},{1},{3}}}f}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="calculus1.partialdiff.ex3b">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;partialdiff/&gt;
  &lt;list&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/list&gt;
  &lt;lambda&gt;
   &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
   &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
   &lt;bvar&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/bvar&gt;
   &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/apply&gt;
  &lt;/lambda&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mfrac&gt;
 &lt;mrow&gt;
  &lt;msup&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msup&gt;
  &lt;mrow&gt;
   &lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;/mfenced&gt;
 &lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;/mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/mrow&gt;
&lt;/mfrac&gt;</pre><blockquote>
                        <p><img src="image/calculus1-partialdiff-ex3b.gif" alt="{\frac{{ {\msup{\unicode{8706}}{3}} {f{\left(x,y,z\right)}} }}{{ {\unicode{8706}{\msup{x}{2}}} {\unicode{8706}z} }}}"></p>
                     </blockquote>
                  </div>
                  <p>In the case of algebraic expressions, the bound variables are given by <code>bvar</code>
                     elements, which are children of the containing <code>apply</code> element. The <code>bvar</code>
                     elements may also contain <code>degree</code> element, which specify the order of the partial
                     derivative to be taken in that variable.
                  </p>
                  <div class="mathml-example" id="calculus1.partialdiff.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;partialdiff/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;ci type="function"&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mfrac&gt;
 &lt;mrow&gt;
  &lt;msup&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
  &lt;mrow&gt;
   &lt;mi&gt;f&lt;/mi&gt;
   &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
   &lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/mrow&gt;
&lt;/mfrac&gt;</pre><blockquote>
                        <p><img src="image/calculus1-partialdiff-ex2.gif" alt="{\frac{{\msup{\unicode{8706}}{{2}}{\mathop{f}{\left(x,y\right)}}}}{{{\unicode{8706}x}{\unicode{8706}y}}}}"></p>
                     </blockquote>
                  </div>
                  <p>Where a total degree of differentiation must be specified, this is
                     indicated by use of a <code>degree</code> element at the top level,
                     i.e. without any associated <code>bvar</code>, as a child of the
                     containing <code>apply</code> element.
                  </p>
                  <div class="mathml-example" id="calculus1.partialdiff.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;partialdiff/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;degree&gt;&lt;ci&gt;m&lt;/ci&gt;&lt;/degree&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;degree&gt;&lt;ci&gt;n&lt;/ci&gt;&lt;/degree&gt;&lt;/bvar&gt;
  &lt;degree&gt;&lt;ci&gt;k&lt;/ci&gt;&lt;/degree&gt;
  &lt;apply&gt;&lt;ci type="function"&gt;f&lt;/ci&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;ci&gt;y&lt;/ci&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mfrac&gt;
 &lt;mrow&gt;
  &lt;msup&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;mi&gt;k&lt;/mi&gt;&lt;/msup&gt;
  &lt;mrow&gt;
   &lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;m&lt;/mi&gt;&lt;/msup&gt;&lt;/mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;&amp;#x2202;&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mi&gt;n&lt;/mi&gt;&lt;/msup&gt;&lt;/mrow&gt;
 &lt;/mrow&gt;
&lt;/mfrac&gt;</pre><blockquote>
                        <p><img src="image/calculus1-partialdiff-ex1.gif" alt="{\frac{{\msup{\unicode{8706}}{k}{\mathop{f}{\left(x,y\right)}}}}{{{\unicode{8706}\msup{x}{m}}{\unicode{8706}\msup{y}{n}}}}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>When applied to a function, the <code>partialdiff</code> element
                     corresponds to the <a href="http://www.openmath.org/cd/calculus1.xhtml#partialdiff">partialdiff</a>
                     symbol from the <a href="http://www.openmath.org/cd/calculus1.xhtml">calculus1</a> content dictionary. No special
                     rules are necessary as the two arguments of <code>partialdiff</code>
                     translate directly to the two arguments of
                     <a href="http://www.openmath.org/cd/calculus1.xhtml#partialdiff">partialdiff</a>.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.p2s.partialdiff" id="contm.p2s.partialdiff"></a>Rewrite: partialdiffdegree
                     </h5>
                     <p>If <code>partialdiff</code> is used with an expression and
                        <code>bvar</code> qualifiers it is rewritten to
                        Strict Content MathML using the 
                        <a href="http://www.openmath.org/cd/calculus1.xhtml#partialdiffdegree">partialdiffdegree</a> symbol.
                        
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;partialdiff/&gt;
  &lt;bvar&gt; <span class="egmeta">x1</span> &lt;degree&gt; <span class="egmeta">n1</span> &lt;/degree&gt;&lt;/bvar&gt;
  &lt;bvar&gt; <span class="egmeta">xk</span> &lt;degree&gt; <span class="egmeta">nk</span> &lt;/degree&gt;&lt;/bvar&gt;
  &lt;degree&gt; <span class="egmeta">total-n1-nk</span> &lt;/degree&gt;
   <span class="egmeta">expression-in-x1-xk</span> 
&lt;/apply&gt;</pre><p>
                        <code> <span class="egmeta">expression-in-x1-xk</span> </code> is an
                        arbitrary expression involving the bound variables.
                     </p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;partialdiffdegree&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="list1"&gt;list&lt;/csymbol&gt;
       <span class="egmeta">n1</span>   <span class="egmeta">nk</span> 
    &lt;/apply&gt;
     <span class="egmeta">total-n1-nk</span> 
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x1</span> &lt;/bvar&gt;
    &lt;bvar&gt; <span class="egmeta">xk</span> &lt;/bvar&gt;
     <span class="egmeta">A</span> 
   &lt;/bind&gt;
  &lt;/apply&gt;
   <span class="egmeta">x1</span> 
   <span class="egmeta">xk</span> 
&lt;/apply&gt;</pre><p>If any of the bound variables do not use a <code>degree</code> qualifier, 
                        <code>&lt;cn&gt;1&lt;/cn&gt;</code> should be used in place of the degree.
                        If the original expression did not use the total degree qualifier then 
                        the second argument to <a href="http://www.openmath.org/cd/calculus1.xhtml#partialdiffdegree">partialdiffdegree</a>
                        should be the sum of the degrees, for example
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
   <span class="egmeta">n1</span>   <span class="egmeta">nk</span> 
&lt;/apply&gt;</pre></div>
                  <div class="strict-mathml-example" id="contm.p2s.partialdiff.ex1">
                     <p>With this rule, the expression
                        
                     </p><pre class="mathml">
&lt;apply&gt;&lt;partialdiff/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;degree&gt;&lt;ci&gt;n&lt;/ci&gt;&lt;/degree&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;degree&gt;&lt;ci&gt;m&lt;/ci&gt;&lt;/degree&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;sin/&gt;
    &lt;apply&gt;&lt;times/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>
                        is translated into 
                        
                     </p><pre class="strict-mathml">
&lt;apply&gt;
  &lt;apply&gt;&lt;csymbol cd="calculus1"&gt;partialdiffdegree&lt;/csymbol&gt;
    &lt;apply&gt;&lt;csymbol cd="list1"&gt;list&lt;/csymbol&gt;
      &lt;ci&gt;n&lt;/ci&gt;&lt;ci&gt;m&lt;/ci&gt;
    &lt;/apply&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
      &lt;ci&gt;n&lt;/ci&gt;&lt;ci&gt;m&lt;/ci&gt;
    &lt;/apply&gt;
    &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
      &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
      &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
      &lt;apply&gt;&lt;csymbol cd="transc1"&gt;sin&lt;/csymbol&gt;
        &lt;apply&gt;&lt;csymbol cd="arith1"&gt;times&lt;/csymbol&gt;
          &lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;
        &lt;/apply&gt;
      &lt;/apply&gt;
    &lt;/bind&gt;
    &lt;ci&gt;x&lt;/ci&gt;
    &lt;ci&gt;y&lt;/ci&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.divergence" id="contm.divergence"></a>4.4.4.4 Divergence <code>&lt;divergence/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-veccalc</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/veccalc1.xhtml#divergence">divergence</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>divergence</code> element is the vector calculus divergence
                     operator, often called div. It represents the divergence function
                     which takes one argument which should be a vector of scalar-valued
                     functions, intended to represent a vector-valued function, and returns
                     the scalar-valued function giving the divergence of the argument.
                  </p>
                  <div class="mathml-example" id="veccalc1.divergence.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;divergence/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;div&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-divergence-ex1.gif" alt="{\mathop{{\minormal{div}}}{\left(a\right)}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="veccalc1.divergence.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;divergence/&gt;
  &lt;ci type="vector"&gt;E&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;div&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;E&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-divergence-ex2.gif" alt="{\mathop{{\minormal{div}}}{\left(E\right)}}"></p>
                     </blockquote><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x2207;&lt;/mo&gt;&lt;mo&gt;&amp;#x22c5;&lt;/mo&gt;&lt;mi&gt;E&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-divergence-ex2-2.gif" alt="{\unicode{8711}\unicode{8901}E}"></p>
                     </blockquote>
                  </div>
                  <p>The functions defining the coordinates may be defined implicitly as expressions defined
                     in terms of the coordinate names, in which case the coordinate names must be provided as
                     bound variables.
                  </p>
                  <div class="mathml-example" id="veccalc1.divergence.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;divergence/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/bvar&gt;
  &lt;vector&gt;
    &lt;apply&gt;&lt;plus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;plus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;plus/&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;/vector&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;div&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mo&gt;(&lt;/mo&gt;
 &lt;mtable&gt;
  &lt;mtr&gt;&lt;mtd&gt;
   &lt;mi&gt;x&lt;/mi&gt;
   &lt;mo&gt;&amp;#x21a6;&lt;/mo&gt;
   &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
  &lt;/mtd&gt;&lt;/mtr&gt;
  &lt;mtr&gt;&lt;mtd&gt;
   &lt;mi&gt;y&lt;/mi&gt;
   &lt;mo&gt;&amp;#x21a6;&lt;/mo&gt;
   &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;/mrow&gt;
  &lt;/mtd&gt;&lt;/mtr&gt;
  &lt;mtr&gt;&lt;mtd&gt;
   &lt;mi&gt;z&lt;/mi&gt;
   &lt;mo&gt;&amp;#x21a6;&lt;/mo&gt;
   &lt;mrow&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
  &lt;/mtd&gt;&lt;/mtr&gt;
 &lt;/mtable&gt;
 &lt;mo&gt;)&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-divergence-ex3.gif" alt="{\left.\mathop{{\minormal{div}}}\middle({\begin{matrix}x\unicode{8614}{x+y}\\y\unicode{8614}{x+z}\\z\unicode{8614}{z+y}\end{matrix}}\middle)\right.}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.grad" id="contm.grad"></a>4.4.4.5 Gradient <code>&lt;grad/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-veccalc</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/veccalc1.xhtml#grad">grad</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>grad</code> element is the vector calculus gradient operator, often called
                     grad. It is used to represent the grad function, which takes one
                     argument which should be a scalar-valued function and returns a
                     vector of functions.
                  </p>
                  <div class="mathml-example" id="veccalc1.gradient.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;grad/&gt;&lt;ci type="function"&gt;f&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;grad&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-gradient-ex1.gif" alt="{\mathop{{\minormal{grad}}}{\left(f\right)}}"></p>
                     </blockquote><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x2207;&lt;/mo&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-gradient-ex1-2.gif" alt="{\unicode{8711}\unicode{8289}{\left(f\right)}}"></p>
                     </blockquote>
                  </div>
                  <p>The functions defining the coordinates may be defined implicitly as expressions
                     defined in terms of the coordinate names, in which case the coordinate names must be
                     provided as bound variables.
                  </p>
                  <div class="mathml-example" id="veccalc1.gradient.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;grad/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;times/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;grad&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mo&gt;(&lt;/mo&gt;
  &lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;mo&gt;&amp;#x21a6;&lt;/mo&gt;
  &lt;mrow&gt;
   &lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;z&lt;/mi&gt;
  &lt;/mrow&gt;
  &lt;mo&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-gradient-ex2.gif" alt="{\mathop{{\minormal{grad}}}{\left.\middle({\left(x,y,z\right)}\unicode{8614}{x\unicode{8290}y\unicode{8290}z}\middle)\right.}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.curl" id="contm.curl"></a>4.4.4.6 Curl <code>&lt;curl/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-veccalc</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/veccalc1.xhtml#curl">curl</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>curl</code> element is used to represent the curl function
                     of vector calculus. It takes one argument which should be a vector
                     of scalar-valued functions, intended to represent a vector-valued
                     function, and returns a vector of functions.
                  </p>
                  <div class="mathml-example" id="veccalc1.curl.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;curl/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;curl&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-curl-ex1.gif" alt="{\mathop{{\minormal{curl}}}{\left(a\right)}}"></p>
                     </blockquote><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x2207;&lt;/mo&gt;&lt;mo&gt;&amp;#xd7;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-curl-ex1-2.gif" alt="{\unicode{8711}\unicode{215}a}"></p>
                     </blockquote>
                  </div>
                  <p>The functions defining the coordinates may be defined implicitly as expressions
                     defined in terms of the coordinate names, in which case the coordinate names must be
                     provided as bound variables.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.laplacian" id="contm.laplacian"></a>4.4.4.7 Laplacian <code>&lt;laplacian/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-veccalc</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/veccalc1.xhtml#Laplacian">Laplacian</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>laplacian</code> element represents the Laplacian operator of
                     vector calculus.  The Laplacian takes a single argument which is a
                     vector of scalar-valued functions representing a vector-valued
                     function, and returns a vector of functions.
                  </p>
                  <div class="mathml-example" id="veccalc1.laplacian.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;laplacian/&gt;&lt;ci type="vector"&gt;E&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msup&gt;&lt;mo&gt;&amp;#x2207;&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mi&gt;E&lt;/mi&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-laplacian-ex1.gif" alt="{\msup{\unicode{8711}}{{2}}\unicode{8289}{\left(E\right)}}"></p>
                     </blockquote>
                  </div>
                  <p>The functions defining the coordinates may be defined implicitly as expressions
                     defined in terms of the coordinate names, in which case the coordinate names must be
                     provided as bound variables.
                  </p>
                  <div class="mathml-example" id="veccalc1.laplacian.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;laplacian/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci&gt;z&lt;/ci&gt;&lt;/bvar&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msup&gt;&lt;mo&gt;&amp;#x2207;&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mo&gt;(&lt;/mo&gt;
  &lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;mi&gt;z&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;mo&gt;&amp;#x21a6;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
  &lt;mo&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/veccalc1-laplacian-ex2.gif" alt="{\msup{\unicode{8711}}{{2}}\unicode{8289}{\left.\middle({\left(x,y,z\right)}\unicode{8614}{\mathop{f}{\left(x,y\right)}}\middle)\right.}}"></p>
                     </blockquote>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.sets" id="contm.sets"></a>4.4.5 Theory of Sets
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.set" id="contm.set"></a>4.4.5.1 Set <code>&lt;set&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-setlist-constructor</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>, <a href="appendixa-d.html#parsing_type">type</a>?
                           </td>
                        </tr>
                        <tr>
                           <th><code>type</code> Attribute Values
                           </th>
                           <td>"set" | "multiset" | text </td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           </td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#set">set</a>, <a href="http://www.openmath.org/cd/multiset1.xhtml#multiset">multiset</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>set</code> represents a function which constructs
                     mathematical sets from its arguments. It is an n-ary function. The
                     members of the set to be constructed may be given explicitly as
                     child elements of the constructor, or specified by rule as described
                     in <a href="chapter4-d.html#contm.container.constructor">Section&nbsp;4.3.1.1 Container Markup for Constructor Symbols</a>.  There is no implied ordering to
                     the elements of a set.
                  </p>
                  <div class="mathml-example" id="set1.set.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;set&gt;
  &lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;ci&gt;c&lt;/ci&gt;
&lt;/set&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;{&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;mo&gt;}&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-set-ex1.gif" alt="{\left.\middle\{a,b,c\middle\}\right.}"></p>
                     </blockquote>
                  </div>
                  <p>In general, a set can be constructed by providing a function and a domain of
                     application.  The elements of the set correspond to the values obtained by evaluating
                     the function at the points of the domain.
                  </p>
                  <div class="mathml-example" id="set1.suchthat.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;set&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;lt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;5&lt;/cn&gt;&lt;/apply&gt;
  &lt;/condition&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/set&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;{&lt;/mo&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;|&lt;/mo&gt;
 &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mn&gt;5&lt;/mn&gt;&lt;/mrow&gt;
 &lt;mo&gt;}&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-suchthat-ex1.gif" alt="{\left.\middle\{x\middle|{x\lt{5}}\middle\}\right.}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="set1.suchthat.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;set&gt;
  &lt;bvar&gt;&lt;ci type="set"&gt;S&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;in/&gt;&lt;ci&gt;S&lt;/ci&gt;&lt;ci type="list"&gt;T&lt;/ci&gt;&lt;/apply&gt;
  &lt;/condition&gt;
  &lt;ci&gt;S&lt;/ci&gt;
&lt;/set&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;{&lt;/mo&gt;
 &lt;mi&gt;S&lt;/mi&gt;
 &lt;mo&gt;|&lt;/mo&gt;
 &lt;mrow&gt;&lt;mi&gt;S&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;}&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-suchthat-ex2.gif" alt="{\left.\middle\{S\middle|{S\unicode{8712}T}\middle\}\right.}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="set1.suchthat.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;set&gt;
  &lt;bvar&gt;&lt;ci&gt; x &lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;and/&gt;
      &lt;apply&gt;&lt;lt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;5&lt;/cn&gt;&lt;/apply&gt;
      &lt;apply&gt;&lt;in/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;naturalnumbers/&gt;&lt;/apply&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/set&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;{&lt;/mo&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;|&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;&lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mn&gt;5&lt;/mn&gt;&lt;mo&gt;)&lt;/mo&gt;&lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
  &lt;mrow&gt;
   &lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;N&lt;/mi&gt;
  &lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;}&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-suchthat-ex3.gif" alt="{\left.\middle\{x\middle|{{\left.\middle(x\lt{5}\middle)\right.}\unicode{8743}{x\unicode{8712}{\midoublestruck{N}}}}\middle\}\right.}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.list" id="contm.list"></a>4.4.5.2 List <code>&lt;list&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-setlist-constructor</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>,  <a href="appendixa-d.html#parsing_order">order</a></td>
                        </tr>
                        <tr>
                           <th><code>order</code> Attribute Values
                           </th>
                           <td>"numeric" | "lexicographic"</td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           </td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/interval1.xhtml#interval_cc">interval_cc</a>, <a href="http://www.openmath.org/cd/list1.xhtml#list">list</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>list</code> elements represents the n-ary function which
                     constructs a list from its arguments. Lists differ from sets in that
                     there is an explicit order to the elements.
                  </p>
                  <p>The list entries and order may be given explicitly.</p>
                  <div class="mathml-example" id="list1.list.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;list&gt;
  &lt;ci&gt;a&lt;/ci&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;ci&gt;c&lt;/ci&gt;
&lt;/list&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;(&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;b&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;c&lt;/mi&gt;&lt;mo&gt;)&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/list1-list-ex1.gif" alt="{\left.\middle(a,b,c\middle)\right.}"></p>
                     </blockquote>
                  </div>
                  <p>In general a list can be constructed by providing a function and
                     a domain of application.  The elements of the list correspond to the
                     values obtained by evaluating the function at the points of the
                     domain. When this method is used, the ordering of the list elements
                     may not be clear, so the kind of ordering may be specified by the
                     <code>order</code> attribute.  Two orders are supported: lexicographic
                     and numeric.
                  </p>
                  <div class="mathml-example" id="list1.suchthat.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;list order="numeric"&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;lt/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;5&lt;/cn&gt;&lt;/apply&gt;
  &lt;/condition&gt;
&lt;/list&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;(&lt;/mo&gt;
 &lt;mi&gt;x&lt;/mi&gt;
 &lt;mo&gt;|&lt;/mo&gt;
 &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;lt;&lt;/mo&gt;&lt;mn&gt;5&lt;/mn&gt;&lt;/mrow&gt;
 &lt;mo&gt;)&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/list1-suchthat-ex1.gif" alt="{\left.\middle(x\middle|{x\lt{5}}\middle)\right.}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.union" id="contm.union"></a>4.4.5.3 Union <code>&lt;union/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#union">union</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>union</code> element is used to denote the n-ary union of sets. It takes sets as arguments,
                     and denotes the set that contains all the elements that occur in any
                     of them.
                  </p>
                  <p>Arguments may be explicitly specified.</p>
                  <div class="mathml-example" id="set1.union.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;union/&gt;&lt;ci&gt;A&lt;/ci&gt;&lt;ci&gt;B&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x222a;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-union-ex1.gif" alt="{A\unicode{8746}B}"></p>
                     </blockquote>
                  </div>
                  <p>Arguments may also be specified using qualifier elements as described in
                     <a href="chapter4-d.html#contm.nary">Section&nbsp;4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                        nary-linalg, nary-set, nary-constructor)</a>. operator element can be used as a binding
                     operator to construct the union over a collection of sets.
                  </p>
                  <div class="mathml-example" id="set1.big.union.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;union/&gt;
  &lt;bvar&gt;&lt;ci type="set"&gt;S&lt;/ci&gt;&lt;/bvar&gt;
  &lt;domainofapplication&gt;
    &lt;ci type="list"&gt;L&lt;/ci&gt;
  &lt;/domainofapplication&gt;
  &lt;ci type="set"&gt; S&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;munder&gt;&lt;mo&gt;&amp;#x22c3;&lt;/mo&gt;&lt;mi&gt;L&lt;/mi&gt;&lt;/munder&gt;&lt;mi&gt;S&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-big_union-ex1.gif" alt="{\munder{\unicode{8899}}{L}S}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.intersect" id="contm.intersect"></a>4.4.5.4 Intersect <code>&lt;intersect/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#intersect">intersect</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>intersect</code> element is used to denote the n-ary
                     intersection of sets. It takes sets as arguments, and denotes the
                     set that contains all the elements that occur in all of them.  Its arguments may be explicitly specified in the
                     enclosing <code>apply</code> element, or specified using qualifier
                     elements as described in <a href="chapter4-d.html#contm.nary">Section&nbsp;4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                        nary-linalg, nary-set, nary-constructor)</a>.
                  </p>
                  <div class="mathml-example" id="set1.intersect.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;intersect/&gt;
  &lt;ci type="set"&gt; A &lt;/ci&gt;
  &lt;ci type="set"&gt; B &lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2229;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-intersect-ex1.gif" alt="{A\unicode{8745}B}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="set1.big.intersect.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;intersect/&gt;
  &lt;bvar&gt;&lt;ci type="set"&gt;S&lt;/ci&gt;&lt;/bvar&gt;
  &lt;domainofapplication&gt;&lt;ci type="list"&gt;L&lt;/ci&gt;&lt;/domainofapplication&gt;
  &lt;ci type="set"&gt; S &lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;munder&gt;&lt;mo&gt;&amp;#x22c2;&lt;/mo&gt;&lt;mi&gt;L&lt;/mi&gt;&lt;/munder&gt;&lt;mi&gt;S&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-big_intersect-ex1.gif" alt="{\munder{\unicode{8898}}{L}S}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.in" id="contm.in"></a>4.4.5.5 Set inclusion <code>&lt;in/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#in">in</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>in</code> element represents the set inclusion relation.
                     It has two arguments, an element and a set. It is used to denote
                     that the element is in the given set.
                  </p>
                  <div class="mathml-example" id="set1.in.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci type="set"&gt;A&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-in-ex1.gif" alt="{a\unicode{8712}A}"></p>
                     </blockquote>
                  </div>
                  <p>When translating to Strict Content Markup, if the <code>type</code>
                     has value "multiset", then the <a href="http://www.openmath.org/cd/multiset1.xhtml#in">in</a> symbol from <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a> should
                     be used instead.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.notin" id="contm.notin"></a>4.4.5.6 Set exclusion <code>&lt;notin/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#notin">notin</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>notin</code> represents the negated set inclusion
                     relation. It has two arguments, an element and a set. It is
                     used to denote that the element is not in the given set.
                  </p>
                  <div class="mathml-example" id="set1.notin.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;notin/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;ci type="set"&gt;A&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;&amp;#x2209;&lt;/mo&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-notin-ex1.gif" alt="{a\unicode{8713}A}"></p>
                     </blockquote>
                  </div>
                  <p>When translating to Strict Content Markup, if the <code>type</code> has value "multiset", then
                     the <a href="http://www.openmath.org/cd/multiset1.xhtml#in">in</a> symbol from <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a> should be used instead.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.subset" id="contm.subset"></a>4.4.5.7 Subset <code>&lt;subset/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.reln">nary-set-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#subset">subset</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>subset</code> element represents the subset relation.  It is used to denote that the
                     first argument is a subset of the second.  As described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>, it may also be used as an n-ary operator to express
                     that each argument is a subset of its predecessor.
                  </p>
                  <div class="mathml-example" id="set1.subset.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;subset/&gt;
  &lt;ci type="set"&gt;A&lt;/ci&gt;
  &lt;ci type="set"&gt;B&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2286;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-subset-ex1.gif" alt="{A\unicode{8838}B}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.prsubset" id="contm.prsubset"></a>4.4.5.8 Proper Subset <code>&lt;prsubset/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.reln">nary-set-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#prsubset">prsubset</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>prsubset</code> element represents the proper subset
                     relation, i.e. that the first argument is a proper subset of the
                     second.  As described in <a href="chapter4-d.html#contm.nary.reln">Section&nbsp;4.3.4.3 N-ary Relations (classes nary-reln, nary-set-reln)</a>, it may
                     also be used as an n-ary operator to express that each argument is a
                     proper subset of its predecessor.
                  </p>
                  <div class="mathml-example" id="set1.prsubset.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;prsubset/&gt;
  &lt;ci type="set"&gt;A&lt;/ci&gt;
  &lt;ci type="set"&gt;B&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2282;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-prsubset-ex1.gif" alt="{A\unicode{8834}B}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.notsubset" id="contm.notsubset"></a>4.4.5.9 Not Subset <code>&lt;notsubset/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#notsubset">notsubset</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>notsubset</code> element represents the negated subset
                     relation. It is used to denote that the first argument is not a subset of the
                     second.
                  </p>
                  <div class="mathml-example" id="set1.notsubset.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;notsubset/&gt;
  &lt;ci type="set"&gt;A&lt;/ci&gt;
  &lt;ci type="set"&gt;B&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2288;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-notsubset-ex1.gif" alt="{A\unicode{8840}B}"></p>
                     </blockquote>
                  </div>
                  <p>When translating to Strict Content Markup, if the <code>type</code> has value "multiset", then
                     the <a href="http://www.openmath.org/cd/multiset1.xhtml#in">in</a> symbol from <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a> should be used instead.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.notprsubset" id="contm.notprsubset"></a>4.4.5.10 Not Proper Subset <code>&lt;notprsubset/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#notprsubset">notprsubset</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>notprsubset</code> element represents the negated proper
                     subset relation. It is used to denote that the first argument is not
                     a proper subset of the second.
                  </p>
                  <div class="mathml-example" id="set1.notprsubset.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;notprsubset/&gt;
  &lt;ci type="set"&gt;A&lt;/ci&gt;
  &lt;ci type="set"&gt;B&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2284;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-notprsubset-ex1.gif" alt="{A\unicode{8836}B}"></p>
                     </blockquote>
                  </div>
                  <p>When translating to Strict Content Markup, if the <code>type</code> has value "multiset", then
                     the <a href="http://www.openmath.org/cd/multiset1.xhtml#in">in</a> symbol from <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a> should be used instead.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.setdiff" id="contm.setdiff"></a>4.4.5.11 Set Difference <code>&lt;setdiff/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#setdiff">setdiff</a>, <a href="http://www.openmath.org/cd/multiset1.xhtml#setdiff">setdiff</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>setdiff</code> element represents set difference
                     operator. It takes two sets as arguments, and denotes the set that
                     contains all the elements that occur in the first set, but not in
                     the second.
                  </p>
                  <div class="mathml-example" id="set1.setdiff.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;setdiff/&gt;
  &lt;ci type="set"&gt;A&lt;/ci&gt;
  &lt;ci type="set"&gt;B&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2216;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-setdiff-ex1.gif" alt="{A\unicode{8726}B}"></p>
                     </blockquote>
                  </div>
                  <p>When translating to Strict Content Markup, if the <code>type</code> has value "multiset", then
                     the <a href="http://www.openmath.org/cd/multiset1.xhtml#in">in</a> symbol from <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a> should be used instead.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.card" id="contm.card"></a>4.4.5.12 Cardinality <code>&lt;card/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#size">size</a>, <a href="http://www.openmath.org/cd/multiset1.xhtml#size">size</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>card</code> element represents the cardinality function,
                     which takes a set argument and returns its cardinality, i.e. the
                     number of elements in the set.  The cardinality of a set is a
                     non-negative integer, or an infinite cardinal number.
                  </p>
                  <div class="mathml-example" id="set1.size.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;card/&gt;&lt;ci&gt;A&lt;/ci&gt;&lt;/apply&gt;
  &lt;cn&gt;5&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mo&gt;|&lt;/mo&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;|&lt;/mo&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mn&gt;5&lt;/mn&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-size-ex1.gif" alt="{{\left.\middle|A\middle|\right.}={5}}"></p>
                     </blockquote>
                  </div>
                  <p>When translating to Strict Content Markup, if the <code>type</code>
                     has value "multiset", then the <a href="http://www.openmath.org/cd/multiset1.xhtml#size">size</a> symbol from <a href="http://www.openmath.org/cd/multiset1.xhtml">multiset1</a> should be used
                     instead.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.cartesianproduct" id="contm.cartesianproduct"></a>4.4.5.13 Cartesian product <code>&lt;cartesianproduct/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#cartesian_product">cartesian_product</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>cartesianproduct</code> element is used to represents the
                     Cartesian product operator. It takes sets as arguments, which may be
                     explicitly specified in the enclosing <code>apply</code> element, or
                     specified using qualifier elements as described in <a href="chapter4-d.html#contm.nary">Section&nbsp;4.3.4.1 N-ary Operators (classes nary-arith, nary-functional, nary-logical,
                        nary-linalg, nary-set, nary-constructor)</a>.
                  </p>
                  <div class="mathml-example" id="set1.cartesianproduct.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;cartesianproduct/&gt;&lt;ci&gt;A&lt;/ci&gt;&lt;ci&gt;B&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#xd7;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-cartesianproduct-ex1.gif" alt="{A\unicode{215}B}"></p>
                     </blockquote>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.4.6" id="id.4.4.6"></a>4.4.6 Sequences and Series
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.sum" id="contm.sum"></a>4.4.6.1 Sum <code>&lt;sum/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">sum</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#sum">sum</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>sum</code> element represents the n-ary addition operator.
                     The terms of the sum are normally specified by rule through the use of
                     qualifiers.  While it can be used with an explicit list of
                     arguments, this is strongly discouraged, and the <code>plus</code>
                     operator should be used instead in such situations.
                  </p>
                  <p>The <code>sum</code> operator may be used either with or without
                     explicit bound variables.  When a bound variable is used, the
                     <code>sum</code> element is followed by one or more <code>bvar</code>
                     elements giving the index variables, followed by qualifiers giving
                     the domain for the index variables. The final child in the enclosing
                     <code>apply</code> is then an expression in the bound variables, and the
                     terms of the sum are obtained by evaluating this expression at each
                     point of the domain of the index variables.  Depending on the
                     structure of the domain, the domain of summation is often given
                     by using <code>uplimit</code> and <code>lowlimit</code> to specify upper and
                     lower limits for the sum.
                  </p>
                  <p>When no bound variables are explicitly given, the final child of
                     the enclosing <code>apply</code> element must be a function, and the
                     terms of the sum are obtained by evaluating the function at
                     each point of the domain specified by qualifiers.
                  </p>
                  <div class="mathml-example" id="arith1.sum.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sum/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munderover&gt;
  &lt;mo&gt;&amp;#x2211;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mi&gt;b&lt;/mi&gt;
 &lt;/munderover&gt;
 &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-sum-ex1.gif" alt="{\munderover{\unicode{8721}}{{x=a}}{b}{\mathop{f}{\left(x\right)}}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="arith1.sum.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sum/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;in/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci type="set"&gt;B&lt;/ci&gt;&lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;ci type="function"&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munder&gt;
  &lt;mo&gt;&amp;#x2211;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/munder&gt;
 &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-sum-ex2.gif" alt="{\munder{\unicode{8721}}{{x\unicode{8712}B}}{\mathop{f}{\left(x\right)}}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="arith1.sum.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sum/&gt;
  &lt;domainofapplication&gt;
    &lt;ci type="set"&gt;B&lt;/ci&gt;
  &lt;/domainofapplication&gt;
  &lt;ci type="function"&gt;f&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;munder&gt;&lt;mo&gt;&amp;#x2211;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/munder&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-sum-ex3.gif" alt="{\munder{\unicode{8721}}{B}f}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>When no explicit bound variables are used, no special rules are
                     required to rewrite sums as Strict Content beyond the generic rules
                     for rewriting expressions using qualifiers.  However, when bound
                     variables are used, it is necessary to introduce a <code>lambda</code>
                     construction to rewrite the expression in the bound variables as a
                     function.
                  </p>
                  <div class="strict-mathml-example" id="contm.strict-sum">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sum/&gt;
  &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;cn&gt;100&lt;/cn&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;sum&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="interval1"&gt;integer_interval&lt;/csymbol&gt;
    &lt;cn&gt;0&lt;/cn&gt;
    &lt;cn&gt;100&lt;/cn&gt;
  &lt;/apply&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;power&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/apply&gt;
  &lt;/bind&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.product" id="contm.product"></a>4.4.6.2 Product <code>&lt;product/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">product</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/arith1.xhtml#product">product</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>product</code> element represents the n-ary multiplication operator.
                     The terms of the product are normally specified by rule through the use of
                     qualifiers.  While it can be used with an explicit list of
                     arguments, this is strongly discouraged, and the <code>times</code>
                     operator should be used instead in such situations.
                  </p>
                  <p>The <code>product</code> operator may be used either with or without
                     explicit bound variables.  When a bound variable is used, the
                     <code>product</code> element is followed by one or more <code>bvar</code>
                     elements giving the index variables, followed by qualifiers giving
                     the domain for the index variables. The final child in the enclosing
                     <code>apply</code> is then an expression in the bound variables, and the
                     terms of the product are obtained by evaluating this expression at
                     each point of the domain.  Depending on the structure of the domain,
                     it is commonly given using <code>uplimit</code> and <code>lowlimit</code>
                     qualifiers.
                  </p>
                  <p>When no bound variables are explicitly given, the final child of
                     the enclosing <code>apply</code> element must be a function, and the
                     terms of the product are obtained by evaluating the function
                     at each point of the domain specified by qualifiers.
                  </p>
                  <div class="mathml-example" id="arith1.product.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;product/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;ci&gt;b&lt;/ci&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;ci type="function"&gt;f&lt;/ci&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munderover&gt;
  &lt;mo&gt;&amp;#x220f;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mi&gt;b&lt;/mi&gt;
 &lt;/munderover&gt;
 &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-product-ex1.gif" alt="{\munderover{\unicode{8719}}{{x=a}}{b}{\mathop{f}{\left(x\right)}}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="arith1.product.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;product/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;in/&gt;
      &lt;ci&gt;x&lt;/ci&gt;
      &lt;ci type="set"&gt;B&lt;/ci&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;ci&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munder&gt;
  &lt;mo&gt;&amp;#x220f;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/munder&gt;
 &lt;mrow&gt;&lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/arith1-product-ex2.gif" alt="{\munder{\unicode{8719}}{{x\unicode{8712}B}}{\mathop{f}{\left(x\right)}}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>When no explicit bound variables are used, no special rules are
                     required to rewrite products as Strict Content beyond the generic rules
                     for rewriting expressions using qualifiers.  However, when bound
                     variables are used, it is necessary to introduce a <code>lambda</code>
                     construction to rewrite the expression in the bound variables as a
                     function.
                  </p>
                  <div class="strict-mathml-example" id="contm.strict-product">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;product/&gt;
  &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;uplimit&gt;&lt;cn&gt;100&lt;/cn&gt;&lt;/uplimit&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="arith1"&gt;product&lt;/csymbol&gt;
  &lt;apply&gt;&lt;csymbol cd="interval1"&gt;integer_interval&lt;/csymbol&gt;
    &lt;cn&gt;0&lt;/cn&gt;
    &lt;cn&gt;100&lt;/cn&gt;
  &lt;/apply&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/bvar&gt;
    &lt;apply&gt;&lt;csymbol cd="arith1"&gt;power&lt;/csymbol&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;/apply&gt;
  &lt;/bind&gt;
&lt;/apply&gt;</pre></div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.limit" id="contm.limit"></a>4.4.6.3 Limits <code>&lt;limit/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.otherclass">limit</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td>
                              <a href="appendixa-d.html#parsing_lowlimit">lowlimit</a>,
                              <a href="appendixa-d.html#parsing_condition">condition</a>
                              
                           </td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td>
                              <a href="http://www.openmath.org/cd/limit1.xhtml#limit">limit</a>,
                              <a href="http://www.openmath.org/cd/limit1.xhtml#both_sides">both_sides</a>,
                              <a href="http://www.openmath.org/cd/limit1.xhtml#above">above</a>,
                              <a href="http://www.openmath.org/cd/limit1.xhtml#below">below</a>,
                              <a href="http://www.openmath.org/cd/limit1.xhtml#null">null</a>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>limit</code> element represents the operation of taking a limit of a
                     sequence. The limit point is expressed by specifying a <code>lowlimit</code> and a
                     <code>bvar</code>, or by specifying a <code>condition</code> on one or more bound variables.
                  </p>
                  <div class="mathml-example" id="limit1.limit.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;limit/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;lowlimit&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/lowlimit&gt;
  &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munder&gt;
  &lt;mi&gt;lim&lt;/mi&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2192;&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;
 &lt;/munder&gt;
 &lt;mrow&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/limit1-limit-ex1.gif" alt="{\munder{{\minormal{lim}}}{{x\unicode{8594}{0}}}{\mathop{{\minormal{sin}}}x}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="limit1.limit.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;limit/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;tendsto/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munder&gt;
  &lt;mi&gt;lim&lt;/mi&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2192;&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;
 &lt;/munder&gt;
 &lt;mrow&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/limit1-limit-ex2.gif" alt="{\munder{{\minormal{lim}}}{{x\unicode{8594}{0}}}{\mathop{{\minormal{sin}}}x}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="limit1.limit.ex3">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;limit/&gt;
  &lt;bvar&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;tendsto type="above"/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;munder&gt;
  &lt;mi&gt;lim&lt;/mi&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;&amp;#x2192;&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;/msup&gt;&lt;/mrow&gt;
 &lt;/munder&gt;
 &lt;mrow&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/limit1-limit-ex3.gif" alt="{\munder{{\minormal{lim}}}{{x\unicode{8594}\msup{a}{+}}}{\mathop{{\minormal{sin}}}x}}"></p>
                     </blockquote>
                  </div>
                  <p>The direction from which a limiting value is approached is given as an argument
                     <a href="http://www.openmath.org/cd/limit1.xhtml#limit">limit</a> in Strict Content MathML, which supplies the
                     direction specifier symbols <a href="http://www.openmath.org/cd/limit1.xhtml#both_sides">both_sides</a>, <a href="http://www.openmath.org/cd/limit1.xhtml#above">above</a>, and <a href="http://www.openmath.org/cd/limit1.xhtml#below">below</a> for this
                     purpose. The first correspond to the values "all", "above",
                     and "below" of the <code>type</code> attribute of the <code>tendsto</code>
                     element below. The <a href="http://www.openmath.org/cd/limit1.xhtml#null">null</a> symbol corresponds to the case
                     where no <code>type</code> attribute is present. We translate
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.strict-limit" id="contm.strict-limit"></a>Rewrite: limits condition
                     </h5><pre class="mathml">
&lt;apply&gt;&lt;limit/&gt;
  &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;tendsto/&gt; <span class="egmeta">x</span> <span class="egmeta">&lt;cn&gt;</span>0<span class="egmeta">&lt;/cn&gt;</span>&lt;/apply&gt;
  &lt;/condition&gt;
   <span class="egmeta">expression-in-x</span> 
&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="limit1"&gt;limit&lt;/csymbol&gt;
  <span class="egmeta">&lt;cn&gt;</span>0<span class="egmeta">&lt;/cn&gt;</span>
  &lt;csymbol cd="limit1"&gt;<span class="egmeta">null</span>&lt;/csymbol&gt;
  &lt;bind&gt;&lt;csymbol cd="fns1"&gt;lambda&lt;/csymbol&gt;
    &lt;bvar&gt; <span class="egmeta">x</span> &lt;/bvar&gt;
     <span class="egmeta">expression-in-x</span> 
  &lt;/bind&gt;
&lt;/apply&gt;</pre><p>where 
                        <code> <span class="egmeta">expression-in-x</span> </code> is an
                        arbitrary expression involving the bound variable(s), and the choice of
                        symbol, <a href="http://www.openmath.org/cd/limit1.xhtml#null">null</a> depends on the
                        <code>type</code> attribute of the <code>tendsto</code> element as
                        described above.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.tendsto" id="contm.tendsto"></a>4.4.6.4 Tends To <code>&lt;tendsto/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-reln</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a>, <a href="appendixa-d.html#parsing_type">type</a>?
                           </td>
                        </tr>
                        <tr>
                           <th><code>type</code> Attribute Values
                           </th>
                           <td> string</td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/limit1.xhtml#limit">limit</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>tendsto</code> element is used to express the relation that
                     a quantity is tending to a specified value. While this is used
                     primarily as part of the statement of a mathematical limit, it
                     exists as a construct on its own to allow one to capture
                     mathematical statements such as "As x tends to y," and to provide a
                     building block to construct more general kinds of limits.
                  </p>
                  <p>The <code>tendsto</code> element takes the attributes <code>type</code> to set the
                     direction from which the limiting value is approached.
                  </p>
                  <div class="mathml-example" id="limit1.tendsto.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;tendsto type="above"/&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
   &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
 &lt;mo&gt;&amp;#x2192;&lt;/mo&gt;
 &lt;msup&gt;&lt;msup&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;/msup&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/limit1-tendsto-ex1.gif" alt="\msup{x}{2}\unicode{8594}\msup{\msup{a}{2}}{+}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="limit1.tendsto.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;tendsto/&gt;
  &lt;vector&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/vector&gt;
   &lt;vector&gt;
     &lt;apply&gt;&lt;ci type="function"&gt;f&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
     &lt;apply&gt;&lt;ci type="function"&gt;g&lt;/ci&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
   &lt;/vector&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mfenced&gt;&lt;mtable&gt;
  &lt;mtr&gt;&lt;mtd&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mtd&gt;&lt;/mtr&gt;
  &lt;mtr&gt;&lt;mtd&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mtd&gt;&lt;/mtr&gt;
&lt;/mtable&gt;&lt;/mfenced&gt;
&lt;mo&gt;&amp;#x2192;&lt;/mo&gt;
&lt;mfenced&gt;&lt;mtable&gt;
  &lt;mtr&gt;&lt;mtd&gt;
    &lt;mi&gt;f&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mtd&gt;&lt;/mtr&gt;
  &lt;mtr&gt;&lt;mtd&gt;
    &lt;mi&gt;g&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mtd&gt;&lt;/mtr&gt;
&lt;/mtable&gt;&lt;/mfenced&gt;</pre><blockquote>
                        <p><img src="image/limit1-tendsto-ex2.gif" alt="{{\left.\middle({\begin{matrix}x\\y\end{matrix}}\middle)\right.}\unicode{8594}{\left.\middle({\begin{matrix}{\mathop{f}{\left(x,y\right)}}\\{\mathop{g}{\left(x,y\right)}}\end{matrix}}\middle)\right.}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>The usage of <code>tendsto</code> to qualify a limit is formally
                     defined by writing the expression in Strict Content MathML via the
                     rule <a href="chapter4-d.html#contm.strict-limit">Rewrite: limits condition</a>. The meanings of other more
                     idiomatic uses of <code>tendsto</code> are not formally defined by this
                     specification. When rewriting these cases to Strict Content MathML,
                     <code>tendsto</code> should be rewritten to an annotated identifier as
                     shown below.
                  </p>
                  <div class="strict-mathml-example">
                     
                     <h5><a name="contm.strict.tendsto" id="contm.strict.tendsto"></a>Rewrite: tendsto
                     </h5><pre class="mathml">
&lt;tendsto/&gt;
</pre><p>Strict Content MathML equivalent:</p><pre class="mathml">
&lt;semantics&gt;
 &lt;ci&gt;tendsto&lt;/ci&gt;
 &lt;annotation-xml encoding="MathML-Content"&gt;
  &lt;tendsto/&gt;
 &lt;/annotation-xml&gt;
&lt;/semantics&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.elemclass" id="contm.elemclass"></a>4.4.7 Elementary classical functions
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.trig" id="contm.trig"></a>4.4.7.1 Common trigonometric functions 
                  </h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-elementary</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/transc1.xhtml#sin">sin</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <table border="1">
                     <tbody>
                        <tr>
                           <td id="contm.sin"><code>sin</code></td>
                           <td id="contm.cos"><code>cos</code></td>
                           <td id="contm.tan"><code>tan</code></td>
                           <td id="contm.sec"><code>sec</code></td>
                           <td id="contm.csc"><code>csc</code></td>
                           <td id="contm.cot"><code>cot</code></td>
                        </tr>
                        <tr>
                           <td id="contm.sinh"><code>sinh</code></td>
                           <td id="contm.cosh"><code>cosh</code></td>
                           <td id="contm.tanh"><code>tanh</code></td>
                           <td id="contm.sech"><code>sech</code></td>
                           <td id="contm.csch"><code>csch</code></td>
                           <td id="contm.coth"><code>coth</code></td>
                        </tr>
                        <tr>
                           <td id="contm.arcsin"><code>arcsin</code></td>
                           <td id="contm.arccos"><code>arccos</code></td>
                           <td id="contm.arctan"><code>arctan</code></td>
                           <td id="contm.arccosh"><code>arccosh</code></td>
                           <td id="contm.arccot"><code>arccot</code></td>
                           <td id="contm.arccoth"><code>arccoth</code></td>
                        </tr>
                        <tr>
                           <td id="contm.arccsc"><code>arccsc</code></td>
                           <td id="contm.arccsch"><code>arccsch</code></td>
                           <td id="contm.arcsec"><code>arcsec</code></td>
                           <td id="contm.arcsech"><code>arcsech</code></td>
                           <td id="contm.arcsinh"><code>arcsinh</code></td>
                           <td id="contm.arctanh"><code>arctanh</code></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>These operator elements denote the standard trigonometric and
                     hyperbolic functions and their inverses.  Since their standard
                     interpretations are widely known, they are discussed as a group. In
                     the case of inverse functions there are differing definitions in use.
                     For maximum interoperability applications evaluating such expressions
                     should follow the definitions in <a href="appendixh-d.html#Abramowitz1997">[Abramowitz1997]</a>.
                  </p>
                  <div class="mathml-example" id="transc1.sin.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/transc1-sin-ex1.gif" alt="{\mathop{{\minormal{sin}}}x}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="transc1.sin.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sin/&gt;
  &lt;apply&gt;&lt;plus/&gt;
    &lt;apply&gt;&lt;cos/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;
    &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;sin&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mo&gt;(&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;cos&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mo&gt;+&lt;/mo&gt;
  &lt;msup&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msup&gt;
  &lt;mo&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/transc1-sin-ex2.gif" alt="{\mathop{{\minormal{sin}}}{\left.\middle({\mathop{{\minormal{cos}}}x}+\msup{x}{{3}}\middle)\right.}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.exp" id="contm.exp"></a>4.4.7.2 Exponential <code>&lt;exp/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/transc1.xhtml#exp">exp</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>exp</code> element represents the exponentiation function
                     associated with the inverse of the ln function. It takes one
                     argument.
                  </p>
                  <div class="mathml-example" id="transc1.exp.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;exp/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msup&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/msup&gt;</pre><blockquote>
                        <p><img src="image/transc1-exp-ex1.gif" alt="\msup{e}{x}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.ln" id="contm.ln"></a>4.4.7.3 Natural Logarithm <code>&lt;ln/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/transc1.xhtml#ln">ln</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>ln</code> element represents the natural logarithm function.
                  </p>
                  <div class="mathml-example" id="transc1.ln.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;ln/&gt;&lt;ci&gt;a&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;ln&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;a&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/transc1-ln-ex1.gif" alt="{\mathop{{\minormal{ln}}}a}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.log" id="contm.log"></a>4.4.7.4 Logarithm <code>&lt;log/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_logbase">logbase</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/transc1.xhtml#log">log</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>log</code> elements represents the logarithm function
                     relative to a given base.  When present, the <code>logbase</code>
                     qualifier specifies the base. Otherwise, the base is assumed to be 10.
                     <code>apply</code>.
                  </p>
                  <div class="mathml-example" id="transc1.log.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;log/&gt;
  &lt;logbase&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/logbase&gt;
  &lt;ci&gt;x&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;msub&gt;&lt;mi&gt;log&lt;/mi&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msub&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/transc1-log-ex1.gif" alt="{\msub{{\minormal{log}}}{{3}}\unicode{8289}x}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="transc1.log.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;log/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;log&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/transc1-log-ex2.gif" alt="{\mathop{{\minormal{log}}}x}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Content MathML</em></p>
                  <p>When mapping <code>log</code> to Strict Content, one uses the
                     <a href="http://www.openmath.org/cd/transc1.xhtml#log">log</a> symbol denoting the function
                     that returns the log of its second argument with respect to the base
                     specified by the first argument.  When <code>logbase</code> is present, it
                     determines the base.  Otherwise, the default base of 10 must be
                     explicitly provided in Strict markup.  See the following example.
                  </p>
                  <div class="strict-mathml-example" id="contm.strict.log"><pre class="mathml">&lt;apply&gt;&lt;plus/&gt;
  &lt;apply&gt;
    &lt;log/&gt;
    &lt;logbase&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/logbase&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;apply&gt;
    &lt;log/&gt;
    &lt;ci&gt;y&lt;/ci&gt;
  &lt;/apply&gt;
&lt;/apply&gt;

</pre><p>Strict Content MathML equivalent:</p><pre class="mathml">&lt;apply&gt;
  &lt;csymbol cd="arith1"&gt;plus&lt;/csymbol&gt;
  &lt;apply&gt;
    &lt;csymbol cd="transc1"&gt;log&lt;/csymbol&gt;
    &lt;cn&gt;2&lt;/cn&gt;
    &lt;ci&gt;x&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;apply&gt;
    &lt;csymbol cd="transc1"&gt;log&lt;/csymbol&gt;
    &lt;cn&gt;10&lt;/cn&gt;
    &lt;ci&gt;y&lt;/ci&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.4.8" id="id.4.4.8"></a>4.4.8 Statistics
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.mean" id="contm.mean"></a>4.4.8.1 Mean <code>&lt;mean/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.unary">nary-stats</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/s_dist1.xhtml#mean">mean</a>, <a href="http://www.openmath.org/cd/s_data1.xhtml#mean">mean</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>mean</code> element represents the function returning arithmetic mean or average of a
                     data set or random variable.
                  </p>
                  <div class="mathml-example" id="s.data1.mean.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;mean/&gt;
  &lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;7&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x2329;&lt;/mo&gt;
 &lt;mn&gt;3&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;3&lt;/mn&gt;
 &lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;7&lt;/mn&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mn&gt;4&lt;/mn&gt;
 &lt;mo&gt;&amp;#x232a;&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_data1-mean-ex1.gif" alt="{\unicode{9001}{3},{4},{3},{7},{4}\unicode{9002}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="s.dist1.mean.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;mean/&gt;&lt;ci&gt;X&lt;/ci&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x2329;&lt;/mo&gt;&lt;mi&gt;X&lt;/mi&gt;&lt;mo&gt;&amp;#x232a;&lt;/mo&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_dist1-mean-ex1.gif" alt="{\unicode{9001}X\unicode{9002}}"></p>
                     </blockquote><pre class="mathml">
&lt;mover&gt;&lt;mi&gt;X&lt;/mi&gt;&lt;mo&gt;&amp;#xaf;&lt;/mo&gt;&lt;/mover&gt;</pre><blockquote>
                        <p><img src="image/s_dist1-mean-ex1-2.gif" alt="{\overline{X}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>When the <code>mean</code> element is applied to an explicit list of arguments, the
                     translation to Strict Content markup is direct, using the <a href="http://www.openmath.org/cd/s_data1.xhtml#mean">mean</a> symbol from the <a href="http://www.openmath.org/cd/s_data1.xhtml">s_data1</a> content dictionary, as described in
                     <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>. When it is applied to a distribution, then the
                     <a href="http://www.openmath.org/cd/s_dist1.xhtml#mean">mean</a> symbol from the <a href="http://www.openmath.org/cd/s_dist1.xhtml">s_dist1</a> content
                     dictionary should be used.  In the case with qualifiers use <a href="chapter4-d.html#contm.p2s.lifted">Rewrite: n-ary domainofapplication</a> 
                     with the same caveat.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.sdev" id="contm.sdev"></a>4.4.8.2 Standard Deviation <code>&lt;sdev/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.unary">nary-stats</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/s_dist1.xhtml#sdev">sdev</a>, <a href="http://www.openmath.org/cd/s_data1.xhtml#sdev">sdev</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>sdev</code> element is used to denote the standard deviation
                     function for a data set or random variable.  Standard deviation is a
                     statistical measure of dispersion given by the square root of the
                     variance.
                  </p>
                  <div class="mathml-example" id="s.data1.sdev.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sdev/&gt;
  &lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;&amp;#x3c3;&lt;/mo&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_data1-sdev-ex1.gif" alt="{\unicode{963}\unicode{8289}{\left({3},{4},{2},{2}\right)}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="s.dist1.sdev.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;sdev/&gt;
  &lt;ci type="discrete_random_variable"&gt;X&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mo&gt;&amp;#x3c3;&lt;/mo&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mfenced&gt;&lt;mi&gt;X&lt;/mi&gt;&lt;/mfenced&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_dist1-sdev-ex1.gif" alt="{\unicode{963}\unicode{8289}{\left(X\right)}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>When the <code>sdev</code> element is applied to an explicit list of arguments, the
                     translation to Strict Content markup is direct, using the <a href="http://www.openmath.org/cd/s_data1.xhtml#sdev">sdev</a> 
                     symbol from the <a href="http://www.openmath.org/cd/s_data1.xhtml">s_data1</a> content dictionary, as described in
                     <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>. When it is applied to a distribution, then the
                     <a href="http://www.openmath.org/cd/s_dist1.xhtml#sdev">sdev</a> symbol from the <a href="http://www.openmath.org/cd/s_dist1.xhtml">s_dist1</a> content
                     dictionary should be used. In the case with qualifiers use
                     <a href="chapter4-d.html#contm.p2s.lifted">Rewrite: n-ary domainofapplication</a> with the same caveat.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.variance" id="contm.variance"></a>4.4.8.3 Variance <code>&lt;variance/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.unary">nary-stats</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,<a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/s_dist1.xhtml#variance">variance</a>, <a href="http://www.openmath.org/cd/s_data1.xhtml#variance">variance</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>variance</code> element represents the variance of a data set
                     or random variable. Variance is a statistical measure of dispersion,
                     averaging the squares of the deviations of possible values from their
                     mean.
                  </p>
                  <div class="mathml-example" id="s.data1.variance.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;variance/&gt;
  &lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msup&gt;
  &lt;mo&gt;&amp;#x3c3;&lt;/mo&gt;
  &lt;mn&gt;2&lt;/mn&gt;
 &lt;/msup&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_data1-variance-ex1.gif" alt="\msup{\unicode{963}}{2}\unicode{8289}\left(3,4,2,2\right)"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="s.dist1.variance.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;variance/&gt;
  &lt;ci type="discrete_random_variable"&gt; X&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msup&gt;&lt;mo&gt;&amp;#x3c3;&lt;/mo&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mi&gt;X&lt;/mi&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;
 </pre><blockquote>
                        <p><img src="image/s_dist1-variance-ex1.gif" alt="\msup{\unicode{963}}{2}\unicode{8289}\left(X\right)"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>When the <code>variance</code> element is applied to an explicit list of arguments, the
                     translation to Strict Content markup is direct, using the <a href="http://www.openmath.org/cd/s_data1.xhtml#variance">variance</a> 
                     symbol from the <a href="http://www.openmath.org/cd/s_data1.xhtml">s_data1</a> content dictionary, as described in
                     <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>. When it is applied to a distribution, then the
                     <a href="http://www.openmath.org/cd/s_dist1.xhtml#variance">variance</a> symbol from the <a href="http://www.openmath.org/cd/s_dist1.xhtml">s_dist1</a> content
                     dictionary should be used. In the case with qualifiers use <a href="chapter4-d.html#contm.p2s.lifted">Rewrite: n-ary domainofapplication</a> 
                     with the same caveat.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.median" id="contm.median"></a>4.4.8.4 Median <code>&lt;median/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.unary">nary-stats</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,
                              <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/s_data1.xhtml#median">median</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>median</code> element represents an operator returning the
                     median of its arguments. The median is a number separating the lower
                     half of the sample values from the upper half.
                  </p>
                  <div class="mathml-example" id="s.data1.median.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;median/&gt;
  &lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;median&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_data1-median-ex1.gif" alt="{\mathop{{\minormal{median}}}{\left({3},{4},{2},{2}\right)}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>When the <code>median</code> element is applied to an explicit list of arguments, the
                     translation to Strict Content markup is direct, using the <a href="http://www.openmath.org/cd/s_data1.xhtml#median">median</a> 
                     symbol from the <a href="http://www.openmath.org/cd/s_data1.xhtml">s_data1</a> content dictionary, as described in
                     <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.mode" id="contm.mode"></a>4.4.8.5 Mode <code>&lt;mode/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary.unary">nary-stats</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,
                              <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/s_data1.xhtml#mode">mode</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>mode</code> element is used to denote the mode of its arguments. The mode is
                     the value which occurs with the greatest frequency.
                  </p>
                  <div class="mathml-example" id="s.data1.mode.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;mode/&gt;
  &lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;mode&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2061;&lt;/mo&gt;
 &lt;mfenced&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mfenced&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/s_data1-mode-ex1.gif" alt="{\mathop{{\minormal{mode}}}{\left({3},{4},{2},{2}\right)}}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <p>When the <code>mode</code> element is applied to an explicit list of arguments, the
                     translation to Strict Content markup is direct, using the <a href="http://www.openmath.org/cd/s_data1.xhtml#mode">mode</a> 
                     symbol from the <a href="http://www.openmath.org/cd/s_data1.xhtml">s_data1</a> content dictionary, as described in
                     <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.moment" id="contm.moment"></a>4.4.8.6 Moment (<code>&lt;moment/&gt;</code>, <code>&lt;momentabout&gt;</code>)
                  </h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-functional</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_degree">degree</a>, 
                              <a href="appendixa-d.html#parsing_momentabout">momentabout</a></td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/s_data1.xhtml#moment">moment</a>, 
                              <a href="http://www.openmath.org/cd/s_dist1.xhtml#moment">moment</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>moment</code> element is used to denote the <var>i</var>th moment of a set of data set or
                     random variable. The <code>moment</code> function accepts the <code>degree</code> and
                     <code>momentabout</code> qualifiers. If present, the <code>degree</code> schema denotes the order of
                     the moment. Otherwise, the moment is assumed to be the first order moment. When used with
                     <code>moment</code>, the <code>degree</code> schema is expected to contain a
                     single child. If present, the <code>momentabout</code> schema denotes the  
                     point about which the moment is taken. Otherwise, the moment is
                     assumed to be the moment about zero.
                  </p>
                  <div class="mathml-example" id="s.data1.moment.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;moment/&gt;
  &lt;degree&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/degree&gt;
  &lt;momentabout&gt;&lt;mean/&gt;&lt;/momentabout&gt;
  &lt;cn&gt;6&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;cn&gt;5&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msub&gt;
 &lt;mrow&gt;
  &lt;mo&gt;&amp;#x2329;&lt;/mo&gt;
  &lt;msup&gt;
   &lt;mfenced&gt;&lt;mn&gt;6&lt;/mn&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;mn&gt;5&lt;/mn&gt;&lt;/mfenced&gt;
   &lt;mn&gt;3&lt;/mn&gt;
  &lt;/msup&gt;
  &lt;mo&gt;&amp;#x232a;&lt;/mo&gt;
 &lt;/mrow&gt;
 &lt;mi&gt;mean&lt;/mi&gt;
&lt;/msub&gt;</pre><blockquote>
                        <p><img src="image/s_data1-moment-ex1.gif" alt="\msub{{\unicode{9001}\msup{{\left({6},{4},{2},{2},{5}\right)}}{{3}}\unicode{9002}}}{{\minormal{mean}}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="s.dist1.moment.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;moment/&gt;
  &lt;degree&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/degree&gt;
  &lt;momentabout&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;/momentabout&gt;
  &lt;ci&gt;X&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msub&gt;
 &lt;mrow&gt;
  &lt;mo&gt;&amp;#x2329;&lt;/mo&gt;&lt;msup&gt;&lt;mi&gt;X&lt;/mi&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/msup&gt;&lt;mo&gt;&amp;#x232a;&lt;/mo&gt;
 &lt;/mrow&gt;
 &lt;mi&gt;p&lt;/mi&gt;
&lt;/msub&gt;</pre><blockquote>
                        <p><img src="image/s_dist1-moment-ex1.gif" alt="\msub{{\unicode{9001}\msup{X}{{3}}\unicode{9002}}}{p}"></p>
                     </blockquote>
                  </div>
                  <p><em>Mapping to Strict Markup</em></p>
                  <div class="strict-mathml-example" id="contm.strict-moment-degree">
                     <p>When rewriting to Strict Markup, the <a href="http://www.openmath.org/cd/s_dist1.xhtml#moment">moment</a> symbol from the <a href="http://www.openmath.org/cd/s_data1.xhtml">s_data1</a> content 
                        dictionary is used when the <code>moment</code> element is applied 
                        to an explicit list of arguments.  When it is applied to a distribution, then the 
                        <a href="http://www.openmath.org/cd/s_dist1.xhtml#moment">moment</a> symbol from the <a href="http://www.openmath.org/cd/s_dist1.xhtml">s_dist1</a> content
                        dictionary should be used. Both operators take 
                        the degree as the first argument, the point as the second, followed by 
                        the data set or random variable respectively.
                     </p><pre class="mathml">
&lt;apply&gt;&lt;moment/&gt;
  &lt;degree&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;/degree&gt;
  &lt;momentabout&gt;&lt;ci&gt;p&lt;/ci&gt;&lt;/momentabout&gt;
  &lt;ci&gt;X&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Strict Content MathML equivalent</p><pre class="strict-mathml">
&lt;apply&gt;&lt;csymbol cd="s_dist1"&gt;moment&lt;/csymbol&gt;
  &lt;cn&gt;3&lt;/cn&gt;
  &lt;ci&gt;p&lt;/ci&gt;
  &lt;ci&gt;X&lt;/ci&gt;
&lt;/apply&gt;</pre></div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="id.4.4.9" id="id.4.4.9"></a>4.4.9 Linear Algebra
               </h3>
               <div class="div4">
                  
                  <h4><a name="contm.vector" id="contm.vector"></a>4.4.9.1 Vector <code>&lt;vector&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-constructor</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,
                              <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           </td>
                        </tr>
                        <tr>
                           <th>OM Symbol</th>
                           <td>
                              <a href="http://www.openmath.org/cd/linalg2.xhtml#vector">vector</a>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>A vector is an ordered n-tuple of values representing an element of an
                     n-dimensional vector space.
                  </p>
                  <p>For purposes of interaction with matrices and matrix multiplication, vectors are
                     regarded as equivalent to a matrix consisting of a single column, and the transpose of
                     a vector as a matrix consisting of a single row. 
                  </p>
                  <p>The components of a <code>vector</code> may be given explicitly as
                     child elements, or specified by rule as described in <a href="chapter4-d.html#contm.container.constructor">Section&nbsp;4.3.1.1 Container Markup for Constructor Symbols</a>.
                  </p>
                  <div class="mathml-example" id="linalg2.vector.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;vector&gt;
  &lt;apply&gt;&lt;plus/&gt;&lt;ci&gt;x&lt;/ci&gt;&lt;ci&gt;y&lt;/ci&gt;&lt;/apply&gt;
  &lt;cn&gt;3&lt;/cn&gt;
  &lt;cn&gt;7&lt;/cn&gt;
&lt;/vector&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;(&lt;/mo&gt;
 &lt;mtable&gt;
  &lt;mtr&gt;&lt;mtd&gt;&lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;&lt;/mtd&gt;&lt;/mtr&gt;
  &lt;mtr&gt;&lt;mtd&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/mtd&gt;&lt;/mtr&gt;
  &lt;mtr&gt;&lt;mtd&gt;&lt;mn&gt;7&lt;/mn&gt;&lt;/mtd&gt;&lt;/mtr&gt;
 &lt;/mtable&gt;
 &lt;mo&gt;)&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg2-vector-ex1.gif" alt="{\left.\middle({\begin{matrix}{x+y}\\{3}\\{7}\end{matrix}}\middle)\right.}"></p>
                     </blockquote><pre class="mathml">
&lt;mfenced&gt;
  &lt;mrow&gt;&lt;mi&gt;x&lt;/mi&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mi&gt;y&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mn&gt;3&lt;/mn&gt;
  &lt;mn&gt;7&lt;/mn&gt;
&lt;/mfenced&gt;</pre><blockquote>
                        <p><img src="image/linalg2-vector-ex1-2.gif" alt="{\left({x+y},{3},{7}\right)}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.matrix" id="contm.matrix"></a>4.4.9.2 Matrix <code>&lt;matrix&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-constructor</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,
                              <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           </td>
                        </tr>
                        <tr>
                           <th>OM Symbol</th>
                           <td>
                              <a href="http://www.openmath.org/cd/linalg2.xhtml#matrix">matrix</a>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>A matrix is regarded as made up of matrix rows, each of which can be 
                     thought of as a special type of vector.
                  </p>
                  <p>Note that the behavior of the <code>matrix</code> and <code>matrixrow</code> elements is
                     substantially different from the <code>mtable</code> and <code>mtr</code> presentation
                     elements.
                  </p>
                  <p>The <code>matrix</code> element is a <em>constructor</em>
                     element, so the entries may be given explicitly as child elements,
                     or specified by rule as described in <a href="chapter4-d.html#contm.container.constructor">Section&nbsp;4.3.1.1 Container Markup for Constructor Symbols</a>.  In the latter case, the
                     entries are specified by providing a function and a 2-dimensional
                     domain of application.  The entries of the matrix correspond to
                     the values obtained by evaluating the function at the points of
                     the domain.
                  </p>
                  <div class="mathml-example" id="linalg6.matrix.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;matrix&gt;
  &lt;bvar&gt;&lt;ci type="integer"&gt;i&lt;/ci&gt;&lt;/bvar&gt;
  &lt;bvar&gt;&lt;ci type="integer"&gt;j&lt;/ci&gt;&lt;/bvar&gt;
  &lt;condition&gt;
    &lt;apply&gt;&lt;and/&gt;
      &lt;apply&gt;&lt;in/&gt;
        &lt;ci&gt;i&lt;/ci&gt;
        &lt;interval&gt;&lt;ci&gt;1&lt;/ci&gt;&lt;ci&gt;5&lt;/ci&gt;&lt;/interval&gt;
      &lt;/apply&gt;
      &lt;apply&gt;&lt;in/&gt;
        &lt;ci&gt;j&lt;/ci&gt;
        &lt;interval&gt;&lt;ci&gt;5&lt;/ci&gt;&lt;ci&gt;9&lt;/ci&gt;&lt;/interval&gt;
      &lt;/apply&gt;
    &lt;/apply&gt;
  &lt;/condition&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;ci&gt;i&lt;/ci&gt;&lt;ci&gt;j&lt;/ci&gt;&lt;/apply&gt;
&lt;/matrix&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mo&gt;[&lt;/mo&gt;
 &lt;msub&gt;&lt;mi&gt;m&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;j&lt;/mi&gt;&lt;/mrow&gt;&lt;/msub&gt;
 &lt;mo&gt;|&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;msub&gt;&lt;mi&gt;m&lt;/mi&gt;&lt;mrow&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mo&gt;,&lt;/mo&gt;&lt;mi&gt;j&lt;/mi&gt;&lt;/mrow&gt;&lt;/msub&gt;
  &lt;mo&gt;=&lt;/mo&gt;
  &lt;msup&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mi&gt;j&lt;/mi&gt;&lt;/msup&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;;&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mrow&gt;
   &lt;mi&gt;i&lt;/mi&gt;
   &lt;mo&gt;&amp;#x2208;&lt;/mo&gt;
   &lt;mfenced open="[" close="]"&gt;&lt;mi&gt;1&lt;/mi&gt;&lt;mi&gt;5&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2227;&lt;/mo&gt;
  &lt;mrow&gt;
   &lt;mi&gt;j&lt;/mi&gt;
   &lt;mo&gt;&amp;#x2208;&lt;/mo&gt;
   &lt;mfenced open="[" close="]"&gt;&lt;mi&gt;5&lt;/mi&gt;&lt;mi&gt;9&lt;/mi&gt;&lt;/mfenced&gt;
  &lt;/mrow&gt;
 &lt;/mrow&gt;
 &lt;mo&gt;]&lt;/mo&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg6-matrix-ex1.gif" alt="{\left.[\msub{m}{{i,j}}\middle|{\msub{m}{{i,j}}=\msup{i}{j}};{{i\unicode{8712}{\left[1,5\right]}}\unicode{8743}{j\unicode{8712}{\left[5,9\right]}}}]\right.}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.matrixrow" id="contm.matrixrow"></a>4.4.9.3 Matrix row <code>&lt;matrixrow&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-constructor</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Qualifiers</th>
                           <td><a href="appendixa-d.html#parsing_BvarQ">BvarQ</a>,
                              <a href="appendixa-d.html#parsing_DomainQ">DomainQ</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td><a href="appendixa-d.html#parsing_ContExp">ContExp</a>*
                           </td>
                        </tr>
                        <tr>
                           <th>OM Symbol</th>
                           <td>
                              <a href="http://www.openmath.org/cd/linalg2.xhtml#matrixrow">matrixrow</a>
                              
                           </td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element is an n-ary constructor used to represent rows of matrices.</p>
                  <p>Matrix rows are not directly rendered by themselves outside of the
                     context of a matrix.
                  </p>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.determinant" id="contm.determinant"></a>4.4.9.4 Determinant <code>&lt;determinant/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-linalg</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/linalg1.xhtml#determinant">determinant</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element is used for the unary function which returns the determinant of its argument, 
                     which should be a square matrix.
                  </p>
                  <div class="mathml-example" id="linalg1.determinant.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;determinant/&gt;
  &lt;ci type="matrix"&gt;A&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;det&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg1-determinant-ex1.gif" alt="{\mathop{{\minormal{det}}}A}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.transpose" id="contm.transpose"></a>4.4.9.5 Transpose <code>&lt;transpose/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.unary">unary-linalg</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/linalg1.xhtml#transpose">transpose</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents a unary function that signifies the transpose of the 
                     given matrix or vector.
                  </p>
                  <div class="mathml-example" id="linalg1.transpose.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;transpose/&gt;
  &lt;ci type="matrix"&gt;A&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msup&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mi&gt;T&lt;/mi&gt;&lt;/msup&gt;</pre><blockquote>
                        <p><img src="image/linalg1-transpose-ex1.gif" alt="\msup{A}{T}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.selector" id="contm.selector"></a>4.4.9.6 Selector <code>&lt;selector/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.nary">nary-linalg</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/linalg1.xhtml#vector_selector">vector_selector</a>, 
                              <a href="http://www.openmath.org/cd/linalg1.xhtml#matrix_selector">matrix_selector</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>The <code>selector</code> element is the operator for indexing into vectors, matrices
                     and lists. It accepts one or more arguments. The first argument identifies the vector,
                     matrix or list from which the selection is taking place, and the second and subsequent
                     arguments, if any, indicate the kind of selection taking place.
                  </p>
                  <p>When <code>selector</code> is used with a single argument, it should be interpreted as
                     giving the sequence of all elements in the list, vector or matrix given. The ordering
                     of elements in the sequence for a matrix is understood to be first by column, then by
                     row; so the resulting list is of matrix rows given entry by entry.  
                     That is, for a matrix (<var>a</var><sub>i,j</sub>), where the indices denote row
                     and column, respectively, the ordering would be <var>a</var><sub>1,1</sub>, 
                     <var>a</var><sub>1,2</sub>, ...  <var>a</var><sub>2,1</sub>, <var>a</var><sub>2,2</sub>
                     ... etc.
                  </p>
                  <p>When two arguments are given, and the first is a vector or list, the second argument
                     specifies the index of an entry in the list or vector. If the first argument is a matrix then
                     the second argument specifies the index of a matrix row.
                  </p>
                  <p>When three arguments are given, the last one is ignored for a list or vector, and
                     in the case of a matrix, the second and third arguments specify the row and column indices of
                     the selected element.
                  </p>
                  <div class="mathml-example" id="linalg1.vector.selector.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;selector/&gt;&lt;ci type="vector"&gt;V&lt;/ci&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;msub&gt;&lt;mi&gt;V&lt;/mi&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/msub&gt;</pre><blockquote>
                        <p><img src="image/linalg1-vector_selector-ex1.gif" alt="\msub{V}{{1}}"></p>
                     </blockquote>
                  </div>
                  <div class="mathml-example" id="linalg1.matrix.selector.ex2">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;selector/&gt;
    &lt;matrix&gt;
      &lt;matrixrow&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/matrixrow&gt;
      &lt;matrixrow&gt;&lt;cn&gt;3&lt;/cn&gt;&lt;cn&gt;4&lt;/cn&gt;&lt;/matrixrow&gt;
    &lt;/matrix&gt;
    &lt;cn&gt;1&lt;/cn&gt;
  &lt;/apply&gt;
  &lt;matrix&gt;
    &lt;matrixrow&gt;&lt;cn&gt;1&lt;/cn&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/matrixrow&gt;
  &lt;/matrix&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;msub&gt;
  &lt;mrow&gt;
   &lt;mo&gt;(&lt;/mo&gt;
   &lt;mtable&gt;
    &lt;mtr&gt;&lt;mtd&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mtd&gt;&lt;/mtr&gt;
    &lt;mtr&gt;&lt;mtd&gt;&lt;mn&gt;3&lt;/mn&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mn&gt;4&lt;/mn&gt;&lt;/mtd&gt;&lt;/mtr&gt;
   &lt;/mtable&gt;
   &lt;mo&gt;)&lt;/mo&gt;
  &lt;/mrow&gt;
  &lt;mn&gt;1&lt;/mn&gt;
 &lt;/msub&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mo&gt;(&lt;/mo&gt;
  &lt;mtable&gt;&lt;mtr&gt;&lt;mtd&gt;&lt;mn&gt;1&lt;/mn&gt;&lt;/mtd&gt;&lt;mtd&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/mtd&gt;&lt;/mtr&gt;&lt;/mtable&gt;
  &lt;mo&gt;)&lt;/mo&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg1-matrix_selector-ex2.gif" alt="\msub{\left({\begin{matrix} 1\endcell 2\\ 3\endcell 4\end{matrix}}\right)}{1}=\left(\begin{matrix} 1\endcell 2\end{matrix}\right)"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.vectorproduct" id="contm.vectorproduct"></a>4.4.9.7 Vector product <code>&lt;vectorproduct/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-linalg</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/linalg1.xhtml#vectorproduct">vectorproduct</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the vector product. It takes two three-dimensional vector arguments 
                     and represents as value a three-dimensional vector.
                  </p>
                  <div class="mathml-example" id="linalg1.vectorproduct.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;vectorproduct/&gt;
    &lt;ci type="vector"&gt; A &lt;/ci&gt;
    &lt;ci type="vector"&gt; B &lt;/ci&gt;
 &lt;/apply&gt;
  &lt;apply&gt;&lt;times/&gt;
    &lt;ci&gt;a&lt;/ci&gt;
    &lt;ci&gt;b&lt;/ci&gt;
    &lt;apply&gt;&lt;sin/&gt;&lt;ci&gt;&amp;#x3b8;&lt;/ci&gt;&lt;/apply&gt;
    &lt;ci type="vector"&gt; N &lt;/ci&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#xd7;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mi&gt;a&lt;/mi&gt;
  &lt;mo&gt;&amp;#x2062;&lt;/mo&gt;
  &lt;mi&gt;b&lt;/mi&gt;
  &lt;mo&gt;&amp;#x2062;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;sin&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;&amp;#x3b8;&lt;/mi&gt;&lt;/mrow&gt;
  &lt;mo&gt;&amp;#x2062;&lt;/mo&gt;
  &lt;mi&gt;N&lt;/mi&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg1-vectorproduct-ex1.gif" alt="{{A\unicode{215}B}={a\unicode{8290}b\unicode{8290}{\mathop{{\minormal{sin}}}\unicode{952}}\unicode{8290}N}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.scalarproduct" id="contm.scalarproduct"></a>4.4.9.8 Scalar product <code>&lt;scalarproduct/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-linalg</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/linalg1.xhtml#scalarproduct">scalarproduct</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the scalar product function. It takes two vector arguments 
                     and returns a scalar value.
                  </p>
                  <div class="mathml-example" id="linalg1.scalarproduct.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;scalarproduct/&gt;
    &lt;ci type="vector"&gt;A&lt;/ci&gt;
    &lt;ci type="vector"&gt;B&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;apply&gt;&lt;times/&gt;
    &lt;ci&gt;a&lt;/ci&gt;
    &lt;ci&gt;b&lt;/ci&gt;
    &lt;apply&gt;&lt;cos/&gt;&lt;ci&gt;&amp;#x3b8;&lt;/ci&gt;&lt;/apply&gt;
  &lt;/apply&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;.&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mrow&gt;
  &lt;mi&gt;a&lt;/mi&gt;
  &lt;mo&gt;&amp;#x2062;&lt;/mo&gt;
  &lt;mi&gt;b&lt;/mi&gt;
  &lt;mo&gt;&amp;#x2062;&lt;/mo&gt;
  &lt;mrow&gt;&lt;mi&gt;cos&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;&amp;#x3b8;&lt;/mi&gt;&lt;/mrow&gt;
 &lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg1-scalarproduct-ex1.gif" alt="{{A.B}={a\unicode{8290}b\unicode{8290}{\mathop{{\minormal{cos}}}\unicode{952}}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.outerproduct" id="contm.outerproduct"></a>4.4.9.9 Outer product <code>&lt;outerproduct/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.binary">binary-linalg</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/linalg1.xhtml#outerproduct">outerproduct</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the outer product function. It takes two vector arguments 
                     and returns as value a matrix.
                  </p>
                  <div class="mathml-example" id="linalg1.outerproduct.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;outerproduct/&gt;
  &lt;ci type="vector"&gt;A&lt;/ci&gt;
  &lt;ci type="vector"&gt;B&lt;/ci&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;A&lt;/mi&gt;&lt;mo&gt;&amp;#x2297;&lt;/mo&gt;&lt;mi&gt;B&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/linalg1-outerproduct-ex1.gif" alt="{A\unicode{8855}B}"></p>
                     </blockquote>
                  </div>
               </div>
            </div>
            <div class="div3">
               
               <h3><a name="contm.constantsandsymbols" id="contm.constantsandsymbols"></a>4.4.10 Constant and Symbol Elements
               </h3>
               <p>This section explains the use of the Constant and Symbol elements.</p>
               <div class="div4">
                  
                  <h4><a name="contm.integers" id="contm.integers"></a>4.4.10.1 integers <code>&lt;integers/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/setname1.xhtml#Z">Z</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the set of integers, positive, negative and zero.</p>
                  <div class="mathml-example" id="setname1.integers.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;
  &lt;cn type="integer"&gt; 42 &lt;/cn&gt;
  &lt;integers/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;42&lt;/mn&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;Z&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/setname1-integers-ex1.gif" alt="{{42}\unicode{8712}{\midoublestruck{Z}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.reals" id="contm.reals"></a>4.4.10.2 reals <code>&lt;reals/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/setname1.xhtml#R">R</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the set of real numbers.</p>
                  <div class="mathml-example" id="setname1.reals.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;
  &lt;cn type="real"&gt; 44.997&lt;/cn&gt;
  &lt;reals/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mn&gt;44.997&lt;/mn&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;R&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/setname1-reals-ex1.gif" alt="{{44.997}\unicode{8712}{\midoublestruck{R}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.rationals" id="contm.rationals"></a>4.4.10.3 Rational Numbers <code>&lt;rationals/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/setname1.xhtml#Q">Q</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the set of rational numbers.</p>
                  <div class="mathml-example" id="setname1.rationals.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;
  &lt;cn type="rational"&gt; 22 &lt;sep/&gt;7&lt;/cn&gt;
  &lt;rationals/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mn&gt;22&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;7&lt;/mn&gt;&lt;/mrow&gt;
 &lt;mo&gt;&amp;#x2208;&lt;/mo&gt;
 &lt;mi mathvariant="double-struck"&gt;Q&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/setname1-rationals-ex1.gif" alt="{{{22}/{7}}\unicode{8712}{\midoublestruck{Q}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.naturalnumbers" id="contm.naturalnumbers"></a>4.4.10.4 Natural Numbers <code>&lt;naturalnumbers/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/setname1.xhtml#N">N</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the set of natural numbers (including zero).</p>
                  <div class="mathml-example" id="setname1.naturalnumbers.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;
  &lt;cn type="integer"&gt;1729&lt;/cn&gt;
  &lt;naturalnumbers/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mn&gt;1729&lt;/mn&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;N&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/setname1-naturalnumbers-ex1.gif" alt="{{1729}\unicode{8712}{\midoublestruck{N}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.complexes" id="contm.complexes"></a>4.4.10.5 complexes <code>&lt;complexes/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/setname1.xhtml#C">C</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the set of complex numbers.</p>
                  <div class="mathml-example" id="setname1.complexes.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;
  &lt;cn type="complex-cartesian"&gt;17&lt;sep/&gt;29&lt;/cn&gt;
  &lt;complexes/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mn&gt;17&lt;/mn&gt;&lt;mo&gt;+&lt;/mo&gt;&lt;mn&gt;29&lt;/mn&gt;&lt;mo&gt;&amp;#x2062;&lt;/mo&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;&amp;#x2208;&lt;/mo&gt;
 &lt;mi mathvariant="double-struck"&gt;C&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/setname1-complexes-ex1.gif" alt="{{{17}+{29}\unicode{8290}i}\unicode{8712}{\midoublestruck{C}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.primes" id="contm.primes"></a>4.4.10.6 primes <code>&lt;primes/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/setname1.xhtml#P">P</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the set of positive prime numbers.</p>
                  <div class="mathml-example" id="setname1.primes.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;in/&gt;
  &lt;cn type="integer"&gt;17&lt;/cn&gt;
  &lt;primes/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mn&gt;17&lt;/mn&gt;&lt;mo&gt;&amp;#x2208;&lt;/mo&gt;&lt;mi mathvariant="double-struck"&gt;P&lt;/mi&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/setname1-primes-ex1.gif" alt="{{17}\unicode{8712}{\midoublestruck{P}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.exponentiale" id="contm.exponentiale"></a>4.4.10.7 Exponential e <code>&lt;exponentiale/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/nums1.xhtml#e">e</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the base of the natural logarithm, approximately 2.718.</p>
                  <div class="mathml-example" id="nums1.exponentiale.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;ln/&gt;&lt;exponentiale/&gt;&lt;/apply&gt;
  &lt;cn&gt;1&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;ln&lt;/mi&gt;&lt;mo&gt;&amp;#x2061;&lt;/mo&gt;&lt;mi&gt;e&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mn&gt;1&lt;/mn&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/nums1-exponentiale-ex1.gif" alt="{{\mathop{{\minormal{ln}}}e}={1}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.imaginaryi" id="contm.imaginaryi"></a>4.4.10.8 Imaginary i <code>&lt;imaginaryi/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/nums1.xhtml#i">i</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the mathematical constant which is the square root of -1, 
                     commonly written i
                  </p>
                  <div class="mathml-example" id="nums1.imaginaryi.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;power/&gt;&lt;imaginaryi/&gt;&lt;cn&gt;2&lt;/cn&gt;&lt;/apply&gt;
  &lt;cn&gt;-1&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;msup&gt;&lt;mi&gt;i&lt;/mi&gt;&lt;mn&gt;2&lt;/mn&gt;&lt;/msup&gt;&lt;mo&gt;=&lt;/mo&gt;&lt;mn&gt;-1&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/nums1-imaginaryi-ex1.gif" alt="{\msup{i}{{2}}={\mn{-1}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.notanumber" id="contm.notanumber"></a>4.4.10.9 Not A Number <code>&lt;notanumber/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/nums1.xhtml#NaN">NaN</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the notion of not-a-number, i.e. the result of an ill-posed 
                     floating computation. See <a href="appendixh-d.html#IEEE754">[IEEE754]</a>.
                  </p>
                  <div class="mathml-example" id="nums1.notanumber.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;divide/&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;cn&gt;0&lt;/cn&gt;&lt;/apply&gt;
  &lt;notanumber/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;0&lt;/mn&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mi&gt;NaN&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/nums1-notanumber-ex1.gif" alt="{{{0}/{0}}={\minormal{NaN}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.true" id="contm.true"></a>4.4.10.10 True <code>&lt;true/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#true">true</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the Boolean value true, i.e. the logical constant for truth.</p>
                  <div class="mathml-example" id="logic1.true.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;or/&gt;
    &lt;true/&gt;
     &lt;ci type="boolean"&gt;P&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;true/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;true&lt;/mi&gt;&lt;mo&gt;&amp;#x2228;&lt;/mo&gt;&lt;mi&gt;P&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mi&gt;true&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-true-ex1.gif" alt="{{{\minormal{true}}\unicode{8744}P}={\minormal{true}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.false" id="contm.false"></a>4.4.10.11 False <code>&lt;false/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/logic1.xhtml#false">false</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the Boolean value false, i.e. the logical constant for falsehood.</p>
                  <div class="mathml-example" id="logic1.false.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;eq/&gt;
  &lt;apply&gt;&lt;and/&gt;
    &lt;false/&gt;
    &lt;ci type="boolean"&gt;P&lt;/ci&gt;
  &lt;/apply&gt;
  &lt;false/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mrow&gt;&lt;mi&gt;false&lt;/mi&gt;&lt;mo&gt;&amp;#x2227;&lt;/mo&gt;&lt;mi&gt;P&lt;/mi&gt;&lt;/mrow&gt;
 &lt;mo&gt;=&lt;/mo&gt;
 &lt;mi&gt;false&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/logic1-false-ex1.gif" alt="{{{\minormal{false}}\unicode{8743}P}={\minormal{false}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.emptyset" id="contm.emptyset"></a>4.4.10.12 Empty Set <code>&lt;emptyset/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-set</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/set1.xhtml#emptyset">emptyset</a>, 
                              <a href="http://www.openmath.org/cd/multiset1.xhtml#emptyset">emptyset</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element is used to represent the empty set, that is the set which contains no members.</p>
                  <div class="mathml-example" id="set1.emptyset.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;neq/&gt;
  &lt;integers/&gt;
  &lt;emptyset/&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi mathvariant="double-struck"&gt;Z&lt;/mi&gt;&lt;mo&gt;&amp;#x2260;&lt;/mo&gt;&lt;mi&gt;&amp;#x2205;&lt;/mi&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/set1-emptyset-ex1.gif" alt="{{\midoublestruck{Z}}\unicode{8800}\unicode{8709}}"></p>
                     </blockquote>
                     <p><em>Mapping to Strict Markup</em></p>
                     <p>In some situations, it may be clear from context that <code>emptyset</code> 
                        corresponds to the <a href="http://www.openmath.org/cd/multiset1.xhtml#emptyset">emptyset</a> 
                        However, as there is no method other than annotation for an author to explicitly indicate this,
                        it is always acceptable to translate to the  <a href="http://www.openmath.org/cd/set1.xhtml#emptyset">emptyset</a> symbol from the <a href="http://www.openmath.org/cd/set1.xhtml">set1</a> CD.
                     </p>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.pi" id="contm.pi"></a>4.4.10.13 pi <code>&lt;pi/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/nums1.xhtml#pi">pi</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents pi, approximately 3.142, which is the
                     ratio of the circumference of a circle to its diameter.
                  </p>
                  <div class="mathml-example" id="nums1.pi.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;approx/&gt;
  &lt;pi/&gt;
  &lt;cn type="rational"&gt;22&lt;sep/&gt;7&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;
 &lt;mi&gt;&amp;#x3c0;&lt;/mi&gt;
 &lt;mo&gt;&amp;#x2243;&lt;/mo&gt;
 &lt;mrow&gt;&lt;mn&gt;22&lt;/mn&gt;&lt;mo&gt;/&lt;/mo&gt;&lt;mn&gt;7&lt;/mn&gt;&lt;/mrow&gt;
&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/nums1-pi-ex1.gif" alt="{\unicode{960}\unicode{8771}{{22}/{7}}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.eulergamma" id="contm.eulergamma"></a>4.4.10.14 Euler gamma <code>&lt;eulergamma/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/nums1.xhtml#gamma">gamma</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element denotes the gamma constant, approximately 0.5772.</p>
                  <div class="mathml-example" id="nums1.eulergamma.ex1">
                     <p>Content MathML</p><pre class="mathml">
&lt;apply&gt;&lt;approx/&gt;
  &lt;eulergamma/&gt;
  &lt;cn&gt;0.5772156649&lt;/cn&gt;
&lt;/apply&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mrow&gt;&lt;mi&gt;&amp;#x3b3;&lt;/mi&gt;&lt;mo&gt;&amp;#x2243;&lt;/mo&gt;&lt;mn&gt;0.5772156649&lt;/mn&gt;&lt;/mrow&gt;</pre><blockquote>
                        <p><img src="image/nums1-eulergamma-ex1.gif" alt="{\unicode{947}\unicode{8771}{0.5772156649}}"></p>
                     </blockquote>
                  </div>
               </div>
               <div class="div4">
                  
                  <h4><a name="contm.infinity" id="contm.infinity"></a>4.4.10.15 infinity <code>&lt;infinity/&gt;</code></h4>
                  <table class="syntax">
                     <tbody>
                        <tr>
                           <th>Class</th>
                           <td><a href="chapter4-d.html#contm.constant">constant-arith</a></td>
                        </tr>
                        <tr>
                           <th>Attributes</th>
                           <td><a href="appendixa-d.html#parsing_CommonAtt">CommonAtt</a>, <a href="appendixa-d.html#parsing_DefEncAtt">DefEncAtt</a></td>
                        </tr>
                        <tr>
                           <th>Content</th>
                           <td>Empty</td>
                        </tr>
                        <tr>
                           <th>OM Symbols</th>
                           <td><a href="http://www.openmath.org/cd/nums1.xhtml#infinity">infinity</a></td>
                        </tr>
                     </tbody>
                  </table>
                  <p>This element represents the notion of infinity.</p>
                  <div class="mathml-example" id="nums1.infinity.ex1">
                     <p>Content MathML</p><pre class="mathml">&lt;infinity/&gt;</pre><p>Sample Presentation</p><pre class="mathml">
&lt;mi&gt;&amp;#x221e;&lt;/mi&gt;</pre><blockquote>
                        <p><img src="image/nums1-infinity-ex1.gif" alt="\unicode{8734}"></p>
                     </blockquote>
                  </div>
               </div>
            </div>
         </div>
         <div class="div2">
            
            <h2><a name="contm.deprecated" id="contm.deprecated"></a>4.5 Deprecated Content Elements
            </h2>
            <div class="div3">
               
               <h3><a name="contm.declare" id="contm.declare"></a>4.5.1 Declare <code>&lt;declare&gt;</code></h3>
               <p>MathML2 provided the <code>declare</code> element to bind properties like
                  types to symbols and variables and to define abbreviations for structure sharing. This
                  element is deprecated in MathML 3. Structure sharing can obtained via the <code>share</code>
                  element (see <a href="chapter4-d.html#contm.sharing">Section&nbsp;4.2.7 Structure Sharing <code>&lt;share&gt;</code></a> for details).
               </p>
            </div>
         </div>
         <div class="div2">
            
            <h2><a name="contm.p2s" id="contm.p2s"></a>4.6 The Strict Content MathML Transformation
            </h2>
            <p>MathML 3 assigns semantics to content markup by defining a
               mapping to Strict Content MathML.  Strict MathML, in turn, is in
               one-to-one correspondence with OpenMath, and the subset of
               OpenMath expressions obtained from content MathML expressions in
               this fashion all have well-defined semantics via the standard
               OpenMath Content Dictionary set.  Consequently, the mapping of
               arbitrary content MathML expressions to equivalent Strict Content
               MathML plays a key role in underpinning the meaning of content
               MathML.
            </p>
            <p>The mapping of arbitrary content MathML into Strict content
               MathML is defined algorithmically. The algorithm is described
               below as a collection of rewrite rules applying to specific
               non-Strict constructions.  The individual rewrite transformations
               have been described in detail in context above.  The goal of this
               section is to outline the complete algorithm in one place.
            </p>
            <p>The algorithm is a sequence of nine steps.  Each step is
               applied repeatedly to rewrite the input until no further
               application is possible. Note that in many programming languages,
               such as XSLT, the natural implementation is as a recursive
               algorithm, rather than the multi-pass implementation suggested by
               the description below. The translation to XSL is straightforward
               and produces the same eventual Strict Content MathML.  However,
               because the overall structure of the multi-pass algorithm is
               clearer, that is the formulation given here.
            </p>
            <p>To transform an arbitrary content MathML expression into
               Strict Content MathML, apply each of the following rules in turn
               to the input expression until all instances of the target
               constructs have been eliminated:
            </p>
            <ol type="1">
               <li>
                  <p><em>Rewrite non-strict <code>bind</code> and elminate deprecated elements</em>: 
                     Change the outer <code>bind</code> tags
                     in binding expressions to <code>apply</code> if they have qualifiers or multiple
                     children. This simplifies the algorithm by allowing the subsequent rules to be applied
                     to non-strict binding expressions without case distinction. Note
                     that the later
                     rules will change the <code>apply</code> elements introduced in this step back to
                     <code>bind</code> elements. Also in this step, deprecated <code>reln</code> 
                     elements are rewritten to <code>apply</code>, and <code>fn</code> elements are replaced by 
                     the child expressions they enclose.
                  </p>
               </li>
               <li>
                  <p><em>Apply special case rules for idiomatic uses of qualifiers</em>:
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p>Rewrite derivatives with rules <a href="chapter4-d.html#contm.p2s.diff">Rewrite: diff</a>, <a href="chapter4-d.html#contm.p2s.nthdiff">Rewrite: nthdiff</a>, 
                           and <a href="chapter4-d.html#contm.p2s.partialdiff">Rewrite: partialdiffdegree</a>
                           to explicate the binding status of the variables involved.  
                           
                        </p>
                     </li>
                     <li>
                        <p>Rewrite integrals with the rules <a href="chapter4-d.html#contm.p2s.int">Rewrite: int</a>,  <a href="chapter4-d.html#contm.p2s.defint">Rewrite: defint</a>
                           and <a href="chapter4-d.html#contm.p2s.int.LUlimit">Rewrite: defint limits</a> to disambiguate the status 
                           of bound and free variables and of the orientation of the range of integration if
                           it is given as a <code>lowlimit</code>/<code>uplimit</code> pair.
                           
                        </p>
                     </li>
                     <li>
                        <p>Rewrite limits as described in <a href="chapter4-d.html#contm.strict.tendsto">Rewrite: tendsto</a> and <a href="chapter4-d.html#contm.strict-limit">Rewrite: limits condition</a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite sums and products as described in
                           <a href="chapter4-d.html#contm.sum">Section&nbsp;4.4.6.1 Sum <code>&lt;sum/&gt;</code></a> and <a href="chapter4-d.html#contm.product">Section&nbsp;4.4.6.2 Product <code>&lt;product/&gt;</code></a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite roots as described in <a href="chapter4-d.html#contm.root">Section&nbsp;4.4.2.11 Root <code>&lt;root/&gt;</code></a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite logarithms as described in <a href="chapter4-d.html#contm.log">Section&nbsp;4.4.7.4 Logarithm <code>&lt;log/&gt;</code></a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite moments as described in <a href="chapter4-d.html#contm.moment">Section&nbsp;4.4.8.6 Moment (<code>&lt;moment/&gt;</code>, <code>&lt;momentabout&gt;</code>)</a>.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Rewrite Qualifiers to <code>domainofapplication</code></em>:
                     These rules rewrite all <code>apply</code> constructions using <code>bvar</code> and 
                     qualifiers to those using only the general <code>domainofapplication</code> qualifier.
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p><em>Intervals</em>: Rewrite qualifiers given as <code>interval</code> and
                           <code>lowlimit</code>/<code>uplimit</code> to intervals of integers via
                           <a href="chapter4-d.html#contm.limits-strict">Rewrite: interval qualifier</a>.
                        </p>
                     </li>
                     <li>
                        <p><em>Multiple <code>condition</code>s</em>: Rewrite multiple <code>condition</code> 
                           qualifiers to a single one by taking their conjunction. The resulting compound 
                           <code>condition</code> is then rewritten to <code>domainofapplication</code> according 
                           to rule <a href="chapter4-d.html#contm.condition-strict">Rewrite: condition</a>.
                        </p>
                     </li>
                     <li>
                        <p><em>Multiple <code>domainofapplication</code>s</em>: Rewrite multiple
                           <code>domainofapplication</code> qualifiers to a single one by taking the
                           intersection of the specified domains.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Normalize Container Markup</em>:
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p>Rewrite sets and lists by the rule 
                           <a href="chapter4-d.html#contm.rewrite.setliste">Rewrite: n-ary setlist domainofapplication</a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite interval, vectors, matrices, and matrix rows
                           as described in <a href="chapter4-d.html#contm.interval">Section&nbsp;4.4.1.1 Interval <code>&lt;interval&gt;</code></a>, <a href="chapter4-d.html#contm.vector">Section&nbsp;4.4.9.1 Vector <code>&lt;vector&gt;</code></a>, 
                           <a href="chapter4-d.html#contm.matrix">Section&nbsp;4.4.9.2 Matrix <code>&lt;matrix&gt;</code></a> and <a href="chapter4-d.html#contm.matrixrow">Section&nbsp;4.4.9.3 Matrix row <code>&lt;matrixrow&gt;</code></a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite lambda expressions by the rules <a href="chapter4-d.html#contm.rewrite.lambda">Rewrite: lambda</a>
                           and <a href="chapter4-d.html#contm.rewrite.lambda.domofa">Rewrite: lambda domainofapplication</a></p>
                     </li>
                     <li>
                        <p>Rewrite piecewise functions as described in <a href="chapter4-d.html#contm.piecewise">Section&nbsp;4.4.1.9 Piecewise declaration (<code>&lt;piecewise&gt;</code>, <code>&lt;piece&gt;</code>, <code>&lt;otherwise&gt;</code>)</a>.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Apply Special Case Rules for Operators using <code>domainofapplication</code> Qualifiers</em>: 
                     This step deals with the special cases for the operators introduced in 
                     <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a>. There are different classes of special cases to be taken into account: 
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p>Rewrite <code>min</code>, <code>max</code>, <code>mean</code> and similar n-ary/unary operators
                           by the rules <a href="chapter4-d.html#contm.p2s.max">Rewrite: n-ary unary set</a>, <a href="chapter4-d.html#contm.unary.nary.doma">Rewrite: n-ary unary domainofapplication</a> 
                           and <a href="chapter4-d.html#contm.nary.unary.single">Rewrite: n-ary unary single</a>.
                           
                        </p>
                     </li>
                     <li>
                        <p>Rewrite the quantifiers <code>forall</code> and <code>exists</code> used with <code>domainofapplication</code>
                           to expressions using implication and conjunction by the rule <a href="chapter4-d.html#contm.rewrite.quantifier">Rewrite: quantifier</a>.
                           
                        </p>
                     </li>
                     <li>
                        <p>Rewrite integrals used with a <code>domainofapplication</code> element (with or without a <code>bvar</code>) 
                           	    according to the rules <a href="chapter4-d.html#contm.p2s.int">Rewrite: int</a> and
                           	    <a href="chapter4-d.html#contm.p2s.defint">Rewrite: defint</a>.
                           
                        </p>
                     </li>
                     <li>
                        <p>Rewrite sums and products used with a <code>domainofapplication</code> element 
                           	  (with or without a <code>bvar</code>) as described in 
                           	  <a href="chapter4-d.html#contm.sum">Section&nbsp;4.4.6.1 Sum <code>&lt;sum/&gt;</code></a> and <a href="chapter4-d.html#contm.product">Section&nbsp;4.4.6.2 Product <code>&lt;product/&gt;</code></a>.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Eliminate <code>domainofapplication</code></em>: At this stage, any
                     <code>apply</code> has at most one <code>domainofapplication</code> child and special cases have been addressed. As
                     <code>domainofapplication</code> is not Strict Content MathML, it is rewritten
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p>into an application of a restricted function via the rule
                           <a href="chapter4-d.html#contm.strict-doa">Rewrite: restriction</a> if the <code>apply</code> does not contain 
                           a <code>bvar</code> child.
                        </p>
                     </li>
                     <li>
                        <p>into an application of the <a href="http://www.openmath.org/cd/fns2.xhtml#predicate_on_list">predicate_on_list</a> symbol via the rules
                           <a href="chapter4-d.html#contm.rewrite.reln">Rewrite: n-ary relations</a> and <a href="chapter4-d.html#contm.rewrite.reln.bvar">Rewrite: n-ary relations bvar</a> 
                           if used with a relation.
                        </p>
                     </li>
                     <li>
                        <p>into a construction with the <a href="http://www.openmath.org/cd/fns2.xhtml#apply_to_list">apply_to_list</a> symbol
                           via the general rule <a href="chapter4-d.html#contm.p2s.lifted">Rewrite: n-ary domainofapplication</a> for
                           general n-ary operators.
                           
                        </p>
                     </li>
                     <li>
                        <p>into a construction using the <a href="http://www.openmath.org/cd/set1.xhtml#suchthat">suchthat</a> symbol
                           from the <a href="http://www.openmath.org/cd/set1.xhtml">set1</a> content dictionary in an <code>apply</code> with bound
                           variables via the <a href="chapter4-d.html#contm.dombind-strict">Rewrite: apply bvar domainofapplication</a> rule.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Rewrite non-strict token elements</em>:
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p>Rewrite numbers represented as <code>cn</code> elements where the <code>type</code> 
                           	    attribute is one of "e-notation", "rational",
                           	    "complex-cartesian", "complex-polar",
                           	    "constant" as strict <code>cn</code> via rules 
                           	    <a href="chapter4-d.html#contm-strict-cn-sep">Rewrite: cn sep</a>, <a href="chapter4-d.html#contm.cn-base">Rewrite: cn based_integer</a> 
                           	    and <a href="chapter4-d.html#contm.cn.strict.const">Rewrite: cn constant</a>.
                        </p>
                     </li>
                     <li>
                        <p>Rewrite any <code>ci</code>, <code>csymbol</code> or <code>cn</code> containing
                           	    presentation MathML to <code>semantics</code> elements with rules  
                           	    <a href="chapter4-d.html#contm.cn.pres">Rewrite: cn presentation mathml</a> and <a href="chapter4-d.html#contm.ci.pres">Rewrite: ci presentation mathml</a> and 
                           	    the analogous rule for <code>csymbol</code>.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Rewrite operators</em>: Rewrite any remaining operator defined in <a href="chapter4-d.html#contm.opel">Section&nbsp;4.4 Content MathML for Specific Operators and Constants</a> 
                     to a <code>csymbol</code> referencing the symbol identified in the syntax table by the rule 
                     <a href="chapter4-d.html#contm.strict-opel">Rewrite: element</a>. As noted in the descriptions of each 
                     	operator element, some require special case rules to determine the proper choice of symbol.  
                     	Some cases of particular note are:
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p>The order of the arguments for the
                           	    <a href="chapter4-d.html#contm.selector"><code>selector</code></a> operator must be 
                           	    rewritten, and the symbol depends on the type of the arguments.
                        </p>
                     </li>
                     <li>
                        <p>The choice of symbol for the <a href="chapter4-d.html#contm.minus"><code>minus</code></a> 
                           	    operator depends on the number of the arguments.
                        </p>
                     </li>
                     <li>
                        <p>The choice of symbol for some set operators depends on the values of 
                           	    the <code>type</code> of the arguments.
                        </p>
                     </li>
                     <li>
                        <p>The choice of symbol for some statistical operators depends on the values of 
                           	    the types of the arguments.
                        </p>
                     </li>
                  </ol>
               </li>
               <li>
                  <p><em>Rewrite non-strict attributes</em>: 
                     
                  </p>
                  <ol type="a">
                     <li>
                        <p><em>Rewrite the <code>type</code> attribute</em>:
                           	    At this point, all elements 
                           that accept the <code>type</code>, other than <code>ci</code> and <code>csymbol</code>, should have been
                           rewritten into Strict Content Markup equivalents without <code>type</code> attributes, 
                           where type information is reflected in the choice of operator symbol. Now rewrite remaining
                           <code>ci</code> and <code>csymbol</code> elements with a <code>type</code> attribute to a
                           strict expression with <code>semantics</code> according to rules
                           <a href="chapter4-d.html#contm.ci.strict.ex">Rewrite: ci type annotation</a> and <a href="chapter4-d.html#contm.csymbol.strict.ex">Rewrite: csymbol type annotation</a>.  
                        </p>
                     </li>
                     <li>
                        <p><em>Rewrite <code>definitionURL</code> and <code>encoding</code> attributes</em>: 
                           	    If the <code>definitionURL</code> and <code>encoding</code> attributes on a 
                           	    <code>csymbol</code> element can be interpreted as a reference to a
                           	    content dictionary (see <a href="chapter4-d.html#contm.csymbol.extended">Section&nbsp;4.2.3.2 Non-Strict uses of <code>&lt;csymbol&gt;</code></a> for details), then
                           	    rewrite to reference the content dictionary by the <code>cd</code> attribute instead. 
                           	  
                        </p>
                     </li>
                     <li>
                        <p><em>Rewrite attributes</em>: Rewrite any element with attributes that are
                           	    not allowed in strict markup to a <code>semantics</code> construction with
                           	    the element without these attributes as the first child and the attributes in
                           	    <code>annotation</code> elements by rule <a href="chapter4-d.html#contm.strict-attributes">Rewrite: attributes</a>.
                        </p>
                     </li>
                  </ol>
               </li>
            </ol>
         </div>
      </div>
      <div class="minitoc">
         
         Overview: <a href="Overview-d.html">Mathematical Markup Language (MathML) Version 3.0</a><br>
         Previous:     3 <a href="chapter3-d.html">Presentation Markup</a><br>
         Next:     5 <a href="chapter5-d.html">Mixing Markup Languages for Mathematical Expressions</a></div>
   </body>
</html>